text
stringlengths 8
6.88M
|
|---|
// Последовательность Фибоначчи определяется так:
// F(0) = 0, F(1) = 1, …, F(n) = F(n−1) + F(n−2).
// Дано натуральное число A. Определите, каким по счету числом Фибоначчи оно является,
// то есть выведите такое число N, что F(N) = A. Если А не является числом Фибоначчи, выведите число -1.
// Формат входных данных
// Вводится натуральное число A > 1.
// Формат выходных данных
// Выведите ответ на задачу.
#include <iostream>
using namespace std;
int main() {
int f1 = 1, f2 = 1, it = 2, n;
cin >> n;
while (f2 < n) {
int tmp=f2;
f2 += f1;
f1 = tmp;
it++;
}
if (f2==n) {
cout << it;
} else {
cout << -1;
}
return 0;
}
|
#ifndef F3LIB_IO_FILESYSTEM_H_
#define F3LIB_IO_FILESYSTEM_H_
#include <istream>
namespace f3 {
namespace io {
class FileHandle
{
public:
~FileHandle();
std::istream& getStream();
protected:
explicit FileHandle();
};
class FileSystem
{
public:
/** Creates a new file system at the given rootPath */
explicit FileSystem(const std::string& rootPath);
/** Opens the file at filePath relative to the FileSystem's rootPath or nullptr if the file could not be found. */
FileHandle* openFile(const std::string& filePath);
private:
};
} // namespace io
} // namespace f3
#endif // F3LIB_IO_FILESYSTEM_H_
|
#include <iostream>
#include <stdlib.h>
#include <unistd.h>
#include <fstream>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <string.h>
using namespace std;
#define PORT 8001
#define SERVERADD "127.0.0.1"
void die(char *s)
{
perror(s);
exit(1);
}
int main()
{
struct sockaddr_in sadd;
int sockfd;
if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) == -1)
{
die("Socket error");
}
//define structure
sadd.sin_family = AF_INET;
sadd.sin_port = htons(PORT);
sadd.sin_addr.s_addr = inet_addr(SERVERADD);
int msg_len;
socklen_t cli = sizeof(sadd);
int slen = sizeof(sadd);
cout << "Enter msg to send\n";
char buffer[1000];
bzero((char *)buffer, sizeof(buffer));
cin.getline(buffer, sizeof(buffer));
msg_len = sendto(sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&sadd, slen);
if (msg_len == -1)
{
die("Error");
}
else
{
cout << "Succecsfhuvd";
}
int ch;
do
{
cout << "1. Send 2. Recve 3.ezdxirt \n";
cin >> ch;
switch (ch)
{
case 1:
{
char filename[100];
cout << "Enter the file name \n";
cin >> filename;
fstream fout;
fout.open(filename, ios::binary | ios::in);
fout.seekg(0,ios::end);
int filesize = fout.tellg();
char* buff = new char[filesize];
fout.seekg(0,ios::beg);
fout.read(buff, filesize);
int msg_len;
msg_len = sendto(sockfd, filename, 99, 0, (struct sockaddr*)&sadd, slen);
if (msg_len == -1)
die("Filename cha error");
msg_len = sendto(sockfd, (void *)&filesize, sizeof(filesize), 0, (struct sockaddr*)&sadd, slen);
if (msg_len == -1)
die("Filesize cha error");
msg_len = sendto(sockfd, buff, filesize, 0, (struct sockaddr*)&sadd, slen);
if (msg_len == -1)
die("bufff cha error");
else
{
cout << "Sexess";
}
}
break;
default:
break;
}
} while (ch != 3);
}
|
#include "DDSLoad.h"
#include "../__trash.h"
GLuint loadDDS(const char * imagepath)
{
DDS_HEADER header;
FILE *fp;
printf("%s could not be\n", imagepath);
/* try to open the file */
fp = fopen(imagepath, "rb");
if (fp == NULL){
printf("%s could not be opened. Are you in the right directory ? Don't forget to read the FAQ !\n", imagepath); getchar();
return 0;
}
fseek(fp, 0, SEEK_END);
long file_size = ftell(fp);
fseek(fp, 0, SEEK_SET);
/* verify the type of file */
void *filecode = malloc(sizeof(uint32_t));
fread(filecode, sizeof(uint32_t), 1, fp);
if (strncmp(filecode, "DDS ", 4) != 0)
{
printf("Not a .DDS image!\n");
fclose(fp);
return 0;
}
/* get the surface desc */
fread(&(header.size), sizeof(uint32_t), 1, fp);
fread(&(header.flags), sizeof(uint32_t), 1, fp);
fread(&(header.height), sizeof(uint32_t), 1, fp);
fread(&(header.width), sizeof(uint32_t), 1, fp);
fread(&(header.pitchOrLinearSize), sizeof(uint32_t), 1, fp);
fread(&(header.depth), sizeof(uint32_t), 1, fp);
fread(&(header.mipMapCount), sizeof(uint32_t), 1, fp);
fread(&(header.reserved1[0]), sizeof(uint32_t), 11, fp);
fread(&(header.ddspf), sizeof(DDS_PIXELFORMAT), 1, fp);
fread(&(header.caps), sizeof(uint32_t), 1, fp);
fread(&(header.caps2), sizeof(uint32_t), 1, fp);
fread(&(header.caps3), sizeof(uint32_t), 1, fp);
fread(&(header.caps4), sizeof(uint32_t), 1, fp);
fread(&(header.reserved2), sizeof(uint32_t), 1, fp);
printf(" h %d, w %d\n", header.height, header.width);
if(header.ddspf.flags & DDPF_FOURCC)
{
if(memcmp(&(header.ddspf.fourCC), "DX10", 4) == 0)
{
printf("DX10\n");
}
printf("%d DX:%s\n", header.mipMapCount, &(header.ddspf.fourCC));
}
unsigned char * buffer;
unsigned int bufsize;
// how big is it going to be including all mipmaps?
bufsize = file_size - 128;
buffer = (unsigned char*)malloc(bufsize * sizeof(unsigned char));
fread(buffer, 1, bufsize, fp);
fclose(fp);
//unsigned int components = (header.ddspf.fourCC == FOURCC_DXT1) ? 3 : 4;
unsigned int format;
unsigned int blockSize = 16;
switch(header.ddspf.fourCC)
{
case FOURCC_DXT1:
format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
blockSize = 8;
break;
case FOURCC_DXT3:
format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
break;
case FOURCC_DXT5:
format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
printf("GL_COMPRESSED_RGBA_S3TC_DXT5_EXT\n");
break;
default:
free(buffer);
return 0;
}
// Create one OpenGL texture*/
GLuint tid = 0;
glGenTextures(1, &tid);
glBindTexture(GL_TEXTURE_2D, tid);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, header.mipMapCount-1); // opengl likes array length of mipmaps
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // don't forget to enable mipmaping
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// load the mipmaps
uint32_t mipMapCount = header.mipMapCount;
uint32_t offset = 0;
uint32_t size = 0;
uint32_t width = header.width;
uint32_t height = header.height;
for (unsigned int i = 0; i < mipMapCount; i++) // && (width || height)
{
if(width == 0 || height == 0) // discard any odd mipmaps 0x1 0x2 resolutions
{
mipMapCount--;
continue;
}
size = ((width+3)/4)*((height+3)/4)*blockSize;
glCompressedTexImage2D(GL_TEXTURE_2D, i, format, width, height, 0, size, buffer + offset);
offset += size;
width /= 2;
height /= 2;
}
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, mipMapCount-1);
glBindTexture(GL_TEXTURE_2D, 0);
free(buffer);
return tid;
}
|
//
// Created by 周华 on 2021/5/1.
//
#ifndef RAYTRACING_TRANSFORMCOMPONENT_H
#define RAYTRACING_TRANSFORMCOMPONENT_H
#include "Component.h"
class TransformComponent : public Component {
public:
~TransformComponent() {}
};
#endif //RAYTRACING_TRANSFORMCOMPONENT_H
|
#include <iostream>
#include <string>
#include <ctime>
#include <fstream>
using namespace std;
char randomLetterGen(){
static string charset = "cdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
return charset[rand() % charset.length()];
}
string randomStrGen(int length) {
string result;
result.resize(length);
for (int i = 0; i < length; i++)
result[i] = randomLetterGen();
return result;
}
const int MAXN = 100000;
void CreateTest(){
srand(1);
ofstream test("Test.txt");
int index1, index2;
char newValue;
int begin, end, formerLength;
int NumberOfQueries = MAXN;
int strlength = MAXN;
string str = randomStrGen(strlength);
test << NumberOfQueries << endl << str << endl;
int operation;
for (int j = 0; j < NumberOfQueries; j++){
operation = rand() % 2;
test << operation << endl;
switch (operation){
case 0:
index1 = rand() % (strlength / 2);
index2 = strlength - index1 - 1;
newValue = randomLetterGen();
test << index1 << endl << index2 << endl << newValue << endl;
break;
case 1:
if (!(j % 2)){
begin = rand() % (strlength / 2);
end = strlength - begin - 1;
}
else{
end = rand() % strlength;
begin = 0;
if (end)
begin = rand() % end;
}
test << begin << endl << end << endl;
break;
}
}
test.close();
}
|
#include <bits/stdc++.h>
#include <SDL.h>
#include "SDL_setup.h"
#include "Snake.h"
int main(int argc, char* argv[])
{
srand(time(nullptr));
if(!initSDL(window,renderer))
{
return -1;
}
bool play= true, Can_move;
int time_to_minus= 1000;
int ret_menu_type= 0;
int wallSize= 20;
Snake snake;
snake.position_arr.push_back(snake.positionH);
snake.position_arr.push_back(snake.positionT);
Point point;
SDL_Rect rect, box;
rect.x=0;
rect.y=0;
rect.w=SCREEN_WIDTH;
rect.h=SCORE_BOX_HEIGHT;
box.x= wallSize;
box.y= SCORE_BOX_HEIGHT+ wallSize;
box.w= SCREEN_WIDTH-2*wallSize-snake.sizeS;
box.h= SCREEN_HEIGHT-SCORE_BOX_HEIGHT-wallSize*2-snake.sizeS;
SDL_Texture* Image[numImage];
gameImage(Image, renderer);
do
{
again=false;
point.position.x=wallSize+rand()%(SCREEN_WIDTH-point.size-2*wallSize+1);
point.position.y=wallSize+SCORE_BOX_HEIGHT+(rand()%(SCREEN_HEIGHT-point.size-2*wallSize+1));
for(int i=0; i<snake.position_arr.size(); i++)
{
if(point.position.x>snake.position_arr[i].x-point.size&&point.position.x<snake.position_arr[i].x+snake.sizeS
&&point.position.y>snake.position_arr[i].y-point.size&&point.position.y<snake.position_arr[i].y+snake.sizeS)
{
again=true;
break;
}
}
}
while(again);
do
{
again=false;
int ret_menu_first=menu_first(renderer, Image);
if(ret_menu_first==boxnum_of_menu_first-1)
{
play=false;
}
else if(ret_menu_first==boxnum_of_menu_first-2)
{
menu_type(renderer, again, ret_menu_type, Image, wallSize);
}
}
while(again);
chunk=Mix_LoadWAV("changebrg.wav");
Mix_PlayChannel(-1,chunk,0);
befor.key.keysym.sym=SDLK_d;
if(ret_menu_type==boxnum_of_menu_type-1)
{
snake.position_arr[0].x=snake.num*2;
snake.position_arr[0].y=SCORE_BOX_HEIGHT+snake.num;
snake.position_arr[1].x=snake.num;
snake.position_arr[1].y=SCORE_BOX_HEIGHT+snake.num;
}
while(play)
{
SDL_SetRenderDrawColor(renderer, 185, 211, 238, 255);
SDL_RenderClear(renderer);
SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255);
SDL_RenderFillRect(renderer, &rect);
printWall(renderer, snake, box, play, point, Image, ret_menu_type, head, befor, wallSize, num_score, time_to_minus, max_score, again);
for(int i=1; i<snake.position_arr.size(); i++)
{
if(snake.position_arr[0].x==snake.position_arr[i].x&&snake.position_arr[0].y==snake.position_arr[i].y)
{
chunk=Mix_LoadWAV("die.wav");
Mix_PlayChannel(-1,chunk,0);
SDL_Delay(2000);
open_menu_final(renderer,num_score,play,befor,head,snake,point,ret_menu_type,wallSize, time_to_minus, max_score,Image, again);
if(!play) break;
}
}
if(!play) break;
snake.render(renderer, head, Image);
point.render(renderer, Image);
printScore(renderer, num_score, "Score: ");
if(snake.times==threshold_appears_big_point)
{
printTime(renderer, time_to_minus);
}
SDL_RenderPresent(renderer);
//SDL_UpdateWindowSurface(window);
SDL_Delay(speed);
if(SDL_PollEvent(&e)!=0)
{
if(e.type==SDL_QUIT) play=false;
if(e.type==SDL_KEYDOWN)
{
Can_move=true;
if((befor.key.keysym.sym==SDLK_d||befor.key.keysym.sym==SDLK_RIGHT)&&(e.key.keysym.sym==SDLK_LEFT||e.key.keysym.sym==SDLK_a))
{
Can_move=false;
}
if((befor.key.keysym.sym==SDLK_a||befor.key.keysym.sym==SDLK_LEFT)&&(e.key.keysym.sym==SDLK_RIGHT||e.key.keysym.sym==SDLK_d))
{
Can_move=false;
}
if((befor.key.keysym.sym==SDLK_w||befor.key.keysym.sym==SDLK_UP)&&(e.key.keysym.sym==SDLK_DOWN||e.key.keysym.sym==SDLK_s))
{
Can_move=false;
}
if((befor.key.keysym.sym==SDLK_s||befor.key.keysym.sym==SDLK_DOWN)&&(e.key.keysym.sym==SDLK_UP||e.key.keysym.sym==SDLK_w))
{
Can_move=false;
}
if(Can_move)
{
switch (e.key.keysym.sym)
{
case SDLK_LEFT:
snake.turnLeft();
head=SNAKE_HEAD_LEFT;
break;
case SDLK_RIGHT:
snake.turnRight();
head=SNAKE_HEAD_RIGHT;
break;
case SDLK_DOWN:
snake.turnDown();
head=SNAKE_HEAD_BOT;
break;
case SDLK_UP:
snake.turnUp();
head=SNAKE_HEAD_TOP;
break;
case SDLK_a:
snake.turnLeft();
head=SNAKE_HEAD_LEFT;
break;
case SDLK_d:
snake.turnRight();
head=SNAKE_HEAD_RIGHT;
break;
case SDLK_s:
snake.turnDown();
head=SNAKE_HEAD_BOT;
break;
case SDLK_w:
snake.turnUp();
head=SNAKE_HEAD_TOP;
break;
default:
break;
}
befor.key.keysym.sym=e.key.keysym.sym;
}
}
}
snake.eat(point, num_score, time_to_minus, wallSize);
snake.move();
}
quitSDL(window,renderer);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
string grid[150];
long long dp[150][2][2][150][150];
long long rightSum[2][2][150][150];
long long leftSum[2][2][150][150];
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> grid[i];
}
long long ans = 0;
memset(dp, 0, sizeof(dp));
for (int row = 0; row < n; row++)
{
int last = max(row - 1, 0);
memset(leftSum, 0, sizeof(leftSum));
for (int r = 0; r < n; r++)
{
for (int l = r; l >= 0; l--)
{
leftSum[0][0][l][r] = dp[last][0][0][l][r];
leftSum[0][1][l][r] = dp[last][0][1][l][r];
if (l < r)
{
leftSum[0][0][l][r] += leftSum[0][0][l + 1][r];
leftSum[0][0][l][r] %= MOD;
leftSum[0][1][l][r] += leftSum[0][1][l + 1][r];
leftSum[0][1][l][r] %= MOD;
}
}
for (int l = 0; l <= r; l++)
{
leftSum[1][0][l][r] = dp[last][1][0][l][r];
leftSum[1][1][l][r] = dp[last][1][1][l][r];
if (l > 0)
{
leftSum[1][0][l][r] += leftSum[1][0][l - 1][r] + dp[last][0][0][l - 1][r];
leftSum[1][0][l][r] %= MOD;
leftSum[1][1][l][r] += leftSum[1][1][l - 1][r] + dp[last][0][1][l - 1][r];
leftSum[1][1][l][r] %= MOD;
}
}
}
memset(rightSum, 0, sizeof(rightSum));
for (int l = 0; l < n; l++)
{
for (int r = l; r < n; r++)
{
rightSum[0][0][l][r] = leftSum[0][0][l][r];
rightSum[1][0][l][r] = leftSum[1][0][l][r];
if (r > l)
{
rightSum[0][0][l][r] += rightSum[0][0][l][r - 1];
rightSum[0][0][l][r] %= MOD;
rightSum[1][0][l][r] += rightSum[1][0][l][r - 1];
rightSum[1][0][l][r] %= MOD;
}
}
for (int r = n - 1; r >= l; r--)
{
rightSum[0][1][l][r] = leftSum[0][1][l][r];
rightSum[1][1][l][r] = leftSum[1][1][l][r];
if (r < n - 1)
{
rightSum[0][1][l][r] += rightSum[0][1][l][r + 1] + leftSum[0][0][l][r + 1];
rightSum[0][1][l][r] %= MOD;
rightSum[1][1][l][r] += rightSum[1][1][l][r + 1] + leftSum[1][0][l][r + 1];
rightSum[1][1][l][r] %= MOD;
}
}
}
for (int l = 0; l < n; l++)
{
bool valid = true;
for (int r = l; r < n; r++)
{
valid = valid && grid[row][r] == 'G';
if (valid)
{
dp[row][0][0][l][r] = (rightSum[0][0][l][r] + 1) % MOD;
dp[row][0][1][l][r] = rightSum[0][1][l][r];
if (r != n - 1)
{
dp[row][0][1][l][r] -= rightSum[0][1][r + 1][r + 1] + dp[last][0][0][r + 1][r + 1];
dp[row][0][1][l][r] += 2 * MOD;
}
dp[row][0][1][l][r] %= MOD;
dp[row][1][0][l][r] = rightSum[1][0][l][r];
dp[row][1][1][l][r] = rightSum[1][1][l][r];
ans += (dp[row][0][0][l][r] + dp[row][0][1][l][r] + dp[row][1][0][l][r] + dp[row][1][1][l][r]) % MOD;
ans %= MOD;
}
else
{
dp[row][0][0][l][r] = 0;
dp[row][0][1][l][r] = 0;
dp[row][1][0][l][r] = 0;
dp[row][1][1][l][r] = 0;
}
}
}
}
cout << ans << endl;
}
|
#include<iostream>
using namespace std;
int countSub(char str[])
{
int flag,count;
flag=count=0;
for (int i=0;str[i]!='\0';i++)
{
if (str[i]=='1')
{ count++;
for(int j=i+1;str[j]!='\0';j++)
if (str[j] == '1')
flag++;
}
}
return flag+count;
}
int main()
{
char str[100];
int n;
cout<<"\nEnter test cases\n";
cin>>n;
for(int k=0;k<n;k++)
{
cout<<"Enter binary string\n";
cin>>str;
cout << countSub(str)<<endl;
}
return 0;
}
|
/*M///////////////////////////////////////////////////////////////////////////////////////
//
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
//
// By downloading, copying, installing or using the software you agree to this license.
// If you do not agree to this license, do not download, install,
// copy or use the software.
//
//
// License Agreement
// For Open Source Computer Vision Library
//
// Copyright (C) 2000-2008, Intel Corporation, all rights reserved.
// Copyright (C) 2009, Willow Garage Inc., all rights reserved.
// Third party copyrights are property of their respective owners.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// * Redistribution's of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// * Redistribution's 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.
//
// * The name of the copyright holders may not 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 Intel Corporation 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.
//
//M*/
#include "test_precomp.hpp"
#include "opencv2/imgproc/imgproc_c.h"
using namespace cv;
using namespace std;
class CV_DefaultNewCameraMatrixTest : public cvtest::ArrayTest
{
public:
CV_DefaultNewCameraMatrixTest();
protected:
int prepare_test_case (int test_case_idx);
void prepare_to_validation( int test_case_idx );
void get_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types );
void run_func();
private:
cv::Size img_size;
cv::Mat camera_mat;
cv::Mat new_camera_mat;
int matrix_type;
bool center_principal_point;
static const int MAX_X = 2048;
static const int MAX_Y = 2048;
static const int MAX_VAL = 10000;
};
CV_DefaultNewCameraMatrixTest::CV_DefaultNewCameraMatrixTest()
{
test_array[INPUT].push_back(NULL);
test_array[OUTPUT].push_back(NULL);
test_array[REF_OUTPUT].push_back(NULL);
matrix_type = 0;
center_principal_point = false;
}
void CV_DefaultNewCameraMatrixTest::get_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types )
{
cvtest::ArrayTest::get_test_array_types_and_sizes(test_case_idx,sizes,types);
RNG& rng = ts->get_rng();
matrix_type = types[INPUT][0] = types[OUTPUT][0]= types[REF_OUTPUT][0] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
sizes[INPUT][0] = sizes[OUTPUT][0] = sizes[REF_OUTPUT][0] = cvSize(3,3);
}
int CV_DefaultNewCameraMatrixTest::prepare_test_case(int test_case_idx)
{
int code = cvtest::ArrayTest::prepare_test_case( test_case_idx );
if (code <= 0)
return code;
RNG& rng = ts->get_rng();
img_size.width = cvtest::randInt(rng) % MAX_X + 1;
img_size.height = cvtest::randInt(rng) % MAX_Y + 1;
center_principal_point = ((cvtest::randInt(rng) % 2)!=0);
// Generating camera_mat matrix
double sz = MAX(img_size.width, img_size.height);
double aspect_ratio = cvtest::randReal(rng)*0.6 + 0.7;
double a[9] = {0,0,0,0,0,0,0,0,1};
Mat _a(3,3,CV_64F,a);
a[2] = (img_size.width - 1)*0.5 + cvtest::randReal(rng)*10 - 5;
a[5] = (img_size.height - 1)*0.5 + cvtest::randReal(rng)*10 - 5;
a[0] = sz/(0.9 - cvtest::randReal(rng)*0.6);
a[4] = aspect_ratio*a[0];
Mat& _a0 = test_mat[INPUT][0];
cvtest::convert(_a, _a0, _a0.type());
camera_mat = _a0;
return code;
}
void CV_DefaultNewCameraMatrixTest::run_func()
{
new_camera_mat = cv::getDefaultNewCameraMatrix(camera_mat,img_size,center_principal_point);
}
void CV_DefaultNewCameraMatrixTest::prepare_to_validation( int /*test_case_idx*/ )
{
const Mat& src = test_mat[INPUT][0];
Mat& dst = test_mat[REF_OUTPUT][0];
Mat& test_output = test_mat[OUTPUT][0];
Mat& output = new_camera_mat;
cvtest::convert( output, test_output, test_output.type() );
if (!center_principal_point)
{
cvtest::copy(src, dst);
}
else
{
double a[9] = {0,0,0,0,0,0,0,0,1};
Mat _a(3,3,CV_64F,a);
if (matrix_type == CV_64F)
{
a[0] = src.at<double>(0,0);
a[4] = src.at<double>(1,1);
}
else
{
a[0] = src.at<float>(0,0);
a[4] = src.at<float>(1,1);
}
a[2] = (img_size.width - 1)*0.5;
a[5] = (img_size.height - 1)*0.5;
cvtest::convert( _a, dst, dst.type() );
}
}
//---------
class CV_UndistortPointsTest : public cvtest::ArrayTest
{
public:
CV_UndistortPointsTest();
protected:
int prepare_test_case (int test_case_idx);
void prepare_to_validation( int test_case_idx );
void get_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types );
double get_success_error_level( int test_case_idx, int i, int j );
void run_func();
void distortPoints(const CvMat* _src, CvMat* _dst, const CvMat* _cameraMatrix,
const CvMat* _distCoeffs, const CvMat* matR, const CvMat* matP);
private:
bool useCPlus;
bool useDstMat;
static const int N_POINTS = 10;
static const int MAX_X = 2048;
static const int MAX_Y = 2048;
bool zero_new_cam;
bool zero_distortion;
bool zero_R;
cv::Size img_size;
cv::Mat dst_points_mat;
cv::Mat camera_mat;
cv::Mat R;
cv::Mat P;
cv::Mat distortion_coeffs;
cv::Mat src_points;
std::vector<cv::Point2f> dst_points;
};
CV_UndistortPointsTest::CV_UndistortPointsTest()
{
test_array[INPUT].push_back(NULL); // points matrix
test_array[INPUT].push_back(NULL); // camera matrix
test_array[INPUT].push_back(NULL); // distortion coeffs
test_array[INPUT].push_back(NULL); // R matrix
test_array[INPUT].push_back(NULL); // P matrix
test_array[OUTPUT].push_back(NULL); // distorted dst points
test_array[TEMP].push_back(NULL); // dst points
test_array[REF_OUTPUT].push_back(NULL);
useCPlus = useDstMat = false;
zero_new_cam = zero_distortion = zero_R = false;
}
void CV_UndistortPointsTest::get_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types )
{
cvtest::ArrayTest::get_test_array_types_and_sizes(test_case_idx,sizes,types);
RNG& rng = ts->get_rng();
useCPlus = ((cvtest::randInt(rng) % 2)!=0);
//useCPlus = 0;
if (useCPlus)
{
types[INPUT][0] = types[OUTPUT][0] = types[REF_OUTPUT][0] = types[TEMP][0]= CV_32FC2;
}
else
{
types[INPUT][0] = types[OUTPUT][0] = types[REF_OUTPUT][0] = types[TEMP][0]= cvtest::randInt(rng)%2 ? CV_64FC2 : CV_32FC2;
}
types[INPUT][1] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
types[INPUT][2] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
types[INPUT][3] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
types[INPUT][4] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
sizes[INPUT][0] = sizes[OUTPUT][0] = sizes[REF_OUTPUT][0] = sizes[TEMP][0]= cvtest::randInt(rng)%2 ? cvSize(1,N_POINTS) : cvSize(N_POINTS,1);
sizes[INPUT][1] = sizes[INPUT][3] = cvSize(3,3);
sizes[INPUT][4] = cvtest::randInt(rng)%2 ? cvSize(3,3) : cvSize(4,3);
if (cvtest::randInt(rng)%2)
{
if (cvtest::randInt(rng)%2)
{
sizes[INPUT][2] = cvSize(1,4);
}
else
{
sizes[INPUT][2] = cvSize(1,5);
}
}
else
{
if (cvtest::randInt(rng)%2)
{
sizes[INPUT][2] = cvSize(4,1);
}
else
{
sizes[INPUT][2] = cvSize(5,1);
}
}
}
int CV_UndistortPointsTest::prepare_test_case(int test_case_idx)
{
RNG& rng = ts->get_rng();
int code = cvtest::ArrayTest::prepare_test_case( test_case_idx );
if (code <= 0)
return code;
useDstMat = (cvtest::randInt(rng) % 2) == 0;
img_size.width = cvtest::randInt(rng) % MAX_X + 1;
img_size.height = cvtest::randInt(rng) % MAX_Y + 1;
int dist_size = test_mat[INPUT][2].cols > test_mat[INPUT][2].rows ? test_mat[INPUT][2].cols : test_mat[INPUT][2].rows;
double cam[9] = {0,0,0,0,0,0,0,0,1};
vector<double> dist(dist_size);
vector<double> proj(test_mat[INPUT][4].cols * test_mat[INPUT][4].rows);
vector<Point2d> points(N_POINTS);
Mat _camera(3,3,CV_64F,cam);
Mat _distort(test_mat[INPUT][2].rows,test_mat[INPUT][2].cols,CV_64F,&dist[0]);
Mat _proj(test_mat[INPUT][4].size(), CV_64F, &proj[0]);
Mat _points(test_mat[INPUT][0].size(), CV_64FC2, &points[0]);
_proj = Scalar::all(0);
//Generating points
for( int i = 0; i < N_POINTS; i++ )
{
points[i].x = cvtest::randReal(rng)*img_size.width;
points[i].y = cvtest::randReal(rng)*img_size.height;
}
//Generating camera matrix
double sz = MAX(img_size.width,img_size.height);
double aspect_ratio = cvtest::randReal(rng)*0.6 + 0.7;
cam[2] = (img_size.width - 1)*0.5 + cvtest::randReal(rng)*10 - 5;
cam[5] = (img_size.height - 1)*0.5 + cvtest::randReal(rng)*10 - 5;
cam[0] = sz/(0.9 - cvtest::randReal(rng)*0.6);
cam[4] = aspect_ratio*cam[0];
//Generating distortion coeffs
dist[0] = cvtest::randReal(rng)*0.06 - 0.03;
dist[1] = cvtest::randReal(rng)*0.06 - 0.03;
if( dist[0]*dist[1] > 0 )
dist[1] = -dist[1];
if( cvtest::randInt(rng)%4 != 0 )
{
dist[2] = cvtest::randReal(rng)*0.004 - 0.002;
dist[3] = cvtest::randReal(rng)*0.004 - 0.002;
if (dist_size > 4)
dist[4] = cvtest::randReal(rng)*0.004 - 0.002;
}
else
{
dist[2] = dist[3] = 0;
if (dist_size > 4)
dist[4] = 0;
}
//Generating P matrix (projection)
if( test_mat[INPUT][4].cols != 4 )
{
proj[8] = 1;
if (cvtest::randInt(rng)%2 == 0) // use identity new camera matrix
{
proj[0] = 1;
proj[4] = 1;
}
else
{
proj[0] = cam[0] + (cvtest::randReal(rng) - (double)0.5)*0.2*cam[0]; //10%
proj[4] = cam[4] + (cvtest::randReal(rng) - (double)0.5)*0.2*cam[4]; //10%
proj[2] = cam[2] + (cvtest::randReal(rng) - (double)0.5)*0.3*img_size.width; //15%
proj[5] = cam[5] + (cvtest::randReal(rng) - (double)0.5)*0.3*img_size.height; //15%
}
}
else
{
proj[10] = 1;
proj[0] = cam[0] + (cvtest::randReal(rng) - (double)0.5)*0.2*cam[0]; //10%
proj[5] = cam[4] + (cvtest::randReal(rng) - (double)0.5)*0.2*cam[4]; //10%
proj[2] = cam[2] + (cvtest::randReal(rng) - (double)0.5)*0.3*img_size.width; //15%
proj[6] = cam[5] + (cvtest::randReal(rng) - (double)0.5)*0.3*img_size.height; //15%
proj[3] = (img_size.height + img_size.width - 1)*0.5 + cvtest::randReal(rng)*10 - 5;
proj[7] = (img_size.height + img_size.width - 1)*0.5 + cvtest::randReal(rng)*10 - 5;
proj[11] = (img_size.height + img_size.width - 1)*0.5 + cvtest::randReal(rng)*10 - 5;
}
//Generating R matrix
Mat _rot(3,3,CV_64F);
Mat rotation(1,3,CV_64F);
rotation.at<double>(0) = CV_PI*(cvtest::randReal(rng) - (double)0.5); // phi
rotation.at<double>(1) = CV_PI*(cvtest::randReal(rng) - (double)0.5); // ksi
rotation.at<double>(2) = CV_PI*(cvtest::randReal(rng) - (double)0.5); //khi
cvtest::Rodrigues(rotation, _rot);
//copying data
//src_points = &_points;
_points.convertTo(test_mat[INPUT][0], test_mat[INPUT][0].type());
_camera.convertTo(test_mat[INPUT][1], test_mat[INPUT][1].type());
_distort.convertTo(test_mat[INPUT][2], test_mat[INPUT][2].type());
_rot.convertTo(test_mat[INPUT][3], test_mat[INPUT][3].type());
_proj.convertTo(test_mat[INPUT][4], test_mat[INPUT][4].type());
zero_distortion = (cvtest::randInt(rng)%2) == 0 ? false : true;
zero_new_cam = (cvtest::randInt(rng)%2) == 0 ? false : true;
zero_R = (cvtest::randInt(rng)%2) == 0 ? false : true;
if (useCPlus)
{
_points.convertTo(src_points, CV_32F);
camera_mat = test_mat[INPUT][1];
distortion_coeffs = test_mat[INPUT][2];
R = test_mat[INPUT][3];
P = test_mat[INPUT][4];
}
return code;
}
void CV_UndistortPointsTest::prepare_to_validation(int /*test_case_idx*/)
{
int dist_size = test_mat[INPUT][2].cols > test_mat[INPUT][2].rows ? test_mat[INPUT][2].cols : test_mat[INPUT][2].rows;
double cam[9] = {0,0,0,0,0,0,0,0,1};
double rot[9] = {1,0,0,0,1,0,0,0,1};
double* dist = new double[dist_size ];
double* proj = new double[test_mat[INPUT][4].cols * test_mat[INPUT][4].rows];
double* points = new double[N_POINTS*2];
double* r_points = new double[N_POINTS*2];
//Run reference calculations
CvMat ref_points= cvMat(test_mat[INPUT][0].rows,test_mat[INPUT][0].cols,CV_64FC2,r_points);
CvMat _camera = cvMat(3,3,CV_64F,cam);
CvMat _rot = cvMat(3,3,CV_64F,rot);
CvMat _distort = cvMat(test_mat[INPUT][2].rows,test_mat[INPUT][2].cols,CV_64F,dist);
CvMat _proj = cvMat(test_mat[INPUT][4].rows,test_mat[INPUT][4].cols,CV_64F,proj);
CvMat _points= cvMat(test_mat[TEMP][0].rows,test_mat[TEMP][0].cols,CV_64FC2,points);
Mat __camera = cvarrToMat(&_camera);
Mat __distort = cvarrToMat(&_distort);
Mat __rot = cvarrToMat(&_rot);
Mat __proj = cvarrToMat(&_proj);
Mat __points = cvarrToMat(&_points);
Mat _ref_points = cvarrToMat(&ref_points);
cvtest::convert(test_mat[INPUT][1], __camera, __camera.type());
cvtest::convert(test_mat[INPUT][2], __distort, __distort.type());
cvtest::convert(test_mat[INPUT][3], __rot, __rot.type());
cvtest::convert(test_mat[INPUT][4], __proj, __proj.type());
if (useCPlus)
{
if (useDstMat)
{
CvMat temp = dst_points_mat;
for (int i=0;i<N_POINTS*2;i++)
{
points[i] = temp.data.fl[i];
}
}
else
{
for (int i=0;i<N_POINTS;i++)
{
points[2*i] = dst_points[i].x;
points[2*i+1] = dst_points[i].y;
}
}
}
else
{
cvtest::convert(test_mat[TEMP][0],__points, __points.type());
}
CvMat* input2 = zero_distortion ? 0 : &_distort;
CvMat* input3 = zero_R ? 0 : &_rot;
CvMat* input4 = zero_new_cam ? 0 : &_proj;
distortPoints(&_points,&ref_points,&_camera,input2,input3,input4);
Mat& dst = test_mat[REF_OUTPUT][0];
cvtest::convert(_ref_points, dst, dst.type());
cvtest::copy(test_mat[INPUT][0], test_mat[OUTPUT][0]);
delete[] dist;
delete[] proj;
delete[] points;
delete[] r_points;
}
void CV_UndistortPointsTest::run_func()
{
if (useCPlus)
{
cv::Mat input2,input3,input4;
input2 = zero_distortion ? cv::Mat() : cv::Mat(test_mat[INPUT][2]);
input3 = zero_R ? cv::Mat() : cv::Mat(test_mat[INPUT][3]);
input4 = zero_new_cam ? cv::Mat() : cv::Mat(test_mat[INPUT][4]);
if (useDstMat)
{
//cv::undistortPoints(src_points,dst_points_mat,camera_mat,distortion_coeffs,R,P);
cv::undistortPoints(src_points,dst_points_mat,camera_mat,input2,input3,input4);
}
else
{
//cv::undistortPoints(src_points,dst_points,camera_mat,distortion_coeffs,R,P);
cv::undistortPoints(src_points,dst_points,camera_mat,input2,input3,input4);
}
}
else
{
CvMat _input0 = test_mat[INPUT][0], _input1 = test_mat[INPUT][1], _input2, _input3, _input4;
CvMat _output = test_mat[TEMP][0];
if(!zero_distortion)
_input2 = test_mat[INPUT][2];
if(!zero_R)
_input3 = test_mat[INPUT][3];
if(!zero_new_cam)
_input4 = test_mat[INPUT][4];
cvUndistortPoints(&_input0, &_output, &_input1,
zero_distortion ? 0 : &_input2,
zero_R ? 0 : &_input3,
zero_new_cam ? 0 : &_input4);
}
}
void CV_UndistortPointsTest::distortPoints(const CvMat* _src, CvMat* _dst, const CvMat* _cameraMatrix,
const CvMat* _distCoeffs,
const CvMat* matR, const CvMat* matP)
{
double a[9];
CvMat* __P;
if ((!matP)||(matP->cols == 3))
__P = cvCreateMat(3,3,CV_64F);
else
__P = cvCreateMat(3,4,CV_64F);
if (matP)
{
cvtest::convert(cvarrToMat(matP), cvarrToMat(__P), -1);
}
else
{
cvZero(__P);
__P->data.db[0] = 1;
__P->data.db[4] = 1;
__P->data.db[8] = 1;
}
CvMat* __R = cvCreateMat(3,3,CV_64F);
if (matR)
{
cvCopy(matR,__R);
}
else
{
cvZero(__R);
__R->data.db[0] = 1;
__R->data.db[4] = 1;
__R->data.db[8] = 1;
}
for (int i=0;i<N_POINTS;i++)
{
int movement = __P->cols > 3 ? 1 : 0;
double x = (_src->data.db[2*i]-__P->data.db[2])/__P->data.db[0];
double y = (_src->data.db[2*i+1]-__P->data.db[5+movement])/__P->data.db[4+movement];
CvMat inverse = cvMat(3,3,CV_64F,a);
cvInvert(__R,&inverse);
double w1 = x*inverse.data.db[6]+y*inverse.data.db[7]+inverse.data.db[8];
double _x = (x*inverse.data.db[0]+y*inverse.data.db[1]+inverse.data.db[2])/w1;
double _y = (x*inverse.data.db[3]+y*inverse.data.db[4]+inverse.data.db[5])/w1;
//Distortions
double __x = _x;
double __y = _y;
if (_distCoeffs)
{
double r2 = _x*_x+_y*_y;
__x = _x*(1+_distCoeffs->data.db[0]*r2+_distCoeffs->data.db[1]*r2*r2)+
2*_distCoeffs->data.db[2]*_x*_y+_distCoeffs->data.db[3]*(r2+2*_x*_x);
__y = _y*(1+_distCoeffs->data.db[0]*r2+_distCoeffs->data.db[1]*r2*r2)+
2*_distCoeffs->data.db[3]*_x*_y+_distCoeffs->data.db[2]*(r2+2*_y*_y);
if ((_distCoeffs->cols > 4) || (_distCoeffs->rows > 4))
{
__x+=_x*_distCoeffs->data.db[4]*r2*r2*r2;
__y+=_y*_distCoeffs->data.db[4]*r2*r2*r2;
}
}
_dst->data.db[2*i] = __x*_cameraMatrix->data.db[0]+_cameraMatrix->data.db[2];
_dst->data.db[2*i+1] = __y*_cameraMatrix->data.db[4]+_cameraMatrix->data.db[5];
}
cvReleaseMat(&__R);
cvReleaseMat(&__P);
}
double CV_UndistortPointsTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
{
return 5e-2;
}
//------------------------------------------------------
class CV_InitUndistortRectifyMapTest : public cvtest::ArrayTest
{
public:
CV_InitUndistortRectifyMapTest();
protected:
int prepare_test_case (int test_case_idx);
void prepare_to_validation( int test_case_idx );
void get_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types );
double get_success_error_level( int test_case_idx, int i, int j );
void run_func();
private:
bool useCPlus;
static const int N_POINTS = 100;
static const int MAX_X = 2048;
static const int MAX_Y = 2048;
bool zero_new_cam;
bool zero_distortion;
bool zero_R;
cv::Size img_size;
cv::Mat camera_mat;
cv::Mat R;
cv::Mat new_camera_mat;
cv::Mat distortion_coeffs;
cv::Mat mapx;
cv::Mat mapy;
CvMat* _mapx;
CvMat* _mapy;
int mat_type;
};
CV_InitUndistortRectifyMapTest::CV_InitUndistortRectifyMapTest()
{
test_array[INPUT].push_back(NULL); // test points matrix
test_array[INPUT].push_back(NULL); // camera matrix
test_array[INPUT].push_back(NULL); // distortion coeffs
test_array[INPUT].push_back(NULL); // R matrix
test_array[INPUT].push_back(NULL); // new camera matrix
test_array[OUTPUT].push_back(NULL); // distorted dst points
test_array[REF_OUTPUT].push_back(NULL);
useCPlus = false;
zero_distortion = zero_new_cam = zero_R = false;
_mapx = _mapy = NULL;
mat_type = 0;
}
void CV_InitUndistortRectifyMapTest::get_test_array_types_and_sizes( int test_case_idx, vector<vector<Size> >& sizes, vector<vector<int> >& types )
{
cvtest::ArrayTest::get_test_array_types_and_sizes(test_case_idx,sizes,types);
RNG& rng = ts->get_rng();
useCPlus = ((cvtest::randInt(rng) % 2)!=0);
//useCPlus = 0;
types[INPUT][0] = types[OUTPUT][0] = types[REF_OUTPUT][0] = CV_64FC2;
types[INPUT][1] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
types[INPUT][2] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
types[INPUT][3] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
types[INPUT][4] = cvtest::randInt(rng)%2 ? CV_64F : CV_32F;
sizes[INPUT][0] = sizes[OUTPUT][0] = sizes[REF_OUTPUT][0] = cvSize(N_POINTS,1);
sizes[INPUT][1] = sizes[INPUT][3] = cvSize(3,3);
sizes[INPUT][4] = cvSize(3,3);
if (cvtest::randInt(rng)%2)
{
if (cvtest::randInt(rng)%2)
{
sizes[INPUT][2] = cvSize(1,4);
}
else
{
sizes[INPUT][2] = cvSize(1,5);
}
}
else
{
if (cvtest::randInt(rng)%2)
{
sizes[INPUT][2] = cvSize(4,1);
}
else
{
sizes[INPUT][2] = cvSize(5,1);
}
}
}
int CV_InitUndistortRectifyMapTest::prepare_test_case(int test_case_idx)
{
RNG& rng = ts->get_rng();
int code = cvtest::ArrayTest::prepare_test_case( test_case_idx );
if (code <= 0)
return code;
img_size.width = cvtest::randInt(rng) % MAX_X + 1;
img_size.height = cvtest::randInt(rng) % MAX_Y + 1;
if (useCPlus)
{
mat_type = (cvtest::randInt(rng) % 2) == 0 ? CV_32FC1 : CV_16SC2;
if ((cvtest::randInt(rng) % 4) == 0)
mat_type = -1;
if ((cvtest::randInt(rng) % 4) == 0)
mat_type = CV_32FC2;
_mapx = 0;
_mapy = 0;
}
else
{
int typex = (cvtest::randInt(rng) % 2) == 0 ? CV_32FC1 : CV_16SC2;
//typex = CV_32FC1; ///!!!!!!!!!!!!!!!!
int typey = (typex == CV_32FC1) ? CV_32FC1 : CV_16UC1;
_mapx = cvCreateMat(img_size.height,img_size.width,typex);
_mapy = cvCreateMat(img_size.height,img_size.width,typey);
}
int dist_size = test_mat[INPUT][2].cols > test_mat[INPUT][2].rows ? test_mat[INPUT][2].cols : test_mat[INPUT][2].rows;
double cam[9] = {0,0,0,0,0,0,0,0,1};
vector<double> dist(dist_size);
vector<double> new_cam(test_mat[INPUT][4].cols * test_mat[INPUT][4].rows);
vector<Point2d> points(N_POINTS);
Mat _camera(3,3,CV_64F,cam);
Mat _distort(test_mat[INPUT][2].size(),CV_64F,&dist[0]);
Mat _new_cam(test_mat[INPUT][4].size(),CV_64F,&new_cam[0]);
Mat _points(test_mat[INPUT][0].size(),CV_64FC2, &points[0]);
//Generating points
for (int i=0;i<N_POINTS;i++)
{
points[i].x = cvtest::randReal(rng)*img_size.width;
points[i].y = cvtest::randReal(rng)*img_size.height;
}
//Generating camera matrix
double sz = MAX(img_size.width,img_size.height);
double aspect_ratio = cvtest::randReal(rng)*0.6 + 0.7;
cam[2] = (img_size.width - 1)*0.5 + cvtest::randReal(rng)*10 - 5;
cam[5] = (img_size.height - 1)*0.5 + cvtest::randReal(rng)*10 - 5;
cam[0] = sz/(0.9 - cvtest::randReal(rng)*0.6);
cam[4] = aspect_ratio*cam[0];
//Generating distortion coeffs
dist[0] = cvtest::randReal(rng)*0.06 - 0.03;
dist[1] = cvtest::randReal(rng)*0.06 - 0.03;
if( dist[0]*dist[1] > 0 )
dist[1] = -dist[1];
if( cvtest::randInt(rng)%4 != 0 )
{
dist[2] = cvtest::randReal(rng)*0.004 - 0.002;
dist[3] = cvtest::randReal(rng)*0.004 - 0.002;
if (dist_size > 4)
dist[4] = cvtest::randReal(rng)*0.004 - 0.002;
}
else
{
dist[2] = dist[3] = 0;
if (dist_size > 4)
dist[4] = 0;
}
//Generating new camera matrix
_new_cam = Scalar::all(0);
new_cam[8] = 1;
//new_cam[0] = cam[0];
//new_cam[4] = cam[4];
//new_cam[2] = cam[2];
//new_cam[5] = cam[5];
new_cam[0] = cam[0] + (cvtest::randReal(rng) - (double)0.5)*0.2*cam[0]; //10%
new_cam[4] = cam[4] + (cvtest::randReal(rng) - (double)0.5)*0.2*cam[4]; //10%
new_cam[2] = cam[2] + (cvtest::randReal(rng) - (double)0.5)*0.3*img_size.width; //15%
new_cam[5] = cam[5] + (cvtest::randReal(rng) - (double)0.5)*0.3*img_size.height; //15%
//Generating R matrix
Mat _rot(3,3,CV_64F);
Mat rotation(1,3,CV_64F);
rotation.at<double>(0) = CV_PI/8*(cvtest::randReal(rng) - (double)0.5); // phi
rotation.at<double>(1) = CV_PI/8*(cvtest::randReal(rng) - (double)0.5); // ksi
rotation.at<double>(2) = CV_PI/3*(cvtest::randReal(rng) - (double)0.5); //khi
cvtest::Rodrigues(rotation, _rot);
//cvSetIdentity(_rot);
//copying data
cvtest::convert( _points, test_mat[INPUT][0], test_mat[INPUT][0].type());
cvtest::convert( _camera, test_mat[INPUT][1], test_mat[INPUT][1].type());
cvtest::convert( _distort, test_mat[INPUT][2], test_mat[INPUT][2].type());
cvtest::convert( _rot, test_mat[INPUT][3], test_mat[INPUT][3].type());
cvtest::convert( _new_cam, test_mat[INPUT][4], test_mat[INPUT][4].type());
zero_distortion = (cvtest::randInt(rng)%2) == 0 ? false : true;
zero_new_cam = (cvtest::randInt(rng)%2) == 0 ? false : true;
zero_R = (cvtest::randInt(rng)%2) == 0 ? false : true;
if (useCPlus)
{
camera_mat = test_mat[INPUT][1];
distortion_coeffs = test_mat[INPUT][2];
R = test_mat[INPUT][3];
new_camera_mat = test_mat[INPUT][4];
}
return code;
}
void CV_InitUndistortRectifyMapTest::prepare_to_validation(int/* test_case_idx*/)
{
#if 0
int dist_size = test_mat[INPUT][2].cols > test_mat[INPUT][2].rows ? test_mat[INPUT][2].cols : test_mat[INPUT][2].rows;
double cam[9] = {0,0,0,0,0,0,0,0,1};
double rot[9] = {1,0,0,0,1,0,0,0,1};
vector<double> dist(dist_size);
vector<double> new_cam(test_mat[INPUT][4].cols * test_mat[INPUT][4].rows);
vector<Point2d> points(N_POINTS);
vector<Point2d> r_points(N_POINTS);
//Run reference calculations
Mat ref_points(test_mat[INPUT][0].size(),CV_64FC2,&r_points[0]);
Mat _camera(3,3,CV_64F,cam);
Mat _rot(3,3,CV_64F,rot);
Mat _distort(test_mat[INPUT][2].size(),CV_64F,&dist[0]);
Mat _new_cam(test_mat[INPUT][4].size(),CV_64F,&new_cam[0]);
Mat _points(test_mat[INPUT][0].size(),CV_64FC2,&points[0]);
cvtest::convert(test_mat[INPUT][1],_camera,_camera.type());
cvtest::convert(test_mat[INPUT][2],_distort,_distort.type());
cvtest::convert(test_mat[INPUT][3],_rot,_rot.type());
cvtest::convert(test_mat[INPUT][4],_new_cam,_new_cam.type());
//Applying precalculated undistort rectify map
if (!useCPlus)
{
mapx = cv::Mat(_mapx);
mapy = cv::Mat(_mapy);
}
cv::Mat map1,map2;
cv::convertMaps(mapx,mapy,map1,map2,CV_32FC1);
CvMat _map1 = map1;
CvMat _map2 = map2;
const Point2d* sptr = (const Point2d*)test_mat[INPUT][0].data;
for( int i = 0;i < N_POINTS; i++ )
{
int u = saturate_cast<int>(sptr[i].x);
int v = saturate_cast<int>(sptr[i].y);
points[i].x = _map1.data.fl[v*_map1.cols + u];
points[i].y = _map2.data.fl[v*_map2.cols + u];
}
//---
cv::undistortPoints(_points, ref_points, _camera,
zero_distortion ? Mat() : _distort,
zero_R ? Mat::eye(3,3,CV_64F) : _rot,
zero_new_cam ? _camera : _new_cam);
//cvTsDistortPoints(&_points,&ref_points,&_camera,&_distort,&_rot,&_new_cam);
cvtest::convert(ref_points, test_mat[REF_OUTPUT][0], test_mat[REF_OUTPUT][0].type());
cvtest::copy(test_mat[INPUT][0],test_mat[OUTPUT][0]);
cvReleaseMat(&_mapx);
cvReleaseMat(&_mapy);
#else
int dist_size = test_mat[INPUT][2].cols > test_mat[INPUT][2].rows ? test_mat[INPUT][2].cols : test_mat[INPUT][2].rows;
double cam[9] = {0,0,0,0,0,0,0,0,1};
double rot[9] = {1,0,0,0,1,0,0,0,1};
double* dist = new double[dist_size ];
double* new_cam = new double[test_mat[INPUT][4].cols * test_mat[INPUT][4].rows];
double* points = new double[N_POINTS*2];
double* r_points = new double[N_POINTS*2];
//Run reference calculations
CvMat ref_points= cvMat(test_mat[INPUT][0].rows,test_mat[INPUT][0].cols,CV_64FC2,r_points);
CvMat _camera = cvMat(3,3,CV_64F,cam);
CvMat _rot = cvMat(3,3,CV_64F,rot);
CvMat _distort = cvMat(test_mat[INPUT][2].rows,test_mat[INPUT][2].cols,CV_64F,dist);
CvMat _new_cam = cvMat(test_mat[INPUT][4].rows,test_mat[INPUT][4].cols,CV_64F,new_cam);
CvMat _points= cvMat(test_mat[INPUT][0].rows,test_mat[INPUT][0].cols,CV_64FC2,points);
CvMat _input1 = test_mat[INPUT][1];
CvMat _input2 = test_mat[INPUT][2];
CvMat _input3 = test_mat[INPUT][3];
CvMat _input4 = test_mat[INPUT][4];
cvtest::convert(cvarrToMat(&_input1), cvarrToMat(&_camera), -1);
cvtest::convert(cvarrToMat(&_input2), cvarrToMat(&_distort), -1);
cvtest::convert(cvarrToMat(&_input3), cvarrToMat(&_rot), -1);
cvtest::convert(cvarrToMat(&_input4), cvarrToMat(&_new_cam), -1);
//Applying precalculated undistort rectify map
if (!useCPlus)
{
mapx = cv::cvarrToMat(_mapx);
mapy = cv::cvarrToMat(_mapy);
}
cv::Mat map1,map2;
cv::convertMaps(mapx,mapy,map1,map2,CV_32FC1);
CvMat _map1 = map1;
CvMat _map2 = map2;
for (int i=0;i<N_POINTS;i++)
{
double u = test_mat[INPUT][0].ptr<double>()[2*i];
double v = test_mat[INPUT][0].ptr<double>()[2*i+1];
_points.data.db[2*i] = (double)_map1.data.fl[(int)v*_map1.cols+(int)u];
_points.data.db[2*i+1] = (double)_map2.data.fl[(int)v*_map2.cols+(int)u];
}
//---
cvUndistortPoints(&_points,&ref_points,&_camera,
zero_distortion ? 0 : &_distort, zero_R ? 0 : &_rot, zero_new_cam ? &_camera : &_new_cam);
//cvTsDistortPoints(&_points,&ref_points,&_camera,&_distort,&_rot,&_new_cam);
CvMat dst = test_mat[REF_OUTPUT][0];
cvtest::convert(cvarrToMat(&ref_points), cvarrToMat(&dst), -1);
cvtest::copy(test_mat[INPUT][0],test_mat[OUTPUT][0]);
delete[] dist;
delete[] new_cam;
delete[] points;
delete[] r_points;
cvReleaseMat(&_mapx);
cvReleaseMat(&_mapy);
#endif
}
void CV_InitUndistortRectifyMapTest::run_func()
{
if (useCPlus)
{
cv::Mat input2,input3,input4;
input2 = zero_distortion ? cv::Mat() : test_mat[INPUT][2];
input3 = zero_R ? cv::Mat() : test_mat[INPUT][3];
input4 = zero_new_cam ? cv::Mat() : test_mat[INPUT][4];
cv::initUndistortRectifyMap(camera_mat,input2,input3,input4,img_size,mat_type,mapx,mapy);
}
else
{
CvMat input1 = test_mat[INPUT][1], input2, input3, input4;
if( !zero_distortion )
input2 = test_mat[INPUT][2];
if( !zero_R )
input3 = test_mat[INPUT][3];
if( !zero_new_cam )
input4 = test_mat[INPUT][4];
cvInitUndistortRectifyMap(&input1,
zero_distortion ? 0 : &input2,
zero_R ? 0 : &input3,
zero_new_cam ? 0 : &input4,
_mapx,_mapy);
}
}
double CV_InitUndistortRectifyMapTest::get_success_error_level( int /*test_case_idx*/, int /*i*/, int /*j*/ )
{
return 8;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
TEST(Calib3d_DefaultNewCameraMatrix, accuracy) { CV_DefaultNewCameraMatrixTest test; test.safe_run(); }
TEST(Calib3d_UndistortPoints, accuracy) { CV_UndistortPointsTest test; test.safe_run(); }
TEST(Calib3d_InitUndistortRectifyMap, accuracy) { CV_InitUndistortRectifyMapTest test; test.safe_run(); }
|
#include<iostream>
#include<math.h>
using namespace std;
class shape {
public:
int *y;
int *x;
};
// shapees 2d shape udamshih
class shape2d:public shape {
// a ni taliin urt
public:
int a;
float area();
// premetr
int pr();
};
int shape2d::pr(){
return 0;
}
float shape2d::area(){
return 0;
}
class Square:public shape2d{
public:
int *x = new int[4];
int *y = new int[4];
float area();
int pr();
};
float Square::area(){
return a*a;
}
int Square::pr(){
return a*4;
}
class Circle : public shape2d {
public:
int x;
int y;
float area();
int pr();
};
float Circle::area(){
return 3.14*a*a;
}
int Circle::pr(){
return 2*3.24*a;
}
class Triangle : public shape2d {
public:
int *x = new int[3];
int *y = new int[3];
float area();
int pr();
};
float Triangle::area(){
return (a*a*sqrt(3))/4;
}
int Triangle::pr(){
return a*3;
}
main(){
/*Kvadratiin oroin tseg bolon taliin urtiig garaas oruulan busad
oroinuud bolon primetr talbaig bodoj olood hevlej bna*/
cout<<"Kvadratiin oroin tseguudiig oruul(x,y): \n";
Square s1;
Circle c1;
Triangle t1;
cin>>s1.x[0]>>s1.y[0];
cout<<"Kvadratiin taliin urtiig oruul: ";
cin>>s1.a;
//end kvadratiin busad oroig olj bna
s1.x[1]=s1.x[0]+s1.a;
s1.y[1]=s1.y[0];
s1.y[2]=s1.y[0]+s1.a;
s1.x[2]=s1.x[0];
s1.y[3]=s1.y[0]+s1.a;
s1.x[3]=s1.x[1]+s1.a;
cout<<"Kvadratiin talbai: "<<s1.area();
cout<<"\nKvadratiin primetr: "<<s1.pr();
/*Toirgiin toviin tseg bolon radius urtiig garaas oruulan
primetr ba talbaig bodoj olood hevlej bna*/
cout<<"\nToirgiin tiviin tseguudiig oruul(x,y): \n";
cin>>c1.x>>c1.y;
cout<<"Radius oruul: ";
cin>>c1.a;
cout<<"Toirgiin talbai: "<<c1.area();
cout<<"\nToirgiin primetr: "<<c1.pr();
/*Gurvaljnii oroin tseg bolon taliin urtiig garaas oruulan busad
oroinuud bolon primetr talbaig bodoj olood hevlej bna*/
cout<<"\nGurvaljnii oroin tsegiig oruul(x,y): \n";
cin>>t1.x[0]>>t1.y[0];
cout<<"Gurvaljnii taliin urtiig oruul: ";
cin>>t1.a;
//Gurvaljnii busad oroig end olj bna
t1.y[1]=t1.a*sqrt(3)/2;
t1.x[1]=t1.x[0]-a/2;
t1.y[2]=t1.a*sqrt(3)/2;
t1.x[2]=t1.x[0]+a/2;
cout<<"Gurvaljnii talbai: "<<t1.area();
cout<<"\nGurvaljnii primetr: "<<t1.pr();
}
|
#include <chuffed/mdd/mdd_to_lgraph.h>
#include <algorithm>
// Convert a MDD into a edge-valued layer graph according to an array of costs.
EVLayerGraph::NodeID mdd_to_layergraph(EVLayerGraph& graph, MDD& r, vec<int>& costs) {
MDDTable& t(*r.table);
MDDNodeInt root = r.val;
root = t.expand(0, root);
const std::vector<MDDNode>& nodes(t.getNodes());
std::vector<int>& status(t.getStatus());
// Mark T and F as seen.
status[0] = 1;
status[1] = 1;
vec<int> node_queue;
status[root] = 1;
node_queue.push(root);
// Compute the set of edges.
// We're assuming they're collected in topological order.
int qhead = 0;
while (qhead < node_queue.size()) {
int nID = node_queue[qhead];
MDDNode nodeptr = nodes[nID];
for (unsigned int j = 0; j < nodeptr->sz; j++) {
if (status[nodeptr->edges[j].dest] == 0) {
node_queue.push(nodeptr->edges[j].dest);
status[nodeptr->edges[j].dest] = 1;
}
}
qhead++;
}
// Assign the terminal states.
status[0] = EVLayerGraph::EVFalse;
status[1] = EVLayerGraph::EVTrue;
// Scan the nodes in reverse topological order, and
// construct the corresponding ev-node.
for (qhead = node_queue.size() - 1; qhead >= 0; qhead--) {
int nID = node_queue[qhead];
MDDNode nodeptr = nodes[nID];
int vv = nodeptr->var;
vec<EVLayerGraph::EInfo> edges;
for (unsigned int j = 0; j < nodeptr->sz; j++) {
if (nodeptr->edges[j].val > costs.size()) {
break;
}
if (nodeptr->edges[j].dest != MDDFALSE) {
EVLayerGraph::NodeID dest = status[nodeptr->edges[j].dest];
unsigned int start = std::max(0, nodeptr->edges[j].val);
unsigned int end = (j + 1 < nodeptr->sz && nodeptr->edges[j + 1].val <= costs.size())
? nodeptr->edges[j + 1].val
: costs.size();
for (unsigned int k = start; k < end; k++) {
EVLayerGraph::EInfo einfo = {static_cast<int>(k), costs[k], dest};
edges.push(einfo);
}
}
}
status[nID] = graph.insert(vv, edges);
}
EVLayerGraph::NodeID ret = status[root];
// Clear the status flags.
status[0] = 0;
status[1] = 0;
for (qhead = 0; qhead < node_queue.size(); qhead++) {
status[node_queue[qhead]] = 0;
}
return ret;
}
|
// Created on: 1992-04-06
// Created by: Christian CAILLET
// Copyright (c) 1992-1999 Matra Datavision
// Copyright (c) 1999-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IGESData_IGESReaderTool_HeaderFile
#define _IGESData_IGESReaderTool_HeaderFile
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
#include <Interface_GeneralLib.hxx>
#include <Interface_ReaderLib.hxx>
#include <Standard_Integer.hxx>
#include <IGESData_IGESType.hxx>
#include <IGESData_ReadStage.hxx>
#include <Interface_FileReaderTool.hxx>
class Interface_ParamList;
class IGESData_FileRecognizer;
class Interface_Check;
class IGESData_IGESReaderData;
class IGESData_Protocol;
class Standard_Transient;
class Interface_InterfaceModel;
class IGESData_IGESEntity;
class IGESData_DirPart;
class IGESData_ParamReader;
//! specific FileReaderTool for IGES
//! Parameters are accessed through specific objects, ParamReaders
class IGESData_IGESReaderTool : public Interface_FileReaderTool
{
public:
DEFINE_STANDARD_ALLOC
//! creates IGESReaderTool to work with an IGESReaderData and an
//! IGES Protocol.
//! Actually, no Lib is used
Standard_EXPORT IGESData_IGESReaderTool(const Handle(IGESData_IGESReaderData)& reader, const Handle(IGESData_Protocol)& protocol);
//! binds empty entities to records, works with the Protocol
//! (from IGESData) stored and later used
//! RQ : Actually, sets DNum into IGES Entities
//! Also loads the list of parameters for ParamReader
Standard_EXPORT void Prepare (const Handle(IGESData_FileRecognizer)& reco);
//! recognizes records by asking Protocol (on data of DirType)
Standard_EXPORT Standard_Boolean Recognize (const Standard_Integer num, Handle(Interface_Check)& ach, Handle(Standard_Transient)& ent) Standard_OVERRIDE;
//! fills model's header, that is, its GlobalSection
Standard_EXPORT void BeginRead (const Handle(Interface_InterfaceModel)& amodel) Standard_OVERRIDE;
//! fills an entity, given record no; works by calling ReadDirPart
//! then ReadParams (with help of a ParamReader), then if required
//! ReadProps and ReadAssocs, from IGESEntity
//! Returns True if no fail has been recorded
Standard_EXPORT Standard_Boolean AnalyseRecord (const Standard_Integer num, const Handle(Standard_Transient)& anent, Handle(Interface_Check)& acheck) Standard_OVERRIDE;
//! after reading entities, true line weights can be computed
Standard_EXPORT virtual void EndRead (const Handle(Interface_InterfaceModel)& amodel) Standard_OVERRIDE;
//! Reads directory part components from file; DP is the literal
//! directory part, IR detains entities referenced by DP
Standard_EXPORT void ReadDir (const Handle(IGESData_IGESEntity)& ent, const Handle(IGESData_IGESReaderData)& IR, const IGESData_DirPart& DP, Handle(Interface_Check)& ach) const;
//! Performs Reading of own Parameters for each IGESEntity
//! Works with the ReaderLib loaded with ReadWriteModules for IGES
//! In case of failure, tries UndefinedEntity from IGES
Standard_EXPORT void ReadOwnParams (const Handle(IGESData_IGESEntity)& ent, const Handle(IGESData_IGESReaderData)& IR, IGESData_ParamReader& PR) const;
//! Reads Property List, if there is (if not, does nothing)
//! criterium is : current parameter of PR remains inside params
//! list, and Stage is "Own"
//! Current parameter must be a positive integer, which value
//! gives the length of the list; else, a Fail is produced (into
//! Check of PR) and reading process is stopped
Standard_EXPORT void ReadProps (const Handle(IGESData_IGESEntity)& ent, const Handle(IGESData_IGESReaderData)& IR, IGESData_ParamReader& PR) const;
//! Reads Associativity List, if there is (if not, does nothing)
//! criterium is : current parameter of PR remains inside params
//! list, and Stage is "Own"
//! Same conditions as above; in addition, no parameter must be
//! let after the list once read
//! Note that "Associated" entities are not declared "Shared"
Standard_EXPORT void ReadAssocs (const Handle(IGESData_IGESEntity)& ent, const Handle(IGESData_IGESReaderData)& IR, IGESData_ParamReader& PR) const;
protected:
private:
Handle(Interface_ParamList) thelist;
Handle(IGESData_FileRecognizer) thereco;
Interface_GeneralLib theglib;
Interface_ReaderLib therlib;
Standard_Integer thecnum;
IGESData_IGESType thectyp;
IGESData_ReadStage thestep;
Handle(Interface_Check) thechk;
Standard_Integer thegradweight;
Standard_Real themaxweight;
Standard_Real thedefweight;
};
#endif // _IGESData_IGESReaderTool_HeaderFile
|
#include "compiler/function_manager.hpp"
#include <boost/test/unit_test.hpp>
using namespace perseus::detail;
typedef function_manager::function_pointer iterator;
BOOST_AUTO_TEST_SUITE( compiler )
BOOST_AUTO_TEST_SUITE( function_manager_tests )
using namespace std::string_literals;
BOOST_AUTO_TEST_CASE( register_functions )
{
using namespace perseus::detail;
function_manager man;
{
iterator add;
BOOST_REQUIRE( man.register_function( function_signature{ "add"s, { type_id::i32, type_id::i32 } }, function_info{ type_id::i32 }, add ) );
iterator subtract;
BOOST_REQUIRE( man.register_function( function_signature{ "subtract"s,{ type_id::i32, type_id::i32 } }, function_info{ type_id::i32 }, subtract ) );
BOOST_CHECK_EQUAL( add->first.name, "add"s );
BOOST_CHECK_EQUAL( subtract->first.name, "subtract"s );
}
}
BOOST_AUTO_TEST_CASE( functions_lookup )
{
function_manager man;
{
function_signature add_signature{ "add"s,{ type_id::i32, type_id::i32 } };
iterator add;
BOOST_REQUIRE( man.register_function( function_signature{ add_signature }, function_info{ type_id::i32 }, add ) );
iterator subtract;
BOOST_REQUIRE( man.register_function( function_signature{ "subtract"s,{ type_id::i32, type_id::i32 } }, function_info{ type_id::i32 }, subtract ) );
iterator found_add;
BOOST_REQUIRE( man.get_function( add_signature, found_add ) );
BOOST_CHECK_EQUAL( found_add->first.name, "add"s );
}
}
BOOST_AUTO_TEST_SUITE_END()
BOOST_AUTO_TEST_SUITE_END()
|
//Standard input/output library
#include <iostream>
int main(){
double tempf;
double tempc;
std::cout << "Input your city temperature(f): ";
std::cin >> tempf;
//store celcius value in tempc
tempc = (tempf - 32)/1.8;
std::cout << "Your city temperature is " << tempc << " degrees Celcius.";
}
|
#include <iostream>
#include <cstring>
#include <vector>
const int MAX = 1001;
int n, m, k, d[MAX];
bool check[MAX];
std::vector<int> list[MAX];
bool dfs(int worker)
{
for(auto x : list[worker])
{
if(check[x])
{
continue;
}
check[x] = 1;
if(d[x] == 0 || dfs(d[x]))
{
d[x] = worker;
return 1;
}
}
return 0;
}
int main()
{
scanf("%d %d %d", &n, &m, &k);
for(int i = 1; i <= n; i++)
{
int c;
scanf("%d", &c);
for(int j = 0; j < c; j++)
{
int idx;
scanf("%d", &idx);
list[i].push_back(idx);
}
}
int ans = 0, k_i = 0;
for(int i = 1; i <= n; i++)
{
std::memset(check, 0, sizeof(check));
if(dfs(i))
{
ans++;
}
}
for(int i = 1; i <= n; i++)
{
if(list[i].size() > 1)
{
std::memset(check, 0, sizeof(check));
if(dfs(i))
{
k_i++;
ans++;
}
}
if(k_i == k)
{
break;
}
}
std::cout << ans << '\n';
return 0;
}
|
#include<iostream>
using namespace std;
class node{
public:
int data;
node* next;
//Constructor
node(int d){
data = d;
next = NULL;
}
};
void insert(node*& head,int data)
{
if(head==NULL)
{
head=new node(data);
return;
}
node *tail=head;
while(tail->next!=NULL)
{
tail=tail->next;
}
tail->next=new node(data);
return;
}
void print(node *head)
{while(head!=NULL){
cout<<head->data<<"->";
head = head->next;
}
cout<<endl;
}
node *reverse (node *head, int k)
{
node* current = head;
node* next = NULL;
node* prev = NULL;
int count = 0;
while (current != NULL && count < k)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
count++;
}
if (next != NULL)
head->next = reverse(next, k);
return prev;
}
int main()
{
node* head=NULL;
int n,k;
cin>>n>>k;
for(int i=0;i<n;i++)
{
int a;
cin>>a;
insert(head,a);
}
head=reverse(head,k);
print(head);
return 0;
}
|
#include <iostream>
#include <iomanip>
#include <ctime>
using namespace std;
double solve(int);
int main() {
clock_t start = clock();
double result = solve(32);
clock_t end = clock();
cout << setprecision(11);
cout << result << ' ' << static_cast<double>(end - start) / CLOCKS_PER_SEC << endl;
system("PAUSE");
}
double solve(int bits) {
long long pascals[65][65];
pascals[0][0] = 1;
for (int i = 1; i <= bits; ++i) {
pascals[i][0] = 1;
for (int j = 1; j < bits; ++j) {
pascals[i][j] = pascals[i - 1][j - 1] + pascals[i - 1][j];
}
pascals[i][i] = 1;
}
const int turns = 101;
double ev[turns][65];
memset(ev, 0.0, sizeof(ev));
long long total = pow(2, bits);
double result = 0.0;
ev[0][0] = 1.0;
for (int i = 0; i < turns - 1; ++i) {
for (int j = 0; j < bits; ++j) {
for (int n = 0; n <= j; ++n) {
for (int m = 0; m <= bits - j; ++m) {
ev[i + 1][m + j] += static_cast<double>(pascals[j][n] * pascals[bits - j][m]) / total * ev[i][j];
}
}
}
result += i * ev[i][bits];
}
result += (turns - 1) * ev[turns - 1][bits];
return result;
}
|
//---------------------------------------------------------------------------
#pragma hdrstop
#include "ISourceGenType.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
int ContainStr(String from, String to)
{
String fromLowerCase = from.LowerCase();
String toLowerCase = to.LowerCase();
return fromLowerCase.Pos(toLowerCase);
}
bool IsDataSetKeyName(String name)
{
if(ContainStr(name, "_KEY_"))
return true;
return false;
}
bool IsADOStoreInputName(String name)
{
if(ContainStr(name, "_I_"))
return true;
return false;
}
String GetADOType(String type)
{
if(type == "float" || type == "char")
return type;
else
return "int";
}
/////////////////////////////////////////////////////////////////////
ReadDataGen::ReadDataGen()
{
m_GenType = "ReadData";
}
ReadDataGen::~ReadDataGen()
{
}
String ReadDataGen::NeedToStringGen(IClassMember * curMember)
{
return FormatStr("%s.SetLength(%s);ReadBuf(_lpData, pos, %s.c_str(), %s);",
curMember->GetName(), curMember->GetArrayVar(),
curMember->GetName(), curMember->GetArrayVar());
}
String ReadDataGen::NormalTypeGen(IClassMember * curMember)
{
String type = curMember->GetType();
if(type == "char" || type == "BYTE")
{
return FormatStr("%s = ReadBYTE(_lpData, pos);", curMember->GetName());
}
else if(type == "short" || type == "WORD")
{
return FormatStr("%s = ReadWORD(_lpData, pos);", curMember->GetName());
}
else if(type == "int" || type == "DWORD")
{
return FormatStr("%s = ReadDWORD(_lpData, pos);", curMember->GetName());
}
else if(type == "float")
{
return FormatStr("%s = ReadFloat(_lpData, pos);", curMember->GetName());
}
else if(type == "double")
{
return FormatStr("%s = ReadDouble(_lpData, pos);", curMember->GetName());
}
return "?";
}
String ReadDataGen::ExTypeGen(IClassMember * curMember)
{
return FormatStr("pos+=%s.ReadData(_lpData+pos, _Len-pos, Key);", curMember->GetName());
}
String ReadDataGen::ExTypeArrayGen(IClassMember * curMember)
{
return FormatStr("for(int i=0; i<%s; i++) pos+=%s[i].ReadData(_lpData+pos, _Len-pos, Key);",
curMember->GetArrayVar(), curMember->GetName());
}
String ReadDataGen::NormalArrayGen(IClassMember * curMember)
{
return FormatStr("ReadBuf(_lpData, pos, &%s[0], %s * sizeof(%s));",
curMember->GetName(), curMember->GetArrayVar(),
curMember->GetType());
}
String ReadDataGen::NormalDArrayGen(IClassMember * curMember)
{
return FormatStr("%s.resize(%s);memcpy(&%s[0],_lpData+pos,%s*sizeof(%s));pos+=%s*sizeof(%s);",
curMember->GetName(), curMember->GetArrayVar(),
curMember->GetName(), curMember->GetArrayVar(), curMember->GetType(),
curMember->GetArrayVar(), curMember->GetType());
}
String ReadDataGen::DArrayGen(IClassMember * curMember)
{
return FormatStr("while(%s.Count()<%s) %s.Add(new %s);for(int i=0; i<%s; i++) pos+=%s[i]->ReadData(_lpData+pos, _Len-pos, Key);",
curMember->GetName(), curMember->GetArrayVar(),
curMember->GetName(), curMember->GetType(),
curMember->GetArrayVar(), curMember->GetName());
}
///////////////////////////////////////////////////////////////////////
ClearGen::ClearGen()
{
m_GenType = "Clear";
}
ClearGen::~ClearGen()
{
}
String ClearGen::NeedToStringGen(IClassMember * curMember)
{
return FormatStr("%s = \"\";", curMember->GetName());
}
String ClearGen::NormalTypeGen(IClassMember * curMember)
{
return FormatStr("%s = 0;", curMember->GetName());
}
String ClearGen::ExTypeGen(IClassMember * curMember)
{
return FormatStr("%s.Clear();", curMember->GetName());
}
String ClearGen::ExTypeArrayGen(IClassMember * curMember)
{
return FormatStr("for(int i=0; i<%s; i++) %s[i].Clear();",
curMember->GetArrayVar(), curMember->GetName());
}
String ClearGen::NormalArrayGen(IClassMember * curMember)
{
return FormatStr("memset(%s, 0, %s * sizeof(%s));",
curMember->GetName(), curMember->GetArrayVar(),
curMember->GetType());
}
String ClearGen::NormalDArrayGen(IClassMember * curMember)
{
return FormatStr("%s.clear();", curMember->GetName());
}
String ClearGen::DArrayGen(IClassMember * curMember)
{
return FormatStr("%s.Clear();", curMember->GetName());
}
///////////////////////////////////////////////////////////////////////
GetLengthGen::GetLengthGen()
{
m_GenType = "GetLength";
m_CurLength = "length";
}
GetLengthGen::~GetLengthGen()
{
}
String GetLengthGen::NeedToStringGen(IClassMember * curMember)
{
int length = curMember->GetArrayVar().ToIntDef(-1);
if(length == -1)
{
//动态
return FormatStr("%s += %s.Length();", m_CurLength, curMember->GetName());
}
else
{
//静态
return FormatStr("%s += %d;", m_CurLength, length);
}
}
String GetLengthGen::NormalTypeGen(IClassMember * curMember)
{
return FormatStr("%s += sizeof(%s);", m_CurLength, curMember->GetType());
}
String GetLengthGen::ExTypeGen(IClassMember * curMember)
{
return FormatStr("%s += %s.GetLength();", m_CurLength, curMember->GetName());
}
String GetLengthGen::ExTypeArrayGen(IClassMember * curMember)
{
return FormatStr("for(int i=0; i<%s; i++) %s += %s[i].GetLength();",
curMember->GetArrayVar(), m_CurLength, curMember->GetName());
}
String GetLengthGen::NormalArrayGen(IClassMember * curMember)
{
return FormatStr("%s += sizeof(%s) * %s;", m_CurLength, curMember->GetType(), curMember->GetArrayVar());
}
String GetLengthGen::NormalDArrayGen(IClassMember * curMember)
{
return FormatStr("%s += sizeof(%s) * %s.size();", m_CurLength, curMember->GetType(), curMember->GetName());
}
String GetLengthGen::DArrayGen(IClassMember * curMember)
{
return FormatStr("for(int i=0; i<%s.Count(); i++) %s += %s[i]->GetLength();",
curMember->GetName(), m_CurLength, curMember->GetName());
}
///////////////////////////////////////////////////////////////////////
WriteBufferGen::WriteBufferGen()
{
m_GenType = "WriteBuffer";
m_Data = "data";
}
WriteBufferGen::~WriteBufferGen()
{
}
String WriteBufferGen::NeedToStringGen(IClassMember * curMember)
{
int varValue = curMember->GetArrayVar().ToIntDef(0);
if(varValue == 0)
return FormatStr("WriteBuf(%s.c_str(),pos, %s.c_str(), %s.Length());",
m_Data, curMember->GetName(), curMember->GetName());
else
return FormatStr("WriteBuf(%s.c_str(),pos, %s.c_str(), %s.Length());pos+=%d-%s.Length();",
m_Data, curMember->GetName(), curMember->GetName(), varValue, curMember->GetName());
}
String WriteBufferGen::NormalTypeGen(IClassMember * curMember)
{
String type = curMember->GetType();
if(type == "char" || type == "BYTE")
{
return FormatStr("WriteBYTE(%s.c_str(), pos, %s);", m_Data, curMember->GetName());
}
else if(type == "short" || type == "WORD")
{
return FormatStr("WriteWORD(%s.c_str(), pos, %s);", m_Data, curMember->GetName());
}
else if(type == "int" || type == "DWORD")
{
return FormatStr("WriteDWORD(%s.c_str(), pos, %s);", m_Data, curMember->GetName());
}
else if(type == "float")
{
return FormatStr("WriteFloat(%s.c_str(), pos, %s);", m_Data, curMember->GetName());
}
else if(type == "double")
{
return FormatStr("WriteDouble(%s.c_str(), pos, %s);", m_Data, curMember->GetName());
}
return "?";
}
String WriteBufferGen::ExTypeGen(IClassMember * curMember)
{
return FormatStr("WriteBuf(%s.c_str(),pos, %s.GetBuffer(Key).c_str(), %s.GetLength());",
m_Data, curMember->GetName(), curMember->GetName());
}
String WriteBufferGen::ExTypeArrayGen(IClassMember * curMember)
{
return FormatStr("for(int i=0; i<%s; i++) WriteBuf(%s.c_str(),pos, %s[i].GetBuffer(Key).c_str(), %s[i].GetLength());",
curMember->GetArrayVar(), m_Data,
curMember->GetName(), curMember->GetName());
}
String WriteBufferGen::NormalArrayGen(IClassMember * curMember)
{
return FormatStr("WriteBuf(%s.c_str(),pos, &%s[0], sizeof(%s) * %s);",
m_Data, curMember->GetName(), curMember->GetType(), curMember->GetArrayVar());
}
String WriteBufferGen::NormalDArrayGen(IClassMember * curMember)
{
return FormatStr("WriteBuf(%s.c_str(),pos, &%s[0], sizeof(%s) * %s.size());",
m_Data, curMember->GetName(), curMember->GetType(), curMember->GetName());
}
String WriteBufferGen::DArrayGen(IClassMember * curMember)
{
return FormatStr("for(int i=0; i<%s.Count(); i++) WriteBuf(%s.c_str(),pos, %s[i]->GetBuffer().c_str(), %s[i]->GetLength());",
curMember->GetName(), m_Data,
curMember->GetName(), curMember->GetName());
}
///////////////////////////////////////////////////////////////////////
MemberGetFuncGen::MemberGetFuncGen()
{
m_GenType = "GetFunc";
}
MemberGetFuncGen::~MemberGetFuncGen()
{
}
String MemberGetFuncGen::NeedToStringGen(IClassMember * curMember)
{
return FormatStr("String\t\tGet%s()", curMember->GetName());
}
String MemberGetFuncGen::NormalTypeGen(IClassMember * curMember)
{
return FormatStr("%s\t\tGet%s()", curMember->GetType(), curMember->GetName());
}
String MemberGetFuncGen::ExTypeGen(IClassMember * curMember)
{
return FormatStr("%s*\t\tGet%s()", curMember->GetType(), curMember->GetName());
}
String MemberGetFuncGen::ExTypeArrayGen(IClassMember * curMember)
{
return FormatStr("%s*\t\tGet%s(int index)", curMember->GetType(), curMember->GetName());
}
String MemberGetFuncGen::NormalArrayGen(IClassMember * curMember)
{
return FormatStr("%s\t\tGet%s(int index)", curMember->GetType(), curMember->GetName());
}
String MemberGetFuncGen::NormalDArrayGen(IClassMember * curMember)
{
return FormatStr("%s\t\tGet%s(int index)", curMember->GetType(), curMember->GetName());
}
String MemberGetFuncGen::DArrayGen(IClassMember * curMember)
{
return FormatStr("%s*\t\tGet%s(int index)", curMember->GetType(), curMember->GetName());
}
///////////////////////////////////////////////////////////////////////
MemberReturnGetFunc::MemberReturnGetFunc()
{
m_GenType = "GetReturnFunc";
}
MemberReturnGetFunc::~MemberReturnGetFunc()
{
}
String MemberReturnGetFunc::NeedToStringGen(IClassMember * curMember)
{
return FormatStr("return m_Detail->%s;", curMember->GetName());
}
String MemberReturnGetFunc::NormalTypeGen(IClassMember * curMember)
{
return FormatStr("return m_Detail->%s;", curMember->GetName());
}
String MemberReturnGetFunc::ExTypeGen(IClassMember * curMember)
{
return FormatStr("return &m_Detail->%s;", curMember->GetName());
}
String MemberReturnGetFunc::ExTypeArrayGen(IClassMember * curMember)
{
return FormatStr("if(index>=0 && index<%s)return &m_Detail->%s[index];else return NULL;",
curMember->GetArrayVar(), curMember->GetName());
}
String MemberReturnGetFunc::NormalArrayGen(IClassMember * curMember)
{
return FormatStr("if(index>=0 && index<%s)return m_Detail->%s[index];else return 0;",
curMember->GetArrayVar(), curMember->GetName());
}
String MemberReturnGetFunc::NormalDArrayGen(IClassMember * curMember)
{
return FormatStr("if(index>=0 && index<(int)%s.size())return m_Detail->%s[index];else return 0;",
curMember->GetName(), curMember->GetName());
}
String MemberReturnGetFunc::DArrayGen(IClassMember * curMember)
{
return FormatStr("if(index>=0 && index<%s.Count())return &m_Detail->%s[index];else return NULL;",
curMember->GetName(), curMember->GetName());
}
//--------------------------------------------------------------
ADOStoreCreateGen::ADOStoreCreateGen()
{
m_GenType = "ADOStoreCreate";
}
ADOStoreCreateGen::~ADOStoreCreateGen()
{
}
String ADOStoreCreateGen::NeedToStringGen(IClassMember * curMember)
{
String head = FormatStr("StoredProc->Parameters->CreateParameter(\"@%s\"", curMember->GetName());
if(IsADOStoreInputName(curMember->GetName()))
{
//输入
return FormatStr("%s, ftString, pdInput, %d, %s);", head,
curMember->GetArrayVar().ToIntDef(0),
curMember->GetName());
}
else
{
//输出
return FormatStr("if(bNeedOutput)%s, ftString, pdOutput, %d, \"\");else{%s, ftString, pdInput, %d, %s);}", head,
curMember->GetArrayVar().ToIntDef(0),head,
curMember->GetArrayVar().ToIntDef(0),
curMember->GetName()
);
}
}
String ADOStoreCreateGen::NormalTypeGen(IClassMember * curMember)
{
String head = FormatStr("StoredProc->Parameters->CreateParameter(\"@%s\"", curMember->GetName());
String type = "ftInteger";
String changeType = "int";
if(curMember->GetType() == "double")
{
type = "ftDateTime";
changeType = "double";
}
if(IsADOStoreInputName(curMember->GetName()))
{
//输入
return FormatStr("%s, %s, pdInput, sizeof(int), (%s)%s);",
head, type, changeType, curMember->GetName());
}
else
{
//输出
return FormatStr("if(bNeedOutput)%s, %s, pdOutput, sizeof(int), %d);else{%s, %s, pdInput, sizeof(int), (%s)%s);}",
head, type, -1,
head, type, changeType, curMember->GetName());
}
}
String ADOStoreCreateGen::ExTypeGen(IClassMember * curMember)
{
return FormatStr("%s.ADOStoreCreate(StoredProc);", curMember->GetName());
}
String ADOStoreCreateGen::ExTypeArrayGen(IClassMember * curMember)
{
return "";
}
String ADOStoreCreateGen::NormalArrayGen(IClassMember * curMember)
{
return "";
}
String ADOStoreCreateGen::NormalDArrayGen(IClassMember * curMember)
{
return "";
}
String ADOStoreCreateGen::DArrayGen(IClassMember * curMember)
{
return "";
}
//--------------------------------------------------------------
ADOStoreReadGen::ADOStoreReadGen()
{
m_GenType = "ADOStoreRead";
}
ADOStoreReadGen::~ADOStoreReadGen()
{
}
String ADOStoreReadGen::NeedToStringGen(IClassMember * curMember)
{
if(IsADOStoreInputName(curMember->GetName()))
{
//输入
return "";
}
else
{
//输出
int arrayLength = curMember->GetArrayVar().ToIntDef(-1);
if(arrayLength == -1)
{
return FormatStr("%s = StoredProc->Parameters->ParamByName(\"@%s\")->Value;",
curMember->GetName(), curMember->GetName());
}
else
return FormatStr("buffer = StoredProc->Parameters->ParamByName(\"@%s\")->Value;buffer=buffer.Trim();memcpy(%s, buffer.c_str(), buffer.Length());",
curMember->GetName(), curMember->GetName());
}
}
String ADOStoreReadGen::NormalTypeGen(IClassMember * curMember)
{
if(IsADOStoreInputName(curMember->GetName()))
{
//输入
return "";
}
else
{
//输出
return FormatStr("%s = (%s)StoredProc->Parameters->ParamByName(\"@%s\")->Value;",
curMember->GetName(),
curMember->GetType(), curMember->GetName());
}
}
String ADOStoreReadGen::ExTypeGen(IClassMember * curMember)
{
//输出
return FormatStr("%s.ADOStoreRead(StoredProc);", curMember->GetName());
}
String ADOStoreReadGen::ExTypeArrayGen(IClassMember * curMember)
{
return "";
}
String ADOStoreReadGen::NormalArrayGen(IClassMember * curMember)
{
return "";
}
String ADOStoreReadGen::NormalDArrayGen(IClassMember * curMember)
{
return "";
}
String ADOStoreReadGen::DArrayGen(IClassMember * curMember)
{
return "";
}
////////////////////////////////////////////////////////////////////
DataSetCreateGen::DataSetCreateGen()
{
m_GenType = "DataSetCreate";
}
DataSetCreateGen::~DataSetCreateGen()
{
}
String DataSetCreateGen::NeedToStringGen(IClassMember * curMember)
{
return FormatStr("[%s] [char] (%s) COLLATE Chinese_PRC_CI_AS NOT NULL ,",
curMember->GetName(),
curMember->GetArrayVar());
}
String DataSetCreateGen::NormalTypeGen(IClassMember * curMember)
{
String type = GetADOType(curMember->GetType());
return FormatStr("[%s] [%s] NOT NULL ,",
curMember->GetName(),
type);
}
String DataSetCreateGen::ExTypeGen(IClassMember * curMember)
{
return "";
}
String DataSetCreateGen::ExTypeArrayGen(IClassMember * curMember)
{
return "";
}
String DataSetCreateGen::NormalArrayGen(IClassMember * curMember)
{
return "";
}
String DataSetCreateGen::NormalDArrayGen(IClassMember * curMember)
{
return "";
}
String DataSetCreateGen::DArrayGen(IClassMember * curMember)
{
return "";
}
/////////////////////////////////////////////////////////////////
MemberADOProcNameGen::MemberADOProcNameGen()
{
m_GenType = "MemberADOProcName";
}
MemberADOProcNameGen::~MemberADOProcNameGen()
{
}
String MemberADOProcNameGen::NeedToStringGen(IClassMember * curMember)
{
if(IsADOStoreInputName(curMember->GetName()))
{
return FormatStr("@%s char(%s), ",
curMember->GetName(),
curMember->GetArrayVar());
}
else
{
return FormatStr("@%s char(%s) OUTPUT, ",
curMember->GetName(),
curMember->GetArrayVar());
}
}
String MemberADOProcNameGen::NormalTypeGen(IClassMember * curMember)
{
String type = GetADOType(curMember->GetType());
if(IsADOStoreInputName(curMember->GetName()))
{
return FormatStr("@%s %s, ",
curMember->GetName(),
type);
}
else
{
return FormatStr("@%s %s OUTPUT, ",
curMember->GetName(),
type);
}
}
String MemberADOProcNameGen::ExTypeGen(IClassMember * curMember)
{
return "";
}
String MemberADOProcNameGen::ExTypeArrayGen(IClassMember * curMember)
{
return "";
}
String MemberADOProcNameGen::NormalArrayGen(IClassMember * curMember)
{
return "";
}
String MemberADOProcNameGen::NormalDArrayGen(IClassMember * curMember)
{
return "";
}
String MemberADOProcNameGen::DArrayGen(IClassMember * curMember)
{
return "";
}
/////////////////////////////////////////////////////////////////
MemberADOProcNoOutputGen::MemberADOProcNoOutputGen()
{
m_GenType = "MemberADOProcNoOutput";
}
MemberADOProcNoOutputGen::~MemberADOProcNoOutputGen()
{
}
String MemberADOProcNoOutputGen::NeedToStringGen(IClassMember * curMember)
{
if(IsADOStoreInputName(curMember->GetName()))
{
return FormatStr("@%s char(%s), ",
curMember->GetName(),
curMember->GetArrayVar());
}
else
{
return FormatStr("@%s char(%s), ",
curMember->GetName(),
curMember->GetArrayVar());
}
}
String MemberADOProcNoOutputGen::NormalTypeGen(IClassMember * curMember)
{
String type = GetADOType(curMember->GetType());
if(IsADOStoreInputName(curMember->GetName()))
{
return FormatStr("@%s %s, ",
curMember->GetName(),
type);
}
else
{
return FormatStr("@%s %s, ",
curMember->GetName(),
type);
}
}
String MemberADOProcNoOutputGen::ExTypeGen(IClassMember * curMember)
{
return "";
}
String MemberADOProcNoOutputGen::ExTypeArrayGen(IClassMember * curMember)
{
return "";
}
String MemberADOProcNoOutputGen::NormalArrayGen(IClassMember * curMember)
{
return "";
}
String MemberADOProcNoOutputGen::NormalDArrayGen(IClassMember * curMember)
{
return "";
}
String MemberADOProcNoOutputGen::DArrayGen(IClassMember * curMember)
{
return "";
}
//////////////////////////////////////
ADOQueryReadFunc::ADOQueryReadFunc()
{
m_GenType = "ADOQueryReadFunc";
}
ADOQueryReadFunc::~ADOQueryReadFunc()
{
}
String ADOQueryReadFunc::NeedToStringGen(IClassMember * curMember)
{
int arrayLength = curMember->GetArrayVar().ToIntDef(-1);
if(arrayLength == -1)
{
return FormatStr("%s = ADOQuery->FieldByName(\"%s\")->AsString.Trim();",
curMember->GetName(), curMember->GetName());
}
else
return FormatStr("buffer = ADOQuery->FieldByName(\"%s\")->AsString.Trim();memcpy(%s, buffer.c_str(), buffer.Length());",
curMember->GetName(), curMember->GetName());
}
String ADOQueryReadFunc::NormalTypeGen(IClassMember * curMember)
{
return FormatStr("%s = ADOQuery->FieldByName(\"%s\")->AsInteger;",
curMember->GetName(), curMember->GetName());
}
String ADOQueryReadFunc::ExTypeGen(IClassMember * curMember)
{
return "";
}
String ADOQueryReadFunc::ExTypeArrayGen(IClassMember * curMember)
{
return "";
}
String ADOQueryReadFunc::NormalArrayGen(IClassMember * curMember)
{
return "";
}
String ADOQueryReadFunc::NormalDArrayGen(IClassMember * curMember)
{
return "";
}
String ADOQueryReadFunc::DArrayGen(IClassMember * curMember)
{
return "";
}
|
//
// main.cpp
// Tarea3Ejercicio1
//
// Created by Daniel on 07/10/14.
// Copyright (c) 2014 Gotomo. All rights reserved.
//
#include <iostream>
#include "ListaEnlazada.h"
#define N 100
int main(int argc, const char * argv[]) {
srand((int) time(NULL));
int num;
ListaEnlazada<int> * lista = new ListaEnlazada<int>();
for(int i = 0; i < N; ++i){
num = rand() %100;
lista->insertBack(num);
}
std::cout<<"Orden original: "<<std::endl;
std::cout<<*lista<<std::endl;
std::cout<<"Orden inverso: "<<std::endl;
for(int i = N-1; i >= 0; --i){
std::cout<< * (lista->At(i))<<", ";
}
delete lista;
return 0;
}
|
// New Connection Dialog
//
// Copyright (C) 2008
// Center for Perceptual Systems
// University of Texas at Austin
//
// jsp Wed Jul 2 16:16:51 CDT 2008
#ifndef NEW_CONNECTION_DIALOG_H
#define NEW_CONNECTION_DIALOG_H
#include "persistent_dialog.h"
#include "ui_new_connection_dialog.h"
namespace flying_dragon
{
class NewConnectionDialog : public PersistentDialog
{
Q_OBJECT
public:
NewConnectionDialog (QWidget *parent)
: PersistentDialog (parent)
{
ui_.setupUi(this);
}
QString HostAddress () const
{
return ui_.addressLineEdit->text ();
}
private:
Ui::NewConnectionDialog ui_;
};
} // namespace flying_dragon
#endif // NEW_CONNECTION_DIALOG_H
|
//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2012, 2013 Ripple Labs Inc.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#if RIPPLE_MDB_AVAILABLE
namespace NodeStore
{
class MdbFactory::BackendImp
: public Backend
, public BatchWriter::Callback
, public LeakChecked <MdbFactory::BackendImp>
{
public:
explicit BackendImp (size_t keyBytes,
Parameters const& keyValues,
Scheduler& scheduler)
: m_keyBytes (keyBytes)
, m_scheduler (scheduler)
, m_batch (*this, scheduler)
, m_env (nullptr)
{
String path (keyValues ["path"]);
if (path.isEmpty ())
Throw (std::runtime_error ("Missing path in MDB backend"));
m_basePath = path.toStdString();
// Regarding the path supplied to mdb_env_open:
// This directory must already exist and be writable.
//
File dir (File::getCurrentWorkingDirectory().getChildFile (path));
Result result = dir.createDirectory ();
if (result.wasOk ())
{
int error = mdb_env_create (&m_env);
// Should use the size of the file plus the free space on the disk
if (error == 0)
error = mdb_env_set_mapsize (m_env, 512L * 1024L * 1024L * 1024L);
if (error == 0)
error = mdb_env_open (
m_env,
m_basePath.c_str (),
MDB_NOTLS,
0664);
MDB_txn* txn;
if (error == 0)
error = mdb_txn_begin (m_env, NULL, 0, &txn);
if (error == 0)
error = mdb_dbi_open (txn, NULL, 0, &m_dbi);
if (error == 0)
error = mdb_txn_commit (txn);
if (error != 0)
{
String s;
s << "Error #" << error << " creating mdb environment";
Throw (std::runtime_error (s.toStdString ()));
}
}
else
{
String s;
s << "MDB Backend failed to create directory, " << result.getErrorMessage ();
Throw (std::runtime_error (s.toStdString().c_str()));
}
}
~BackendImp ()
{
if (m_env != nullptr)
{
mdb_dbi_close (m_env, m_dbi);
mdb_env_close (m_env);
}
}
std::string getName()
{
return m_basePath;
}
//--------------------------------------------------------------------------
template <class T>
unsigned char* mdb_cast (T* p)
{
return const_cast <unsigned char*> (static_cast <unsigned char const*> (p));
}
Status fetch (void const* key, NodeObject::Ptr* pObject)
{
pObject->reset ();
Status status (ok);
MDB_txn* txn = nullptr;
int error = 0;
error = mdb_txn_begin (m_env, NULL, MDB_RDONLY, &txn);
if (error == 0)
{
MDB_val dbkey;
MDB_val data;
dbkey.mv_size = m_keyBytes;
dbkey.mv_data = mdb_cast (key);
error = mdb_get (txn, m_dbi, &dbkey, &data);
if (error == 0)
{
DecodedBlob decoded (key, data.mv_data, data.mv_size);
if (decoded.wasOk ())
{
*pObject = decoded.createObject ();
}
else
{
status = dataCorrupt;
}
}
else if (error == MDB_NOTFOUND)
{
status = notFound;
}
else
{
status = unknown;
WriteLog (lsWARNING, NodeObject) << "MDB txn failed, code=" << error;
}
mdb_txn_abort (txn);
}
else
{
status = unknown;
WriteLog (lsWARNING, NodeObject) << "MDB txn failed, code=" << error;
}
return status;
}
void store (NodeObject::ref object)
{
m_batch.store (object);
}
void storeBatch (Batch const& batch)
{
MDB_txn* txn = nullptr;
int error = 0;
error = mdb_txn_begin (m_env, NULL, 0, &txn);
if (error == 0)
{
EncodedBlob::Pool::ScopedItem item (m_blobPool);
BOOST_FOREACH (NodeObject::Ptr const& object, batch)
{
EncodedBlob& encoded (item.getObject ());
encoded.prepare (object);
MDB_val key;
key.mv_size = m_keyBytes;
key.mv_data = mdb_cast (encoded.getKey ());
MDB_val data;
data.mv_size = encoded.getSize ();
data.mv_data = mdb_cast (encoded.getData ());
error = mdb_put (txn, m_dbi, &key, &data, 0);
if (error != 0)
{
WriteLog (lsWARNING, NodeObject) << "mdb_put failed, error=" << error;
break;
}
}
if (error == 0)
{
error = mdb_txn_commit(txn);
if (error != 0)
{
WriteLog (lsWARNING, NodeObject) << "mdb_txn_commit failed, error=" << error;
}
}
else
{
mdb_txn_abort (txn);
}
}
else
{
WriteLog (lsWARNING, NodeObject) << "mdb_txn_begin failed, error=" << error;
}
}
void visitAll (VisitCallback& callback)
{
// VFALCO TODO Implement this!
bassertfalse;
}
int getWriteLoad ()
{
return m_batch.getWriteLoad ();
}
//--------------------------------------------------------------------------
void writeBatch (Batch const& batch)
{
storeBatch (batch);
}
private:
size_t const m_keyBytes;
Scheduler& m_scheduler;
BatchWriter m_batch;
EncodedBlob::Pool m_blobPool;
std::string m_basePath;
MDB_env* m_env;
MDB_dbi m_dbi;
};
//------------------------------------------------------------------------------
MdbFactory::MdbFactory ()
{
}
MdbFactory::~MdbFactory ()
{
}
MdbFactory* MdbFactory::getInstance ()
{
return new MdbFactory;
}
String MdbFactory::getName () const
{
return "mdb";
}
Backend* MdbFactory::createInstance (
size_t keyBytes,
Parameters const& keyValues,
Scheduler& scheduler)
{
return new MdbFactory::BackendImp (keyBytes, keyValues, scheduler);
}
}
#endif
|
#include<bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define pb push_back
#define mp make_pair
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--) {
string s;
ll n;
cin>>s>>n;
int m=s.size();
ll a=0,b=0,ans=0;
int i,temp1=0;
for(i=0;i<n;i++) {
int temp=0;
for(int j=0;j<m;j++) {
if(s[j]=='a') {
a++;
}
else {
b++;
}
if(a>b) {
ans++;
temp++;
}
}
if(temp1==temp)
break;
temp1=temp;
}
if(i==n)
cout<<ans<<"\n";
else {
ans=ans+(n-i-1)*temp1;
cout<<ans<<"\n";
}
}
return 0;
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
**
** Copyright (C) 1995-2011 Opera Software ASA. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
*/
#include <core/pch.h>
#ifdef DOM_EXTENSIONS_TAB_API_SUPPORT
#include "modules/dom/src/extensions/domtabsapihelper.h"
#include "modules/dom/src/extensions/dombrowsertab.h"
#include "modules/dom/src/extensions/dombrowsertabgroup.h"
#include "modules/dom/src/extensions/dombrowserwindow.h"
#include "modules/dochand/winman.h"
#include "modules/windowcommander/src/WindowCommander.h"
#include "modules/util/str.h"
#include "modules/doc/frm_doc.h"
#include "modules/windowcommander/OpWindowCommanderManager.h"
#include "modules/ecmascript_utils/esasyncif.h"
#include "modules/ecmascript_utils/essched.h"
#include "modules/prefs/prefsmanager/collections/pc_doc.h"
static int convert_value_impl(DOM_Object* this_object, ES_Value* argv, int argc, ES_Value* return_value, DOM_Runtime* origining_runtime)
{
OP_ASSERT(argc > 0);
*return_value = argv[0];
return ES_VALUE;
}
static OP_STATUS DOM_ConvertValue(ES_Value* value, const char* convert_to, ES_AsyncCallback* callback, DOM_Runtime* origining_runtime)
{
DOM_Function* func = OP_NEW(DOM_Function, (convert_value_impl));
RETURN_OOM_IF_NULL(func);
RETURN_IF_ERROR(func->SetFunctionRuntime(origining_runtime, UNI_L("c"), "Function", convert_to));
ES_AsyncInterface* async_if = origining_runtime->GetEnvironment()->GetAsyncInterface();
OP_ASSERT(async_if);
ES_ThreadScheduler *scheduler = origining_runtime->GetESScheduler();
ES_Thread* thread = scheduler->GetCurrentThread();
return async_if->CallFunction(func->GetNativeObject(), func->GetNativeObject(), 1, value, callback, thread);
};
DOM_TabsApiHelperBase::DOM_TabsApiHelperBase()
: m_status(OpStatus::OK)
, m_is_finished(FALSE)
{
}
void
DOM_TabsApiHelperBase::Finish(OP_STATUS status)
{
m_is_finished = TRUE;
m_status = status;
DOM_RestartObject::Resume();
}
/* static */ int
DOM_TabsApiHelperBase::CallTabAPIException(DOM_Object* this_object, ES_Value* return_value, OP_STATUS error)
{
if (OpStatus::IsMemoryError(error))
return ES_NO_MEMORY;
if (error == DOM_TabsApiHelper::Error::ERR_NOT_ENOUGH_INITIAL_CONTENT)
return DOM_CALL_DOMEXCEPTION(VALIDATION_ERR);
if (error == OpStatus::ERR_NOT_SUPPORTED)
return DOM_CALL_DOMEXCEPTION(NOT_SUPPORTED_ERR);
if (error == DOM_TabsApiHelper::Error::ERR_WRONG_MOVE_ARGUMENT)
return DOM_CALL_INTERNALEXCEPTION(WRONG_ARGUMENTS_ERR);
return DOM_CALL_DOMEXCEPTION(INVALID_STATE_ERR);
}
/* static */ void
DOM_TabsApiHelperBase::ExtractTabProps(TabProps& props, ES_Object* es_props, DOM_Runtime* runtime, BOOL clone_strings)
{
props.title = NULL;
props.url = NULL;
props.is_locked = MAYBE;
props.is_private = MAYBE;
props.is_selected = MAYBE;
if (!es_props)
return;
ES_Value value;
OP_BOOLEAN result;
result = runtime->GetName(es_props, UNI_L("url"), &value);
if (result == OpBoolean::IS_TRUE && value.type == VALUE_STRING)
if (clone_strings)
props.url = UniSetNewStr(value.value.string); // Ignore OOM here - treat it as we had empty strings.
else
props.url = value.value.string;
result = runtime->GetName(es_props, UNI_L("title"), &value);
if (result == OpBoolean::IS_TRUE && value.type == VALUE_STRING)
if (clone_strings)
props.title = UniSetNewStr(value.value.string); // Ignore OOM here - treat it as we had empty strings.
else
props.title = value.value.string;
result = runtime->GetName(es_props, UNI_L("focused"), &value);
if (result == OpBoolean::IS_TRUE && value.type == VALUE_BOOLEAN)
props.is_selected = value.value.boolean ? YES : NO;
result = runtime->GetName(es_props, UNI_L("private"), &value);
if (result == OpBoolean::IS_TRUE && value.type == VALUE_BOOLEAN)
props.is_private = value.value.boolean ? YES : NO;
result = runtime->GetName(es_props, UNI_L("locked"), &value);
if (result == OpBoolean::IS_TRUE && value.type == VALUE_BOOLEAN)
props.is_locked = value.value.boolean ? YES : NO;
}
void
DOM_TabsApiHelperBase::ExtractWindowProps(WindowProps& props, ES_Object* es_props, DOM_Runtime* runtime)
{
props.is_private = MAYBE;
props.is_focused = MAYBE;
if (!es_props)
return;
ES_Value value;
OP_BOOLEAN result;
result = runtime->GetName(es_props, UNI_L("focused"), &value);
if (result == OpBoolean::IS_TRUE)
props.is_focused = value.value.boolean ? YES : NO;
result = runtime->GetName(es_props, UNI_L("private"), &value);
if (result == OpBoolean::IS_TRUE)
props.is_private = value.value.boolean ? YES : NO;
props.top = TruncateDoubleToInt(DOMGetDictionaryNumber(es_props, UNI_L("top"), OpTabAPIListener::UNSPECIFIED_WINDOW_DIMENSION));
props.left = TruncateDoubleToInt(DOMGetDictionaryNumber(es_props, UNI_L("left"), OpTabAPIListener::UNSPECIFIED_WINDOW_DIMENSION));
props.height = TruncateDoubleToInt(DOMGetDictionaryNumber(es_props, UNI_L("height"), OpTabAPIListener::UNSPECIFIED_WINDOW_DIMENSION));
props.width = TruncateDoubleToInt(DOMGetDictionaryNumber(es_props, UNI_L("width"), OpTabAPIListener::UNSPECIFIED_WINDOW_DIMENSION));
}
/*static */ void
DOM_TabsApiHelperBase::ExtractTabGroupProps(TabGroupProps& props, ES_Object* es_props, DOM_Runtime* runtime)
{
props.is_collapsed = MAYBE;
if (!es_props)
return;
ES_Value value;
OP_BOOLEAN result;
result = runtime->GetName(es_props, UNI_L("collapsed"), &value);
if (result == OpBoolean::IS_TRUE)
props.is_collapsed = value.value.boolean ? YES : NO;
}
OP_STATUS
DOM_TabsApiHelperBase::OpenNewTab(OpTabAPIListener::WindowTabInsertTarget& insert_target, ES_Object* es_props, BOOL3 focus_override, OpWindowCommander** out_wc)
{
FramesDocument* frm_doc = GetRuntime()->GetFramesDocument();
if (!frm_doc)
return OpStatus::ERR; // No doc == no go.
OpWindowCommander* source = frm_doc->GetWindow()->GetWindowCommander();
OpGadget* gadget = source->GetGadget();
TabProps props;
ExtractTabProps(props, es_props, GetRuntime(), FALSE);
OpUiWindowListener::CreateUiWindowArgs args;
args.locked = props.is_locked == YES;
args.opener = source;
args.type = OpUiWindowListener::WINDOWTYPE_REGULAR;
if (focus_override == MAYBE)
args.regular.focus_document = props.is_selected == YES;
else
args.regular.focus_document = focus_override == YES;
args.regular.open_background = !args.regular.focus_document;
args.regular.height = 0;
args.regular.width = 0;
args.regular.opened_by_script = TRUE;
args.regular.scrollbars = !!g_pcdoc->GetIntegerPref(PrefsCollectionDoc::ShowScrollbars);
args.regular.toolbars = TRUE;
args.regular.transparent = FALSE;
args.regular.user_initiated = FALSE;
BOOL is_gadget_url = FALSE;
OpString url;
if (props.url)
{
OP_ASSERT(gadget);
URL resolved = gadget->ResolveExtensionURL(props.url);
RETURN_IF_ERROR(url.Set(resolved.GetAttribute(URL::KUniName_With_Fragment).CStr()));
is_gadget_url = resolved.Type() == URL_WIDGET;
}
OpWindowCommander* wc;
RETURN_IF_ERROR(g_windowCommanderManager->GetWindowCommander(&wc));
if (is_gadget_url)
static_cast<WindowCommander*>(wc)->SetGadget(gadget);
args.insert_target = &insert_target;
OP_STATUS status = g_windowCommanderManager->GetUiWindowListener()->CreateUiWindow(wc, args);
if (OpStatus::IsError(status))
{
g_windowCommanderManager->ReleaseWindowCommander(wc);
return status;
}
if (props.is_private == YES)
wc->SetPrivacyMode(TRUE);
else if (props.is_private == NO)
wc->SetPrivacyMode(FALSE);
wc->OpenURL(url.CStr(), FALSE);
if (out_wc)
*out_wc = wc;
return OpStatus::OK;
}
////////////////////////////////////////////////////////////////////
DOM_TabsApiHelper::DOM_TabsApiHelper()
{
}
/* static */ OP_STATUS
DOM_TabsApiHelper::Make(DOM_TabsApiHelper*& new_obj, DOM_Runtime* runtime)
{
RETURN_IF_ERROR(DOMSetObjectRuntime(new_obj = OP_NEW(DOM_TabsApiHelper, ()), runtime));
return new_obj->KeepAlive();
}
void
DOM_TabsApiHelper::QueryAllWindows()
{
g_windowCommanderManager->GetTabAPIListener()->OnQueryAllBrowserWindows(this);
}
void
DOM_TabsApiHelper::QueryAllTabs()
{
g_windowCommanderManager->GetTabAPIListener()->OnQueryAllTabs(this);
}
void
DOM_TabsApiHelper::QueryTabGroup(OpTabAPIListener::TabAPIItemId tab_group_id, BOOL include_content)
{
g_windowCommanderManager->GetTabAPIListener()->OnQueryTabGroup(tab_group_id, include_content, this);
}
void
DOM_TabsApiHelper::QueryWindow(OpTabAPIListener::TabAPIItemId window_id, BOOL include_content)
{
g_windowCommanderManager->GetTabAPIListener()->OnQueryBrowserWindow(window_id, include_content, this);
}
void
DOM_TabsApiHelper::QueryTab(OpWindowCommander* target_widow)
{
g_windowCommanderManager->GetTabAPIListener()->OnQueryTab(target_widow, this);
}
void
DOM_TabsApiHelper::QueryTab(OpTabAPIListener::TabAPIItemId target_tab)
{
g_windowCommanderManager->GetTabAPIListener()->OnQueryTab(target_tab, this);
}
void
DOM_TabsApiHelper::OnNotification(OP_STATUS status, QueryResult::ResultType type)
{
Finish(status);
}
void
DOM_TabsApiHelper::RequestTabClose(OpTabAPIListener::TabAPIItemId tab_id)
{
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabClose(tab_id, this);
}
void
DOM_TabsApiHelper::RequestWindowClose(OpTabAPIListener::TabAPIItemId window_id)
{
g_windowCommanderManager->GetTabAPIListener()->OnRequestBrowserWindowClose(window_id, this);
}
void
DOM_TabsApiHelper::RequestWindowMove(OpTabAPIListener::TabAPIItemId window_id, const OpRect& rect)
{
OpTabAPIListener::ExtensionWindowMoveResize info;
info.window_height = rect.height;
info.window_width = rect.width;
info.window_top = rect.Top();
info.window_left = rect.Left();
info.maximize = !(info.window_height >= 0 || info.window_width > 0 || info.window_top > 0 || info.window_left > 0);
g_windowCommanderManager->GetTabAPIListener()->OnRequestBrowserWindowMoveResize(window_id, info, this);
}
void
DOM_TabsApiHelper::QueryAllTabGroups()
{
g_windowCommanderManager->GetTabAPIListener()->OnQueryAllTabGroups(this);
}
void
DOM_TabsApiHelper::RequestTabGroupUpdate(OpTabAPIListener::TabAPIItemId target_tab_group_id, ES_Object* es_props, DOM_Runtime* origining_runtime)
{
OP_ASSERT(origining_runtime);
TabGroupProps tab_group_props;
ExtractTabGroupProps(tab_group_props, es_props, origining_runtime);
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabGroupUpdate(target_tab_group_id, tab_group_props.is_collapsed, this);
}
void
DOM_TabsApiHelper::RequestTabUpdate(OpTabAPIListener::TabAPIItemId target_tab_id, ES_Object* es_props, DOM_Runtime* origining_runtime)
{
OP_ASSERT(origining_runtime);
TabProps tab_props;
ExtractTabProps(tab_props, es_props, origining_runtime, FALSE);
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabUpdate(target_tab_id, tab_props.is_selected == YES, tab_props.is_locked, tab_props.url, tab_props.title, this);
}
void
DOM_TabsApiHelper::RequestTabGroupClose(OpTabAPIListener::TabAPIItemId target_tab_group_id)
{
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabGroupClose(target_tab_group_id, this);
}
void
DOM_TabsApiHelper::RequestTabFocus(OpTabAPIListener::TabAPIItemId target_tab_id)
{
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabUpdate(target_tab_id, TRUE, -1, NULL, NULL, this);
}
///////////////////////////////////////////////////////////////////////////
/* static */ OP_STATUS
DOM_TabsApiFocusHelper::Make(DOM_TabsApiFocusHelper*& new_obj, DOM_Runtime* runtime)
{
RETURN_IF_ERROR(DOMSetObjectRuntime(new_obj = OP_NEW(DOM_TabsApiFocusHelper, ()), runtime));
return new_obj->KeepAlive();
}
void
DOM_TabsApiFocusHelper::RequestTabGroupFocus(OpTabAPIListener::TabAPIItemId target_tab_group_id)
{
g_windowCommanderManager->GetTabAPIListener()->OnQueryTabGroup(target_tab_group_id, FALSE, this);
}
void
DOM_TabsApiFocusHelper::RequestWindowFocus(OpTabAPIListener::TabAPIItemId target_window_id)
{
g_windowCommanderManager->GetTabAPIListener()->OnQueryBrowserWindow(target_window_id, FALSE, this);
}
/* virtual */ void
DOM_TabsApiFocusHelper::OnNotification(OP_STATUS status, QueryResult::ResultType type)
{
if (OpStatus::IsSuccess(status))
{
switch (type)
{
case QueryResult::RESULT_QUERY_WINDOW:
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabUpdate(GetResult().value.query_window.selected_tab_id, TRUE, -1, NULL, NULL, this);
return;
case QueryResult::RESULT_QUERY_TAB_GROUP:
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabUpdate(GetResult().value.query_tab_group.selected_tab_id, TRUE, -1, NULL, NULL, this);
return;
default:
OP_ASSERT(!"Unexpected notification!"); // Intentional fall through
case QueryResult::RESULT_REQUEST_TAB_UPDATE:
break; // go to Finish(status).
}
}
Finish(status);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
DOM_TabsApiInsertHelper::DOM_TabsApiInsertHelper()
: m_src_group_id(0)
, m_src_tab_id(0)
{
op_memset(&m_insert_target, 0 ,sizeof(m_insert_target));
}
/* static */ OP_STATUS
DOM_TabsApiInsertHelper::Make(DOM_TabsApiInsertHelper*& new_obj, DOM_Runtime* runtime)
{
RETURN_IF_ERROR(DOMSetObjectRuntime(new_obj = OP_NEW(DOM_TabsApiInsertHelper, ()), runtime));
return new_obj->KeepAlive();
}
void DOM_TabsApiInsertHelper::RequestInsert(ES_Object* insert_what, ES_Object* into_what, ES_Object* before_what /*optional*/)
{
OP_STATUS error;
if (OpStatus::IsError(error = FindInsertDestination(into_what))
|| OpStatus::IsError(error = CheckSrc(insert_what))
|| OpStatus::IsError(error = CheckBeforeWhat(before_what)))
Finish(error);
else
PerformMove();
}
OP_STATUS DOM_TabsApiInsertHelper::CheckSrc(ES_Object* insert_what)
{
OP_ASSERT(insert_what);
DOM_HOSTOBJECT_SAFE(src_tab_group, insert_what, DOM_TYPE_BROWSER_TAB_GROUP, DOM_BrowserTabGroup);
if (src_tab_group)
m_src_group_id = src_tab_group->GetTabGroupId();
else
{
DOM_HOSTOBJECT_SAFE(src_tab, insert_what, DOM_TYPE_BROWSER_TAB, DOM_BrowserTab);
if (src_tab)
m_src_tab_id = src_tab->GetTabId();
else
return Error::ERR_WRONG_MOVE_ARGUMENT;
}
return OpStatus::OK;
}
OP_STATUS
DOM_TabsApiInsertHelper::FindInsertDestination(ES_Object* into_what)
{
OP_ASSERT(into_what);
DOM_HOSTOBJECT_SAFE(dst_window, into_what, DOM_TYPE_BROWSER_WINDOW, DOM_BrowserWindow);
if (dst_window)
{
m_insert_target.type = OpTabAPIListener::WindowTabInsertTarget::EXISTING_BROWSER_WINDOW;
m_insert_target.dst_window_id = dst_window->GetWindowId();
}
else
{
DOM_HOSTOBJECT_SAFE(dst_tab_group, into_what, DOM_TYPE_BROWSER_TAB_GROUP, DOM_BrowserTabGroup);
if (dst_tab_group)
{
m_insert_target.type = OpTabAPIListener::WindowTabInsertTarget::EXISTING_TAB_GROUP;
m_insert_target.dst_group_id = dst_tab_group->GetTabGroupId();
}
else
return Error::ERR_WRONG_MOVE_ARGUMENT;
}
return OpStatus::OK;
}
OP_STATUS
DOM_TabsApiInsertHelper::CheckBeforeWhat(ES_Object* before_what)
{
if(before_what)
{
DOM_HOSTOBJECT_SAFE(tab_group, before_what, DOM_TYPE_BROWSER_TAB_GROUP, DOM_BrowserTabGroup);
if (tab_group)
{
m_insert_target.before_item_id = tab_group->GetTabGroupId();
return OpStatus::OK;
}
DOM_HOSTOBJECT_SAFE(tab, before_what, DOM_TYPE_BROWSER_TAB, DOM_BrowserTab);
if (tab)
{
m_insert_target.before_item_id = tab->GetTabId();
return OpStatus::OK;
}
return Error::ERR_WRONG_MOVE_ARGUMENT;
}
return OpStatus::OK;
}
/* virtual */ void
DOM_TabsApiInsertHelper::OnNotification(OP_STATUS status, QueryResult::ResultType type)
{
switch (type)
{
case QueryResult::RESULT_REQUEST_TAB_GROUP_MOVE:
case QueryResult::RESULT_REQUEST_TAB_MOVE:
Finish(status);
return;
default:
OP_ASSERT(FALSE);
Finish(OpStatus::ERR);
return;
}
}
void
DOM_TabsApiInsertHelper::PerformMove()
{
OP_ASSERT(!m_src_group_id || !m_src_tab_id);
OP_ASSERT(m_src_group_id || m_src_tab_id);
if (m_src_group_id)
{
if (m_insert_target.type != OpTabAPIListener::WindowTabInsertTarget::EXISTING_BROWSER_WINDOW)
{
Finish(Error::ERR_WRONG_MOVE_STATE);
return;
}
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabGroupMove(m_src_group_id, m_insert_target, this);
}
else
{
OP_ASSERT(m_insert_target.type == OpTabAPIListener::WindowTabInsertTarget::EXISTING_BROWSER_WINDOW
|| m_insert_target.type == OpTabAPIListener::WindowTabInsertTarget::EXISTING_TAB_GROUP);
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabMove(m_src_tab_id, m_insert_target, this);
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
DOM_TabsApiTabCreateHelper::DOM_TabsApiTabCreateHelper()
: m_properties(NULL)
{
op_memset(&m_insert_target, 0 ,sizeof(m_insert_target));
}
/* static */ OP_STATUS
DOM_TabsApiTabCreateHelper::Make(DOM_TabsApiTabCreateHelper*& new_obj, DOM_Runtime* runtime)
{
RETURN_IF_ERROR(DOMSetObjectRuntime(new_obj = OP_NEW(DOM_TabsApiTabCreateHelper, ()), runtime));
return new_obj->KeepAlive();
}
void
DOM_TabsApiTabCreateHelper::RequestCreateTab(ES_Object* tab_props, OpTabAPIListener::TabAPIItemId parent_win_id, OpTabAPIListener::TabAPIItemId parent_group_id, ES_Object* before_what)
{
m_properties = tab_props;
FindInsertDestination(parent_win_id, parent_group_id);
OP_STATUS error;
if (OpStatus::IsError(error = CheckBeforeWhat(before_what)))
Finish(error);
else
PerformCreate();
}
/* virtual */ void
DOM_TabsApiTabCreateHelper::GCTrace()
{
GCMark(m_properties);
DOM_RestartObject::GCTrace();
}
/* virtual */ void
DOM_TabsApiTabCreateHelper::OnNotification(OP_STATUS status, QueryResult::ResultType type)
{
if (OpStatus::IsSuccess(status))
{
switch (type)
{
case QueryResult::RESULT_QUERY_TAB:
unsigned int window_id = GetResult().value.query_tab.window_id;
OpTabAPIListener::TabAPIItemId id = GetResult().value.query_tab.id;
m_query_result.Clean();
m_query_result.type = QueryResult::RESULT_REQUEST_TAB_CREATE;
m_query_result.value.created_tab_info.window_id = window_id;
m_query_result.value.created_tab_info.tab_id = id;
break; // GOTO Finish(status);
}
}
Finish(status);
}
OP_STATUS
DOM_TabsApiTabCreateHelper::CheckBeforeWhat(ES_Object* before_what)
{
if(before_what)
{
DOM_HOSTOBJECT_SAFE(tab_group, before_what, DOM_TYPE_BROWSER_TAB_GROUP, DOM_BrowserTabGroup);
if (tab_group)
{
m_insert_target.before_item_id = tab_group->GetTabGroupId();
return OpStatus::OK;
}
DOM_HOSTOBJECT_SAFE(tab, before_what, DOM_TYPE_BROWSER_TAB, DOM_BrowserTab);
if (tab)
{
m_insert_target.before_item_id = tab->GetTabId();
return OpStatus::OK;
}
return Error::ERR_WRONG_MOVE_ARGUMENT;
}
return OpStatus::OK;
}
void
DOM_TabsApiTabCreateHelper::FindInsertDestination(OpTabAPIListener::TabAPIItemId parent_win_id, OpTabAPIListener::TabAPIItemId parent_group_id)
{
OP_ASSERT(!parent_win_id || !parent_group_id);
if (parent_win_id)
{
m_insert_target.type = OpTabAPIListener::WindowTabInsertTarget::EXISTING_BROWSER_WINDOW;
m_insert_target.dst_window_id = parent_win_id;
}
else if (parent_group_id)
{
m_insert_target.type = OpTabAPIListener::WindowTabInsertTarget::EXISTING_TAB_GROUP;
m_insert_target.dst_group_id = parent_group_id;
}
else
m_insert_target.type = OpTabAPIListener::WindowTabInsertTarget::CURRENT_CONTAINER;
}
void
DOM_TabsApiTabCreateHelper::PerformCreate()
{
m_query_result.Clean();
OpWindowCommander* wc;
OP_STATUS error = OpenNewTab(m_insert_target, m_properties, MAYBE, &wc);
if (OpStatus::IsError(error))
{
Finish(error);
return;
}
g_windowCommanderManager->GetTabAPIListener()->OnQueryTab(wc, this);
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////
DOM_TabsApiContainerCreateHelper::DOM_TabsApiContainerCreateHelper()
: m_initial_content_index(0)
, m_initial_content(NULL)
, m_querying_before(FALSE)
, m_focus_container(NO)
{
m_create_next_timer.SetTimerListener(this);
op_memset(&m_insert_target, 0 ,sizeof(m_insert_target));
}
/* static */ OP_STATUS
DOM_TabsApiContainerCreateHelper::Make(DOM_TabsApiContainerCreateHelper*& new_obj, DOM_Runtime* runtime)
{
RETURN_IF_ERROR(DOMSetObjectRuntime(new_obj = OP_NEW(DOM_TabsApiContainerCreateHelper, ()), runtime));
return new_obj->KeepAlive();
}
/* virtual */ void
DOM_TabsApiContainerCreateHelper::GCTrace()
{
GCMark(m_initial_content);
DOM_RestartObject::GCTrace();
}
void
DOM_TabsApiContainerCreateHelper::RequestCreateTabGroup(ES_Object* initial_content, ES_Object* container_props, OpTabAPIListener::TabAPIItemId parent_win_id, ES_Object* before_what)
{
TabGroupProps props;
ExtractTabGroupProps(props, container_props, GetRuntime());
m_insert_target.tab_group_create.collapsed = props.is_collapsed == YES;
m_initial_content = initial_content;
ES_Value len_val;
OP_BOOLEAN result = GetRuntime()->GetName(initial_content, UNI_L("length"), &len_val);
if (result != OpBoolean::IS_TRUE || len_val.type != VALUE_NUMBER || len_val.value.number < 2.0)
{
Finish(Error::ERR_NOT_ENOUGH_INITIAL_CONTENT);
return;
}
FindInsertDestination(parent_win_id);
OP_STATUS error;
if (OpStatus::IsError(error = CheckBeforeWhat(before_what)))
Finish(error);
else
PerformCreateStep();
}
void
DOM_TabsApiContainerCreateHelper::RequestCreateWindow(ES_Object* initial_content, ES_Object* container_props)
{
WindowProps props;
ExtractWindowProps(props, container_props, GetRuntime());
m_initial_content = initial_content;
m_insert_target.window_create.height = props.height;
m_insert_target.window_create.width = props.width;
m_insert_target.window_create.left = props.left;
m_insert_target.window_create.top = props.top;
m_insert_target.window_create.is_private = props.is_private == YES;
m_focus_container = props.is_focused == YES ? YES : NO;
m_insert_target.type = OpTabAPIListener::WindowTabInsertTarget::NEW_BROWSER_WINDOW;
PerformCreateStep();
}
void DOM_TabsApiContainerCreateHelper::SetInsertTypeToExisting()
{
if (m_insert_target.type == OpTabAPIListener::WindowTabInsertTarget::NEW_BROWSER_WINDOW)
m_insert_target.type = OpTabAPIListener::WindowTabInsertTarget::EXISTING_BROWSER_WINDOW;
if (m_insert_target.type == OpTabAPIListener::WindowTabInsertTarget::NEW_TAB_GROUP)
m_insert_target.type = OpTabAPIListener::WindowTabInsertTarget::EXISTING_TAB_GROUP;
m_insert_target.before_item_id = 0;
}
/* virtual */void
DOM_TabsApiContainerCreateHelper::OnNotification(OP_STATUS status, QueryResult::ResultType type)
{
if (OpStatus::IsSuccess(status))
{
switch (type)
{
case QueryResult::RESULT_REQUEST_TAB_MOVE:
case QueryResult::RESULT_REQUEST_TAB_GROUP_MOVE:
m_insert_target.dst_group_id = m_query_result.value.moved_to_info.tab_group_id;
m_insert_target.dst_window_id = m_query_result.value.moved_to_info.browser_window_id;
break;
case QueryResult::RESULT_QUERY_TAB:
m_insert_target.dst_group_id = m_query_result.value.query_tab.tab_group_id;
m_insert_target.dst_window_id = m_query_result.value.query_tab.browser_window_id;
break;
default:
OP_ASSERT(FALSE);
}
SetInsertTypeToExisting();
m_create_next_timer.Start(0);
}
else
Finish(status);
}
/* virtual */ void
DOM_TabsApiContainerCreateHelper::OnTimeOut(OpTimer* timer)
{
PerformCreateStep();
}
OP_STATUS
DOM_TabsApiContainerCreateHelper::CheckBeforeWhat(ES_Object* before_what)
{
if(before_what)
{
DOM_HOSTOBJECT_SAFE(tab_group, before_what, DOM_TYPE_BROWSER_TAB_GROUP, DOM_BrowserTabGroup);
if (tab_group)
{
m_insert_target.before_item_id = tab_group->GetTabGroupId();
return OpStatus::OK;
}
DOM_HOSTOBJECT_SAFE(tab, before_what, DOM_TYPE_BROWSER_TAB, DOM_BrowserTab);
if (tab)
{
m_insert_target.before_item_id = tab->GetTabId();
return OpStatus::OK;
}
return Error::ERR_WRONG_MOVE_ARGUMENT;
}
return OpStatus::OK;
}
void
DOM_TabsApiContainerCreateHelper::FindInsertDestination(OpTabAPIListener::TabAPIItemId parent_win_id)
{
m_insert_target.type = OpTabAPIListener::WindowTabInsertTarget::NEW_TAB_GROUP;
m_insert_target.dst_window_id = parent_win_id;
}
void DOM_TabsApiContainerCreateHelper::PerformCreateStep()
{
ES_Value initial_content_item;
OP_BOOLEAN status;
if (m_initial_content)
{
status = GetRuntime()->GetIndex(m_initial_content, m_initial_content_index, &initial_content_item);
if (status != OpBoolean::IS_TRUE || initial_content_item.type != VALUE_OBJECT)
{
if (!OpStatus::IsError(status))
{
if (m_initial_content_index == 0) // Empty array - treat as null.
{
m_initial_content = NULL;
PerformCreateStep();
return;
}
status = OpStatus::OK;
}
CreatingContainerFinished();
Finish(status);
return;
}
++m_initial_content_index;
DOM_HOSTOBJECT_SAFE(tab, initial_content_item.value.object, DOM_TYPE_BROWSER_TAB, DOM_BrowserTab);
if (tab)
{
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabMove(tab->GetTabId(), m_insert_target, this);
return;
}
DOM_HOSTOBJECT_SAFE(tab_group, initial_content_item.value.object, DOM_TYPE_BROWSER_TAB_GROUP, DOM_BrowserTabGroup);
if (tab_group)
{
g_windowCommanderManager->GetTabAPIListener()->OnRequestTabGroupMove(tab_group->GetTabGroupId(), m_insert_target, this);
return;
}
ConversionCallback* conversion_callback = OP_NEW(ConversionCallback, (this));
if (!conversion_callback)
{
Finish(OpStatus::ERR_NO_MEMORY);
return;
}
status = DOM_ConvertValue(&initial_content_item, "{url:S,title:S,focused:b,locked:b,private:b}", conversion_callback, GetRuntime());
if (OpStatus::IsError(status))
{
OP_DELETE(conversion_callback);
Finish(status);
return;
}
}
else
{
if (m_insert_target.type != OpTabAPIListener::WindowTabInsertTarget::NEW_BROWSER_WINDOW
&& m_insert_target.type != OpTabAPIListener::WindowTabInsertTarget::NEW_TAB_GROUP)
{
CreatingContainerFinished();
Finish(OpStatus::OK);
return;
}
else
{
OpWindowCommander* wc;
status = OpenNewTab(m_insert_target, NULL, m_focus_container ? YES : NO, &wc);
if (OpStatus::IsError(status))
Finish(status);
else
g_windowCommanderManager->GetTabAPIListener()->OnQueryTab(wc, this);
return;
}
}
}
/* virtual */ OP_STATUS
DOM_TabsApiContainerCreateHelper::ConversionCallback::HandleCallback(ES_AsyncOperation operation, ES_AsyncStatus status, const ES_Value &result)
{
OP_ASSERT(ES_ASYNC_CALL_FUNCTION == operation);
if (status != ES_ASYNC_SUCCESS)
m_helper->Finish(OpStatus::ERR);
else
{
OpWindowCommander* wc;
OP_STATUS status = m_helper->OpenNewTab(m_helper->m_insert_target, result.value.object, m_helper->m_focus_container, &wc);
if (OpStatus::IsError(status))
m_helper->Finish(status);
else
{
m_helper->m_query_result.Clean();
g_windowCommanderManager->GetTabAPIListener()->OnQueryTab(wc, m_helper);
}
}
OP_DELETE(this);
return OpStatus::OK;
}
void DOM_TabsApiContainerCreateHelper::CreatingContainerFinished()
{
m_query_result.Clean();
if (IsCreatingGroup())
{
m_query_result.type = QueryResult::RESULT_REQUEST_TAB_GROUP_CREATE;
m_query_result.value.created_tab_group_id = m_insert_target.dst_group_id;
}
else
{
m_query_result.type = QueryResult::RESULT_REQUEST_WINDOW_CREATE;
m_query_result.value.created_window_id = m_insert_target.dst_window_id;
}
}
BOOL DOM_TabsApiContainerCreateHelper::IsCreatingGroup()
{
return m_insert_target.type == OpTabAPIListener::WindowTabInsertTarget::EXISTING_TAB_GROUP || m_insert_target.type == OpTabAPIListener::WindowTabInsertTarget::NEW_TAB_GROUP;
}
#endif // DOM_EXTENSIONS_TAB_API_SUPPORT
|
#ifndef UI_ACTION_INTERVALACTIONS_MOVE_H_
#define UI_ACTION_INTERVALACTIONS_MOVE_H_
#pragma once
namespace ui
{
class UILIB_API MoveBy : public IntervalAction
{
public:
static MoveBy* Create(float duration, const CPoint& deltaPosition);
virtual MoveBy* Clone() const override;
virtual MoveBy* Reverse() const override;
virtual void StartWithTarget(Control* target) override;
virtual void Update(float time) override;
protected:
MoveBy() = default;
/** initializes the action */
bool InitWithDuration(float duration, const CPoint& deltaPosition);
protected:
CPoint positionDelta_;
CPoint startPosition_;
};
class UILIB_API MoveTo : public MoveBy
{
public:
static MoveTo* Create(float duration, const CPoint& position);
virtual MoveTo* Clone() const override;
virtual MoveTo* Reverse() const override;
virtual void StartWithTarget(Control *target) override;
protected:
MoveTo() = default;
/**
* initializes the action
* @param duration in seconds
*/
bool InitWithDuration(float duration, const CPoint& position);
protected:
CPoint endPosition_;
};
}
#endif
|
#pragma once
#include <Tanker/Trustchain/GroupId.hpp>
#include <Tanker/Trustchain/UserId.hpp>
#include <tconcurrent/future.hpp>
#include <vector>
namespace Tanker
{
class ITrustchainPuller
{
public:
virtual tc::shared_future<void> scheduleCatchUp(
std::vector<Trustchain::UserId> const& = {},
std::vector<Trustchain::GroupId> const& = {}) = 0;
};
}
|
#include <iostream>
#include <sstream>
#include <vector>
#if defined(_MSC_VER) && defined(_M_X64)
# include <boost/test/included/unit_test.hpp>
#else
# include <boost/test/unit_test.hpp>
#endif
#include "opennwa/Nwa.hpp"
#include "arbitrary.hpp"
using boost::unit_test_framework::test_suite;
using boost::unit_test_framework::test_case;
using Arbitrary::suite_of_random_tests;
typedef opennwa::NWA<opennwa::ClientInfo> Nwa;
typedef wali::ref_ptr<Nwa> NwaRefPtr;
namespace Arbitrary {
void arbitrary(NwaRefPtr & nwa, int n)
{
assert(nwa == 0);
int num_states;
arbitrary(num_states, n);
num_states = abs(num_states);
std::vector<wali::Key> state_keys(num_states);
nwa = new Nwa(wali::getKey("stuck"));
for (int i=0; i<num_states; ++i) {
std::stringstream ss;
ss << "state #" << i;
wali::Key key = wali::getKey(ss.str());
nwa->addState(key);
state_keys[i] = key;
}
int num_syms;
arbitrary(num_syms, n/2);
num_syms = abs(num_syms);
std::vector<wali::Key> sym_keys(num_syms);
for (int i=0; i<num_syms; ++i) {
std::stringstream ss;
ss << "symbol #" << i;
wali::Key key = wali::getKey(ss.str());
nwa->addSymbol(key);
sym_keys[i] = key;
}
// Internals
for (int i=0; i<num_states; ++i) {
for (int j=0; j<num_states; ++j) {
for (int k=0; k<num_syms; ++k) {
bool inc;
arbitrary(inc, 0);
if (inc) {
nwa->addInternalTrans(state_keys[i], sym_keys[k], state_keys[j]);
}
}
}
}
// Calls
for (int i=0; i<num_states; ++i) {
for (int j=0; j<num_states; ++j) {
for (int k=0; k<num_syms; ++k) {
bool inc;
arbitrary(inc, 0);
if (inc) {
nwa->addCallTrans(state_keys[i], sym_keys[k], state_keys[j]);
}
}
}
}
// Returns
for (int i=0; i<num_states; ++i) {
for (int j=0; j<num_states; ++j) {
for (int k=0; k<num_states; ++k) {
for (int l=0; l<num_syms; ++l) {
bool inc;
arbitrary(inc, 0);
if (inc) {
nwa->addReturnTrans(state_keys[i], state_keys[j], sym_keys[l], state_keys[k]);
}
}
}
}
}
}
}
/// Tests whether the argument is positive. Obviously this will fail a
/// lot of the time.
void test_positive(int i)
{
BOOST_CHECK_LT(0, i);
}
void test_nwa(NwaRefPtr p)
{
BOOST_CHECK_EQUAL(p->sizeStates(), p->num_nwa_states());
}
void test_intersection(NwaRefPtr left, NwaRefPtr right, NwaRefPtr intersection, Nwa::NestedWord const & word)
{
bool inLeft = left->isMemberNondet(word);
bool inRight = right->isMemberNondet(word);
bool inInter = intersection->isMemberNondet(word);
if (inLeft && inRight) {
BOOST_CHECK(inInter);
}
else {
BOOST_CHECK(!inInter);
}
}
template<typename Function>
test_suite* binop_test_suite_given_one_nwa(Function func, int n, int size, NwaRefPtr left)
{
NwaRefPtr right;
arbitrary(right, size);
NwaRefPtr intersection = Nwa::intersect(left, right);
return suite_of_random_tests(boost::bind(test_intersection, left, right, intersection, _1),
n, size);
}
/// This is the equivalent of "main"
test_suite* init_unit_test_suite(int, char** const)
{
return suite_of_random_tests(test_nwa, 20, 10);
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n=0;
string c;
cout<<"Enter the string : ";
cin>>c;
cout<<endl<<"The Concatenated String is : ";
for (int i=0; i<c.size(); i++){
if(c[i]>=65 && c[i]<=91){
n++;
cout<<endl;
}
cout<<c[i];
}
cout<<endl<<endl<<"The total number of words in Camel Case String are : "<<n;
return 0;
}
|
#include "PolygonizationScene.hpp"
#include "MarchingCubes.hpp"
#include "Sphere.hpp"
#include <vector>
#include <atlas/gl/GL.hpp>
#include <atlas/utils/GUI.hpp>
namespace assignment2
{
using Vector3 = atlas::math::Vector;
PolygonizationScene::PolygonizationScene()
{
mSceneMesh.addSceneSphere(new Sphere(Vector3(-3.0f, 0, 0), 2.0f));
mSceneMesh.addSceneSphere(new Sphere(2.2f));
mSceneMesh.createMesh();
}
void PolygonizationScene::renderScene()
{
atlas::utils::Gui::getInstance().newFrame();
const float grey = 161.0f / 255.0f;
glClearColor(grey, grey, grey, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
mProjection = glm::perspective(
glm::radians(mCamera.getCameraFOV()),
(float)mWidth / mHeight, 1.0f, 1000000.0f);
mUniformMatrixBuffer.bindBuffer();
mUniformMatrixBuffer.bufferSubData(0, sizeof(atlas::math::Matrix4),
&mProjection[0][0]);
mUniformMatrixBuffer.unBindBuffer();
mView = mCamera.getCameraMatrix();
mUniformMatrixBuffer.bindBuffer();
mUniformMatrixBuffer.bufferSubData(sizeof(atlas::math::Matrix4),
sizeof(atlas::math::Matrix4), &mView[0][0]);
if (mShowGrid)
{
mGrid.renderGeometry(mProjection, mView);
}
mSceneMesh.renderGeometry(mProjection, mView);
ImGui::SetNextWindowSize(ImVec2(400, 200), ImGuiSetCond_FirstUseEver);
ImGui::Begin("Polygonization HUD");
ImGui::Checkbox("Show grid", &mShowGrid);
if (ImGui::Button("Reset Camera"))
{
mCamera.resetCamera();
}
static int e = 0;
ImGui::Text("Rendering Type:");
ImGui::RadioButton("Atlas Mesh", &e, 0);
ImGui::RadioButton("Lines", &e, 1);
ImGui::RadioButton("Points", &e, 2);
mSceneMesh.setRenderType(e);
ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f /
ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
ImGui::End();
ImGui::Render();
}
}
|
#include "stdafx.h"
#include "TestScene.h"
TestScene::TestScene()
{
}
TestScene::~TestScene()
{
}
HRESULT TestScene::Init()
{
isDebug = false;
SOUND->Play("Test", 0.5f);
//test.push_back("test");
//test.push_back("test1");
//test.push_back("test2");
//test.push_back("test3");
//TEXTDATA->TextSave((char*)"save/test.txt", test);
//test = TEXTDATA->TextLoad((char*)"save/test.txt");
//INIDATA->AddData("Test", "KeyTest", "1000");
//INIDATA->AddData("Test", "KeyTest2", "3.141592f");
//INIDATA->AddData("Test2", "KeyTest3", "1234");
//INIDATA->AddData("Test3", "KeyTest4", "1000");
//INIDATA->AddData("Test", "KeyTest5", "1000");
//INIDATA->SaveData("IniSave");
width = height = 100;
return S_OK;
}
void TestScene::Release()
{
}
void TestScene::Update()
{
SOUND->Update();
if (INPUT->GetKey(VK_UP)) {
width++;
height++;
}
if (INPUT->GetKey(VK_DOWN)) {
width--;
height--;
}
//====================== Debug =====================//
if (INPUT->GetKeyDown(VK_TAB)) {
isDebug = !isDebug;
}
//==================================================//
}
void TestScene::Render()
{
//=================================================
{
//for (int i = 0; i < test.size(); i++) {
// TextOut(GetMemDC(), WINSIZEX / 2, i * 20,
// test[i].c_str(), strlen(test[i].c_str()));
//}
//sprintf_s(str, "%d",
// INIDATA->LoadDataInteger("IniSave", "Test3", "KeyTest4"));
//TextOut(GetMemDC(), WINSIZEX / 2, WINSIZEY / 2, str, strlen(str));
//float data = atof(INIDATA->LoadDataString("IniSave", "Test", "KeyTest2"));
//sprintf_s(str, "%f", data);
//TextOut(GetMemDC(), WINSIZEX / 2, WINSIZEY / 2 + 50, str, strlen(str));
IMAGE->Render("bg", GetMemDC(), 0, 0);
IMAGE->Render("restore", GetMemDC(), WINSIZEX / 4, WINSIZEY / 2);
//IMAGE->Render("restore", GetMemDC(), WINSIZEX / 4, WINSIZEY / 2, 100, 100);
//IMAGE->FindImage("restore")->SetTransColor(false, RGB(255, 0, 255));
IMAGE->FindImage("restore")->Render(GetMemDC(), WINSIZEX / 2, WINSIZEY / 2, width, height);
IMAGE->FindImage("restore")->AlphaRender(GetMemDC(),
WINSIZEX / 6 + 50, WINSIZEY / 2, width, height, 128);
IMAGE->Render("restore", GetMemDC(), WINSIZEX / 4, WINSIZEY / 4);
IMAGE->FindImage("restore")->AlphaRender2(GetMemDC(),
WINSIZEX / 6 + 50, WINSIZEY / 4, width, height, 128);
}
//================== Debug ====================
if (isDebug)
{
}
//=================================================
}
|
// Created on: 2022-06-30
// Created by: Alexander MALYSHEV
// Copyright (c) 2022-2022 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _BRepBuilderAPI_MakeShapeOnMesh_HeaderFile
#define _BRepBuilderAPI_MakeShapeOnMesh_HeaderFile
#include <BRepBuilderAPI_MakeShape.hxx>
#include <Poly_Triangulation.hxx>
//! Builds shape on per-facet basis on the input mesh. Resulting shape has shared
//! edges by construction, but no maximization (unify same domain) is applied.
//! No generation history is provided.
class BRepBuilderAPI_MakeShapeOnMesh : public BRepBuilderAPI_MakeShape
{
public:
DEFINE_STANDARD_ALLOC
//! Ctor. Sets mesh to process.
//! @param theMesh [in] - Mesh to construct shape for.
BRepBuilderAPI_MakeShapeOnMesh(const Handle(Poly_Triangulation)& theMesh)
: myMesh(theMesh)
{}
//! Builds shape on mesh.
Standard_EXPORT virtual void Build(const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
private:
Handle(Poly_Triangulation) myMesh;
};
#endif // _BRepBuilderAPI_MakeShapeOnMesh_HeaderFile
|
// sample_multithread_c_program.c
// compile with: /c
//
// Bounce - Creates a new thread each time the letter 'a' is typed.
// Each thread bounces a happy face of a different color around
// the screen. All threads are terminated when the letter 'Q' is
// entered.
//
#include <afxwin.h>
#include <iostream>
#include <string>
using namespace std;
UINT MyThreadProc( LPVOID pParam )
{
if (pParam == NULL)
return 1; // if pObject is not valid
// do something with 'pObject'
for(int i=0;i<100;i++)
{
cout<<'a';
Sleep(100);
}
return 0; // thread completed successfully
}
UINT MyThreadProc2( LPVOID pParam )
{
if (pParam == NULL)
return 1; // if pObject is not valid
// do something with 'pObject'
for(int i=0;i<100;i++)
{
cout<<'b';
Sleep(100);
}
return 0; // thread completed successfully
}
int main()
{
char *pNewObject1 ="a", *pNewObject2 ="b", *pNewObject3 ="c";
AfxBeginThread(MyThreadProc, ( LPVOID)pNewObject1);
AfxBeginThread(MyThreadProc2, pNewObject2);
//AfxBeginThread(MyThreadProc, pNewObject3);
cin>>pNewObject1;
}
|
#include <windows.h>
#include "Audio.h"
//Costruttore
Audio::Audio(void)
{
}
//Distruttore
Audio::~Audio(void)
{
}
ALuint buffer[8]; //Array di buffer
ALuint source[8]; //Array di sorgenti
void Audio::initAL() {
alutInit(0, 0); //Inizializza OpenAL
//Vengono generati i buffers, altrimenti i suoni non saranno prodotti
alGenBuffers(8, buffer);
//Ad ogni posizione dell'array di ALbyte viene assegnato il percorso dei file audio
path[0] = (ALbyte*)"suoni/applausi.wav";
path[1] = (ALbyte*)"suoni/birilli.wav";
path[2] = (ALbyte*)"suoni/bowling.wav";
path[3] = (ALbyte*)"suoni/palla.wav";
path[4] = (ALbyte*)"suoni/sottofondo.wav";
path[5] = (ALbyte*)"suoni/sottofondo2.wav";
path[6] = (ALbyte*)"suoni/sottofondo3.wav";
path[7] = (ALbyte*)"suoni/sottofondo4.wav";
//audio->playAL(numeroTraccia); riproduci traccia
//audio->stopAL(numeroTraccia); stop traccia
//audio->playAsStream(numeroTracia); riproduzione continua
for (int i = 0; i < 8; i++) {
// This is the same for alutLoadWAVMemory
alutLoadWAVFile(path[i], &format, &data, &size, &freq, &loop); //Viene caricato il file audio in base al percorso passato
alBufferData(buffer[i], format, data, size, freq); //Viene allocato il buffer
alutUnloadWAV(format, data, size, freq); //Viene scaricato il file audio
}
//Vengono generate le sorgenti
alGenSources(8, source);
for (int i = 0; i < 8; i++) {
alSourcef(source[i], AL_PITCH, 1.0f); //Altezza
alSourcef(source[i], AL_GAIN, 1.0f); //Migliora la sorgente
alSourcei(source[i], AL_BUFFER, buffer[i]); //Assegna il buffer alla sorgente
alSourcei(source[i], AL_LOOPING, AL_TRUE); //Imposta il valore di looping se Ŕ true l'audio si ripete, altrimenti si ferma
}
}
//Avvio del brano selezionato
void Audio::playAL(int musicValue) {
alSourcePlay(source[musicValue]);
alSourcei(source[musicValue], AL_LOOPING, AL_FALSE);
}
//Avvio del brano selezionato in modalitÓ ripeti
void Audio::playAsStream(int musicValue) {
alSourcePlay(source[musicValue]);
alSourcei(source[musicValue], AL_LOOPING, AL_TRUE);
}
//Stop del brano selezionato
void Audio::stopAL(int musicValue) {
alSourceStop(source[musicValue]);
}
//Pause del brano selezionato
void Audio::pauseAL(int musicValue) {
alSourcePause(source[musicValue]);
}
|
// BSD 3-Clause License
//
// Copyright (c) 2020-2021, bodand
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <catch2/catch.hpp>
// test'd
#include <info/nonnull.hpp>
using namespace info;
TEST_CASE("nonnull accepts valid pointer",
"[InfoUtils][nonnull][nullability]") {
int i = 42;
nonnull non{&i};
CHECK(non == &i);
}
TEST_CASE("nonnull accepts shared_ptr smart pointer",
"[InfoUtils][nonnull][nullability]") {
auto ip = std::make_shared<int>(42);
info::nonnull<int*> non{ip};
CHECK(non == ip.get());
}
TEST_CASE("nonnull always converts to true",
"[InfoUtils][nonnull][nullability]") {
int i = 42;
info::nonnull non{&i};
CHECK(non);
}
TEST_CASE("nonnull does not modify pointed at value",
"[InfoUtils][nonnull][nullability]") {
int i = 42;
info::nonnull non{&i};
CHECK(i == 42);
CHECK(*non == 42);
}
TEST_CASE("nonnull allows dereference-access operator",
"[InfoUtils][nonnull][nullability]") {
struct Foo {
int a;
} foo{42};
info::nonnull non{&foo};
CHECK(non->a == 42);
}
TEST_CASE("nonnull can be passed from raw-pointer") {
auto f = [](info::nonnull<int*> ptr) {
return ptr.get();
};
int i = 42;
CHECK(*f(&i) == i);
}
TEST_CASE("nonnull does not break inheritance-based polymorphism") {
struct Foo {
virtual int make() = 0;
virtual ~Foo() = default;
};
struct Bar : Foo {
private:
int
make() override {
return 1;
}
} bar;
auto f = [](info::nonnull<Foo*> ptr) {
return ptr->make();
};
CHECK(f(&bar) == 1);
}
TEST_CASE("std::hash differentiates nonnull as pointers") {
std::hash<info::nonnull<int*>> h{};
int a = 4, b = 2;
info::nonnull nona{&a}, nonb{&b};
CHECK(h(nona) != h(nonb));
}
TEST_CASE("std::hash on nonnull is deterministic") {
std::hash<info::nonnull<int*>> h{};
int a = 42;
info::nonnull ap{&a};
CHECK(h(ap) == h(ap));
}
|
//
// EPITECH PROJECT, 2018
// nanotekspice
// File description:
// simulate chipsets
//
#include "Link.hpp"
Link::Link(std::string c, std::string p, std::string c1, std::string p1)
: _comp(c), _pin(p), _comp1(c1), _pin1(p1)
{
}
Link::Link()
{
_comp = "UNDEFINED";
_pin = "UNDEFINED";
_comp1 = "UNDEFINED";
_pin1 = "UNDEFINED";
}
Link::~Link()
{
}
|
//swap would work if array wasn't const
int Solution::repeatedNumber(const vector<int> &A) {
int n = A.size();
if (n == 0 || n == 1)
return -1;
if (n == 2)
{
if (A[0] == A[1]) {
return A[1];
} else {
return -1;
}
}
int i = 0;
int slow = A[i];
int fast = A[slow];
while (slow != fast)
{
slow = A[slow];
fast = A[A[fast]];
}
slow = 0;
while (slow != fast)
{
slow = A[slow];
fast = A[fast];
}
return slow;
}
|
/*
Copyright (c) 2009-2013, Intel Corporation
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* Neither the name of Intel Corporation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// written by Roman Dementiev
/*! \file pcm-numa.cpp
\brief Example of using CPU counters: implements a performance counter monitoring utility for NUMA (remote and local memory accesses counting). Example for programming offcore response events
*/
#define HACK_TO_REMOVE_DUPLICATE_ERROR
#include <iostream>
#ifdef _MSC_VER
#pragma warning(disable : 4996) // for sprintf
#include <windows.h>
#include "../PCM_Win/windriver.h"
#else
#include <unistd.h>
#include <signal.h>
#endif
#include <math.h>
#include <iomanip>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <assert.h>
#include "cpucounters.h"
#include "utils.h"
#ifdef _MSC_VER
#include "freegetopt/getopt.h"
#endif
#include <vector>
using namespace std;
void print_usage(const char * progname)
{
std::cout << "\nUsage "<<progname<<" (delay | \"external_program\") [-C] \n\n";
std::cout << " <delay> - delay in seconds between updates. Either delay or \"external program\" parameters must be supplied\n";
std::cout << " \"external_program\" - start external program and print the performance metrics for the execution at the end\n";
std::cout << " -C - output in csv format (optional)\n";
cout << endl;
}
template <class StateType>
void print_stats(const StateType & BeforeState, const StateType & AfterState, bool csv)
{
uint64 cycles = getCycles(BeforeState, AfterState);
uint64 instr = getInstructionsRetired(BeforeState, AfterState);
if(csv)
{
cout << double(instr)/double(cycles) << ",";
cout << instr << ",";
cout << cycles << ",";
}
else
{
cout << double(instr)/double(cycles) << " ";
cout << unit_format(instr) << " ";
cout << unit_format(cycles) << " ";
}
for(int i=0;i<2;++i)
if(!csv)
cout << unit_format(getNumberOfCustomEvents(i, BeforeState, AfterState)) << " ";
else
cout << getNumberOfCustomEvents(i, BeforeState, AfterState)<<",";
cout << "\n";
}
int main(int argc, char * argv[])
{
#ifdef PCM_FORCE_SILENT
null_stream nullStream1, nullStream2;
std::cout.rdbuf(&nullStream1);
std::cerr.rdbuf(&nullStream2);
#endif
cout << endl;
cout << " Intel(r) Performance Counter Monitor: NUMA monitoring utility "<< endl;
cout << endl;
cout << " Copyright (c) 2013 Intel Corporation" << endl;
cout << endl;
#ifdef _MSC_VER
// Increase the priority a bit to improve context switching delays on Windows
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
TCHAR driverPath[1024];
GetCurrentDirectory(1024, driverPath);
wcscat(driverPath, L"\\msr.sys");
SetConsoleCtrlHandler((PHANDLER_ROUTINE)cleanup, TRUE);
#else
signal(SIGPIPE, cleanup);
signal(SIGINT, cleanup);
signal(SIGKILL, cleanup);
signal(SIGTERM, cleanup);
#endif
int delay = -1;
char * ext_program = NULL;
bool csv = false;
int my_opt = -1;
while ((my_opt = getopt(argc, argv, "e:cC")) != -1)
{
switch(my_opt)
{
case 'e':
break;
case 'C':
case 'c':
csv = true;
break;
default:
print_usage(argv[0]);
return -1;
}
}
if (optind >= argc)
{
print_usage(argv[0]);
return -1;
}
delay = atoi(argv[optind]);
if(delay == 0)
ext_program = argv[optind];
else
delay = (delay<0)?1:delay;
#ifdef _MSC_VER
// WARNING: This driver code (msr.sys) is only for testing purposes, not for production use
Driver drv;
// drv.stop(); // restart driver (usually not needed)
if (!drv.start(driverPath))
{
cout << "Cannot access CPU counters" << endl;
cout << "You must have signed msr.sys driver in your current directory and have administrator rights to run this program" << endl;
}
#endif
PCM * m = PCM::getInstance();
EventSelectRegister def_event_select_reg;
def_event_select_reg.value = 0;
def_event_select_reg.fields.usr = 1;
def_event_select_reg.fields.os = 1;
def_event_select_reg.fields.enable = 1;
PCM::ExtendedCustomCoreEventDescription conf;
conf.fixedCfg = NULL; // default
conf.nGPCounters = 4;
switch(m->getCPUModel())
{
case PCM::WESTMERE_EX:
conf.OffcoreResponseMsrValue[0] = 0x40FF; // OFFCORE_RESPONSE.ANY_REQUEST.LOCAL_DRAM: Offcore requests satisfied by the local DRAM
conf.OffcoreResponseMsrValue[1] = 0x20FF; // OFFCORE_RESPONSE.ANY_REQUEST.REMOTE_DRAM: Offcore requests satisfied by a remote DRAM
break;
default:
cout << "pcm-numa tool does not support your processor currently." << endl;
return -1;
}
EventSelectRegister regs[4];
conf.gpCounterCfg = regs;
for(int i=0;i<4;++i)
regs[i] = def_event_select_reg;
regs[0].fields.event_select = 0xB7; // OFFCORE_RESPONSE 0 event
regs[0].fields.umask = 0x01;
regs[1].fields.event_select = 0xBB; // OFFCORE_RESPONSE 1 event
regs[1].fields.umask = 0x01;
PCM::ErrorCode status = m->program(PCM::EXT_CUSTOM_CORE_EVENTS, &conf);
switch (status)
{
case PCM::Success:
break;
case PCM::MSRAccessDenied:
cout << "Access to Intel(r) Performance Counter Monitor has denied (no MSR or PCI CFG space access)." << endl;
return -1;
case PCM::PMUBusy:
cout << "Access to Intel(r) Performance Counter Monitor has denied (Performance Monitoring Unit is occupied by other application). Try to stop the application that uses PMU." << endl;
cout << "Alternatively you can try to reset PMU configuration at your own risk. Try to reset? (y/n)" << endl;
char yn;
std::cin >> yn;
if ('y' == yn)
{
m->resetPMU();
cout << "PMU configuration has been reset. Try to rerun the program again." << endl;
}
return -1;
default:
cout << "Access to Intel(r) Performance Counter Monitor has denied (Unknown error)." << endl;
return -1;
}
cout << "\nDetected "<< m->getCPUBrandString() << " \"Intel(r) microarchitecture codename "<<m->getUArchCodename()<<"\""<<endl;
uint64 BeforeTime = 0, AfterTime = 0;
SystemCounterState SysBeforeState, SysAfterState;
const uint32 ncores = m->getNumCores();
std::vector<CoreCounterState> BeforeState, AfterState;
std::vector<SocketCounterState> DummySocketStates;
cout << "Update every "<<delay<<" seconds"<< endl;
BeforeTime = m->getTickCount();
m->getAllCounterStates(SysBeforeState, DummySocketStates, BeforeState);
std::cout.precision(2);
std::cout << std::fixed;
while(1)
{
#ifdef _MSC_VER
int delay_ms = delay * 1000;
// compensate slow Windows console output
if(AfterTime) delay_ms -= (int)(m->getTickCount() - BeforeTime);
if(delay_ms < 0) delay_ms = 0;
#else
int delay_ms = delay * 1000;
#endif
if(ext_program)
MySystem(ext_program);
else
MySleepMs(delay_ms);
AfterTime = m->getTickCount();
m->getAllCounterStates(SysAfterState, DummySocketStates, AfterState);
cout << "Time elapsed: "<<dec<<fixed<<AfterTime-BeforeTime<<" ms\n";
//cout << "Called sleep function for "<<dec<<fixed<<delay_ms<<" ms\n";
if(csv)
cout << "Core,IPC,Instructions,Cycles,Local DRAM accesses,Remote DRAM accesses \n";
else
cout << "Core | IPC | Instructions | Cycles | Local DRAM accesses | Remote DRAM Accesses \n";
for(uint32 i = 0; i<ncores ; ++i)
{
if(csv)
cout <<i<<",";
else
cout <<" "<< setw(3) << i << " " << setw(2) ;
print_stats(BeforeState[i], AfterState[i], csv);
}
if(csv)
cout << "*,";
else
{
cout << "-------------------------------------------------------------------------------------------------------------------\n";
cout << " * ";
}
print_stats(SysBeforeState, SysAfterState, csv);
std::cout << std::endl;
swap(BeforeTime, AfterTime);
swap(BeforeState, AfterState);
swap(SysBeforeState, SysAfterState);
if(ext_program) break;
}
m->cleanup();
return 0;
}
|
#include <iostream>
#include <algorithm>
#include<utility>
using namespace std;
int main()
{
long long n, m, j;
pair <long long , long long> temp;
cin >> n >> m;
pair<long long, long long> days[n];
for (int i = 0; i < n; i++)
cin >> days[i].first;
for (int i = 0; i < n; i++)
cin >> days[i].second;
//find how many candies we have to give without using balloons
for (int i = 0; i < n; i++)
days[i].first = days[i].first * days[i].second;
sort(days, days + n);
// cout << "after sorting" << endl;
// for (int i = 0; i < n; i++)
// cout << days[i].first << " ";
// cout << endl;
//now keep distributing the available balloons
//always give ballon to last one(max candies) and keep rearranging
while (m > 0)
{
//check if we have completed the distribution
if (days[n - 1].first == 0)
break;
// cout << "spending ballons, curent ballons" << m << endl;
while (days[n - 1].first >= days[n - 2].first && m > 0)
{
days[n - 1].first -= days[n - 1].second;
m--;
}
for (int i = 0; i < n; i++)
cout << days[i].first << " ";
cout << endl;
// rearrange
j = n - 2;
temp = days[n - 1];
while (days[j].first > temp.first && j > -1)
{
days[j + 1] = days[j];
--j;
}
days[++j] = temp;
}
// cout << "final result" << endl;
// for (int i = 0; i < n; i++)
// cout << days[i].candies << " ";
cout << days[n - 1].first;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <sequtils.h>
#include <deque>
using namespace std;
void print(int t)
{
cout << t << " ";
}
int main(int argc, char *argv[])
{
deque<int> c1;
populate_lseq(c1, 10);
deque<int>::iterator pos1 = find(c1.begin(), c1.end(), 2);
deque<int>::iterator pos2 = find(pos1, c1.end(), 7);
print(*pos1); print(*pos2); cout << endl;
for_each(pos1, pos2, print);
cout << endl;
deque<int>::reverse_iterator rpos1(pos1);
deque<int>::reverse_iterator rpos2(pos2);
print(*rpos1); print(*rpos2); cout << endl;
for_each(rpos2, rpos1, print);
cout << endl;
return 0;
}
|
#include "H/mouse.h"
mouse KBmouse;
bool GetLeftClick(){
return KBmouse.mouseLeftClick;
}
bool GetRightClick(){
return KBmouse.mouseRightClick;
}
bool GetClick(){
return KBmouse.mouseClick;
}
bool GetMouseUp(){
return KBmouse.mouseUp;
}
bool GetMouseDown(){
return KBmouse.mouseDown;
}
bool GetMouseLeft(){
return KBmouse.mouseLeft;
}
bool GetMouseRight(){
return KBmouse.mouseRight;
}
int GetMouseX(){
return KBmouse.x;
}
int GetMouseY(){
return KBmouse.y;
}
int GetMouseVelocityX(){
return KBmouse.velox;
}
int GetMouseVelocityY(){
return KBmouse.veloy;
}
void mouse_wait()
{
unsigned int _time_out=100000;
while(_time_out--) //Data
{
if((inb(0x64) & 0b10)==0)
{
return;
}
}
return;
}
void mousewait()
{
unsigned int _time_out=100000;
while(_time_out--) //Data
{
if(inb(0x64) & 0b1)
{
return;
}
}
return;
}
void mouse_write(unsigned char a_write)
{
//Wait to be able to send a command
mouse_wait();
//Tell the mouse we are sending a command
outb(0x64, 0xD4);
//Wait for the final part
mouse_wait();
//Finally write
outb(0x60, a_write);
}
unsigned char mouse_read()
{
//Get response from mouse
mousewait();
return inb(0x60);
}
void mouseinit()
{
outb(0x64,0xA8);
mouse_wait();
outb(0x64,0x20);
unsigned char status_byte;
mousewait();
status_byte |= 0b10;
mouse_wait();
outb(0x64, 0x60);
mouse_wait();
outb(0x60, status_byte);
mouse_write(0xF6);
mouse_read();
mouse_write(0xF4);
mouse_read();
//interruptHandlerRegister(12,&mouse_handler);
}
bool lookMouseOrKeyboard(){
char bytes;
int byte[4];
switch (bytes){
case 0:
byte[0]=inb(0x64);
bytes++;
break;
case 1:
byte[1]=inb(0x64);
bytes++;
break;
case 2:
byte[2]=inb(0x64);
bytes++;
break;
case 3:
byte[3]=inb(0x64);
bytes++;
case 4:
if (inb(0x64)==0x20)return 1;
else return 0;
break;
}
return 0;
}
uint8 mouse_cycle=0;
int8 mouse_byte[3];
bool mouse_byteReady = false;
void mouse_updater(uint8_t data)
{
if (mouse_byteReady) return;
switch(mouse_cycle)
{
case 0:
if ((data & 0b00001000)==0) break;
mouse_byte[0]=data;
mouse_cycle++;
break;
case 1:
mouse_byte[1]=data;
mouse_cycle++;
break;
case 2:
mouse_byte[2]=data;
mouse_byteReady = true;
mouse_cycle=0;
break;
}
}
void MousePacket(){
if (!mouse_byteReady/*||!lookMouseOrKeyboard()*/) return;
if (mouse_byte[0] & PS2Leftbutton) {
KBmouse.mouseLeftClick = true;
KBmouse.mouseClick = true;
}else{
KBmouse.mouseLeftClick = false;
KBmouse.mouseClick = false;
}
mouse_byte[1]/=mouse_byte[1];
mouse_byte[2]/=mouse_byte[2];
if (!(mouse_byte[0] & PS2XSign)){
KBmouse.x += mouse_byte[1];
//write_serial('R');
if (mouse_byte[0] & PS2XOverflow){
KBmouse.x += 255;
}
}else{
mouse_byte[1] = 256 - mouse_byte[1];
KBmouse.x -= mouse_byte[1];
//write_serial('L');
if (mouse_byte[0] & PS2XOverflow){
KBmouse.x -= 255;
}
}
if (!(mouse_byte[0] & PS2YSign)){
KBmouse.y -= mouse_byte[2];
//write_serial('U');
if (mouse_byte[0] & PS2YOverflow){
KBmouse.y -= 255;
}
}else{
mouse_byte[2] = 256 - mouse_byte[2];
KBmouse.y += mouse_byte[2];
//write_serial('D');
if (mouse_byte[0] & PS2YOverflow){
KBmouse.y += 255;
}
}
if (KBmouse.x < 0) KBmouse.x = 0;
if (KBmouse.x > 320) KBmouse.x = 320;
KBmouse.velox = mouse_byte[1];
if (KBmouse.y < 0) KBmouse.y = 0;
if (KBmouse.y > 200) KBmouse.y = 200;
KBmouse.veloy = mouse_byte[2];
ctmouse(KBmouse.x, KBmouse.y);
mouse_byteReady = false;
}
|
#include "PipeLine.h"
#include <assert.h>
void pipeLine::init(int width, int height, GLbyte* h_buffer, unsigned char* d_buffer, GLint bufferSize)
{
pipeLine::buffer = buffer;
pipeLine::bufferSize = bufferSize;
d_init(width, height, (unsigned char*)h_buffer, d_buffer);
}
void pipeLine::handleVerteices(Vertex* vertices, int vertexCount)
{
d_handleVerteices(vertices, vertexCount);
}
void pipeLine::drawTriangles(Mesh * mesh)
{
d_drawTriangles(mesh);
}
|
#include "material.h"
#include <algorithm>
using namespace std;
namespace sbg {
Material::Material(double restitution, double density, double staticFriction, double dynamicFriction) : _density(density), _staticFriction(staticFriction), _dynamicFriction(dynamicFriction)
{
setRestitution(restitution);
}
double Material::getDensity() const
{
return _density;
}
double Material::getDynamicFriction() const
{
return _dynamicFriction;
}
double Material::getRestitution() const
{
return _restitution;
}
double Material::getStaticFriction() const
{
return _staticFriction;
}
void Material::setDensity(double density)
{
_density = density;
}
void Material::setDynamicFriction(double dynamicFriction)
{
_dynamicFriction = dynamicFriction;
}
void Material::setRestitution(double restitution)
{
_restitution = min(restitution, 1.0);
}
void Material::setStaticFriction(double staticFriction)
{
_staticFriction = staticFriction;
}
}
|
#pragma once
#include <cstdlib>
#include <array>
namespace Department {
enum Mask : unsigned int {
INTERNAL_SECURITY = 1,
AGRICULTURE = 2,
FACILITIES = 4,
MECHANICULTURE = 8,
RESEARCH = 16,
ALL = (uint)(-1)
};
using List_t = std::array<Mask,5>;
const List_t List = {{
INTERNAL_SECURITY,
AGRICULTURE,
FACILITIES,
MECHANICULTURE,
RESEARCH,
}};
inline Mask random_dept() {
return List[rand() % List.size()];
}
inline const char* mask_to_dcode(Mask m) {
switch (m) {
case INTERNAL_SECURITY:
return "IS";
case AGRICULTURE:
return "AG";
case FACILITIES:
return "FC";
case MECHANICULTURE:
return "MC";
case RESEARCH:
return "RS";
default:
return "??";
}
}
inline const char* mask_to_local6(Mask m) {
switch (m) {
case INTERNAL_SECURITY:
return "INTSEC";
case AGRICULTURE:
return "AGRICL";
case FACILITIES:
return "FACILT";
case MECHANICULTURE:
return "MECHAN";
case RESEARCH:
return "RESRCH";
default:
return "??????";
}
}
inline const char* mask_to_local(Mask m) {
switch (m) {
case INTERNAL_SECURITY:
return "INTERNAL SECURITY";
case AGRICULTURE:
return "AGRICULTURE";
case FACILITIES:
return "FACILITIES";
case MECHANICULTURE:
return "MECHANICULTURE";
case RESEARCH:
return "RESEARCH";
default:
return "??";
}
}
}
|
//
// Created by 송지원 on 2020/05/23.
//
#include <iostream>
using namespace std;
int main() {
int input;
int ans = 0;
scanf("%d", &input);
while (input != 0) {
ans += (input%2);
input /= 2;
}
printf("%d", ans);
}
|
#pragma once //______________________________________ CalculadoraIMC.h
#include "Resource.h"
class CalculadoraIMC : public Win::Dialog
{
public:
CalculadoraIMC()
{
}
~CalculadoraIMC()
{
}
protected:
//______ Wintempla GUI manager section begin: DO NOT EDIT AFTER THIS LINE
Win::LevelState lsIMC;
Win::Label lb1;
Win::Label lb2;
Win::Textbox tbxPeso;
Win::Textbox tbxAltura;
Win::Label lb3;
Win::Label lb4;
Win::Button gbox1;
Win::Button radioHombre;
Win::Button radioMujer;
Win::Button btCalcular;
protected:
Win::Gdi::Font fontArial014A;
void GetDialogTemplate(DLGTEMPLATE& dlgTemplate)
{
dlgTemplate.cx = Sys::Convert::PixelToDlgUnitX(516);
dlgTemplate.cy = Sys::Convert::PixelToDlgUnitY(347);
dlgTemplate.style = WS_CAPTION | WS_POPUP | WS_SYSMENU | WS_VISIBLE | DS_CENTER | DS_MODALFRAME;
}
//_________________________________________________
void InitializeGui()
{
this->Text = L"CalculadoraIMC";
lsIMC.Create(WS_EX_CLIENTEDGE, NULL, WS_CHILD | WS_VISIBLE, 224, 9, 193, 331, hWnd, 1000);
lb1.Create(NULL, L"Peso", WS_CHILD | WS_VISIBLE | SS_LEFT | SS_WINNORMAL, 6, 14, 65, 25, hWnd, 1001);
lb2.Create(NULL, L"Altura", WS_CHILD | WS_VISIBLE | SS_LEFT | SS_WINNORMAL, 6, 52, 65, 25, hWnd, 1002);
tbxPeso.Create(WS_EX_CLIENTEDGE, NULL, WS_CHILD | WS_TABSTOP | WS_VISIBLE | ES_AUTOHSCROLL | ES_LEFT | ES_WINNORMALCASE, 71, 13, 94, 25, hWnd, 1003);
tbxAltura.Create(WS_EX_CLIENTEDGE, NULL, WS_CHILD | WS_TABSTOP | WS_VISIBLE | ES_AUTOHSCROLL | ES_LEFT | ES_WINNORMALCASE, 70, 50, 94, 25, hWnd, 1004);
lb3.Create(NULL, L"Kg", WS_CHILD | WS_VISIBLE | SS_LEFT | SS_WINNORMAL, 171, 13, 45, 25, hWnd, 1005);
lb4.Create(NULL, L"metros", WS_CHILD | WS_VISIBLE | SS_LEFT | SS_WINNORMAL, 171, 50, 45, 25, hWnd, 1006);
gbox1.Create(WS_EX_TRANSPARENT, L"Sexo", WS_CHILD | WS_VISIBLE | BS_GROUPBOX, 9, 97, 209, 91, hWnd, 1007);
radioHombre.Create(NULL, L"Hombre", WS_CHILD | WS_TABSTOP | WS_VISIBLE | BS_AUTORADIOBUTTON | BS_LEFT | BS_VCENTER, 25, 124, 136, 26, hWnd, 1008);
radioMujer.Create(NULL, L"Mujer", WS_CHILD | WS_TABSTOP | WS_VISIBLE | BS_AUTORADIOBUTTON | BS_LEFT | BS_VCENTER, 24, 149, 137, 26, hWnd, 1009);
btCalcular.Create(NULL, L"Calcular", WS_CHILD | WS_TABSTOP | WS_VISIBLE | BS_PUSHBUTTON | BS_CENTER | BS_VCENTER, 418, 13, 91, 28, hWnd, 1010);
fontArial014A.Create(L"Arial", 14, false, false, false, false);
lsIMC.Font = fontArial014A;
lb1.Font = fontArial014A;
lb2.Font = fontArial014A;
tbxPeso.Font = fontArial014A;
tbxAltura.Font = fontArial014A;
lb3.Font = fontArial014A;
lb4.Font = fontArial014A;
gbox1.Font = fontArial014A;
radioHombre.Font = fontArial014A;
radioMujer.Font = fontArial014A;
btCalcular.Font = fontArial014A;
}
//_________________________________________________
void btCalcular_Click(Win::Event& e);
void Window_Open(Win::Event& e);
//_________________________________________________
bool EventHandler(Win::Event& e)
{
if (btCalcular.IsEvent(e, BN_CLICKED)) { btCalcular_Click(e); return true; }
return false;
}
};
|
#include "framework.h"
/*
콘솔의 출력 스트림 --> ostream cout <Console OUTput stream>
콘솔의 입력 스트림 --> istream cin <Console INput stream>
ofstream :
ifstream :
C++ 의 모드 상수
ios::in 읽기 상태
ios::ate 파일을 열고 파일포인터를 EOF로 이동
ios::app 출력 데이터가 항상 EOF에 기록
ios::trunc 기존 파일이 이미 있는 경우 , 파일을 삭제후 다시 생성
ios::nocreate fopen()을 시도하지 않고 file의 존재 여부만 판단 --> 파일이 존재하지 않을 경우
에러를 발생
ios::noreplace ↑ 랑 반대로 file이 존재하면 에러
ios::binary 바이너리 파일 모드로 오픈
~@#EWG!#F그파워포인트이름.csv
csv
Comma Separated Value
*/
int main(void) {
// FILE * fp = fopen("text.txt", "wb");
// FILE * fp = fopen("text.txt", "w");
ofstream bfout = ofstream("binarytext.dat", ios::binary | ios::trunc );
ofstream tfout = ofstream("stringtext.txt", ios::trunc);
// FILE * fp = fopen("text.txt", "rb");
// FILE * fp = fopen("text.txt", "r");
ifstream bfin = ifstream("binarytext.dat");
ifstream tfin = ifstream("stringtext.txt");
fstream fs = fstream("binarytext.dat", ios::binary | ios::in | ios::_Nocreate);
bfout << "hello world" <<","<<100<<","<<3.141592 <<endl;
tfout << "hello world" << "," << 100 << "," << 3.141592 << endl;
string text = string();
char str[100] = { 0 };
getline(bfin, text);
tfin.getline(str, 99);
istringstream sin = istringstream(text);
sin >> text;
tfin.seekg(tfin._Seekbeg);
cout << text<<endl;
cout << str << endl;
bfout.close();
tfout.close();
bfin.close();
tfin.close();
fs.close();
return 0;
}
|
const int PIEZO_OUTPUT_PIN = 3;
void setup()
{
Serial.begin(9600); // for printing values to console
}
void loop()
{
int potVal = analogRead(A0); // returns 0 - 1023 (due to 10 bit ADC)
Serial.println(potVal); // print value to Serial
if(potVal > 0)
{
tone(PIEZO_OUTPUT_PIN, map(potVal, 0, 1023, 0, 1000));
} else {
noTone(PIEZO_OUTPUT_PIN);
}
delay(50); // Reading new values at ~20Hz
}
|
#ifndef _VEKTOR_HEADER_
#define _VEKTOR_HEADER_
#include "matrix.h"
class Vektor :
public Matrix
{
public:
Vektor(void);
float betrag();
float skalarprodukt(Vektor*);
float winkel(Vektor*);
virtual ~Vektor(void);
};
#endif /*_VEKTOR_HEADER_*/
|
#include<bits/stdc++.h>
using namespace std;
main()
{
long long int n, m;
while(cin>>n>>m)
{
long long int k, i;
k=n/m;
i=n%m;
cout<<((k*(k+1))/2)*i + ((k*(k-1))/2)*(m-i)<<" "<<((n-m)*(n-m+1))/2<<endl;
}
return 0;
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4; c-file-style:"stroustrup" -*-
**
** Copyright (C) 1995-2011 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
** Espen Sand
*/
#ifndef X11_ATOMIZER_H
#define X11_ATOMIZER_H
#include "platforms/utilix/x11types.h"
#include "modules/util/adt/opvector.h"
#define ATOMIZE(a) (X11Atomizer::Get(X11Atomizer::a))
#define IS_NET_SUPPORTED(a) (X11Atomizer::IsSupported(X11Atomizer::a))
class X11Atomizer
{
public:
enum AtomId {
_NET_SUPPORTED,
_NET_WM_DECORATION,
_NET_WM_MOVERESIZE,
_NET_WM_PING,
_NET_WM_PID,
_NET_WM_SYNC_REQUEST,
_NET_WM_SYNC_REQUEST_COUNTER,
_NET_WM_NAME,
_NET_WM_ICON,
_NET_WM_STATE,
_NET_WM_STATE_FULLSCREEN,
_NET_WM_STATE_HIDDEN,
_NET_WM_STATE_MAXIMIZED_HORZ,
_NET_WM_STATE_MAXIMIZED_VERT,
_NET_WM_STATE_SHADED,
_NET_WM_STATE_STAYS_ON_TOP,
_NET_WM_STATE_ABOVE,
_NET_WM_STATE_BELOW,
_NET_WM_STATE_DEMANDS_ATTENTION,
_NET_WM_STATE_MODAL,
_NET_WM_WINDOW_TYPE,
_NET_WM_WINDOW_TYPE_TOOLBAR,
_NET_WM_WINDOW_TYPE_MENU,
_NET_WM_WINDOW_TYPE_UTILITY,
_NET_WM_WINDOW_TYPE_SPLASH,
_NET_WM_WINDOW_TYPE_DIALOG,
_NET_WM_WINDOW_TYPE_DROPDOWN_MENU,
_NET_WM_WINDOW_TYPE_POPUP_MENU,
_NET_WM_WINDOW_TYPE_TOOLTIP,
_NET_WM_WINDOW_TYPE_NOTIFICATION,
_NET_WM_WINDOW_TYPE_COMBO,
_NET_WM_WINDOW_TYPE_DND,
_NET_WM_WINDOW_TYPE_NORMAL,
_NET_WM_STATE_SKIP_TASKBAR,
_NET_FRAME_EXTENTS,
_NET_FRAME_WINDOW,
_NET_DESKTOP_GEOMETRY,
_NET_NUMBER_OF_DESKTOPS,
_NET_CURRENT_DESKTOP,
_NET_WORKAREA,
_NET_SUPPORTING_WM_CHECK,
_NET_STARTUP_INFO_BEGIN,
_NET_STARTUP_INFO,
_MOTIF_WM_HINTS,
COMPOUND_TEXT,
OPERA_CLIPBOARD,
OPERA_VERSION,
OPERA_MESSAGE,
OPERA_SEMAPHORE,
OPERA_USER,
OPERA_PREFERENCE,
OPERA_WINDOW_NAME,
OPERA_WINDOWS,
SAVE_TARGETS,
TARGETS,
TEXT,
SM_CLIENT_ID,
WM_CLIENT_LEADER,
WM_CLIENT_MACHINE,
WM_DELETE_WINDOW,
WM_NAME,
WM_STATE,
WM_TAKE_FOCUS,
WM_WINDOW_ROLE,
WM_PROTOCOLS,
UTF8_STRING,
CLIPBOARD,
CLIPBOARD_MANAGER,
XdndAware,
XdndEnter,
XdndLeave,
XdndDrop,
XdndFinished,
XdndPosition,
XdndStatus,
XdndTypeList,
XdndActionList,
XdndSelection,
XdndProxy,
XdndActionCopy,
XdndActionMove,
XdndActionLink,
XdndActionPrivate,
NUM_ATOMS // Keep this one as the last element!
};
private:
struct Entry
{
int supported; // Only used for NET_ atoms. -1: Not tested, 0: No, 1: Yes
X11Types::Atom atom;
const char* name;
};
public:
static X11Types::Atom Get(AtomId id);
static bool IsSupported(AtomId id);
private:
static void Init();
private:
static Entry m_atom_list[NUM_ATOMS];
static OpAutoVector<X11Types::Atom> m_net_supported_list;
static bool m_has_init_supported_list;
};
#endif // X11_ATOMIZER_H
|
/******************************************************************************
* $Id$
*
* Project: libLAS - http://liblas.org - A BSD library for LAS format data.
* Purpose: Implementation of Classification type.
* Author: Mateusz Loskot, mateusz@loskot.net
*
******************************************************************************
* Copyright (c) 2009, Mateusz Loskot
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following
* conditions are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided
* with the distribution.
* * Neither the name of the Martin Isenburg or Iowa Department
* of Natural Resources nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
* OF SUCH DAMAGE.
****************************************************************************/
#include <liblas/classification.hpp>
#include <liblas/detail/private_utility.hpp>
// boost
#include <boost/cstdint.hpp>
// std
#include <cstddef>
#include <limits>
#include <string>
using namespace boost;
namespace {
static std::string g_class_names[] =
{
"Created, never classified",
"Unclassified",
"Ground",
"Low Vegetation",
"Medium Vegetation",
"High Vegetation",
"Building",
"Low Point (noise)",
"Model Key-point (mass point)",
"Water",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Overlap Points",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition",
"Reserved for ASPRS Definition"
};
} // namespace anonymous
namespace liblas {
uint32_t const Classification::class_table_size = detail::static_array_size(g_class_names);
std::string Classification::GetClassName() const
{
uint32_t const index = GetClass();
check_class_index(index);
return g_class_names[index];
}
uint8_t Classification::GetClass() const
{
bitset_type bits(m_flags);
bitset_type const mask(static_cast<uint64_t>(class_table_size) - 1);
bits &= mask;
uint32_t const index = static_cast<uint32_t>(bits.to_ulong());
assert(index < class_table_size);
assert(index <= std::numeric_limits<uint8_t>::max());
return static_cast<uint8_t>(index);
}
void Classification::SetClass(uint32_t index)
{
check_class_index(index);
bitset_type binval(static_cast<uint64_t>(index));
binval <<= 0;
// Store value in bits 0,1,2,3,4
bitset_type const mask(0x1F);
m_flags &= ~mask;
m_flags |= mask & binval;
}
void Classification::check_class_index(uint32_t index) const
{
if (index > class_table_size - 1 || !(index <= std::numeric_limits<uint8_t>::max()))
{
std::ostringstream msg;
msg << "given index is " << index
<< ", but must fit between 0 and " << (class_table_size - 1);
throw std::out_of_range(msg.str());
}
}
} // namespace liblas
|
// Datastructures.cc
// Remove the numberOfTowns and rechect the performance?
#include "datastructures.hh"
//#include <iostream>
#include <utility>
#include <cmath>
#include <random>
std::minstd_rand rand_engine; // Reasonably quick pseudo-random generator
template <typename Type>
Type random_in_range(Type start, Type end)
{
auto range = end-start;
++range;
auto num = std::uniform_int_distribution<unsigned long int>(0, range-1)(rand_engine);
return static_cast<Type>(start+num);
}
//template <class S> void Swap(S& name1, S& name2) {
// // Basic swapping of two values.
// S temp_ = name1;
// name1 = name2;
// name2 = temp_;
//}
Datastructures::Datastructures()
{
}
Datastructures::~Datastructures()
{
for (unsigned int i = 0; i < towns.size(); ++i) {
delete towns[i];
}
towns.clear();
distlist.clear();
alphalist.clear();
distlistUpdated = false;
alphalistUpdated = false;
// delete pivot;
}
unsigned int Datastructures::size()
{
return towns.size();
}
void Datastructures::clear()
{
for (unsigned int i = 0; i < towns.size(); ++i) {
delete towns[i];
}
towns.clear();
distlist.clear();
alphalist.clear();
alphalistUpdated = false;
distlistUpdated = false;
}
std::vector<TownData*> Datastructures::all_towns()
{
return towns;
}
TownData* Datastructures::add_town(const std::string& name, int x, int y)
{
TownData* town = new TownData;
town->name = name;
town->x = x;
town->y = y;
towns.push_back(town);
// distlistUpdated = false;
if (distlist.size() > 0) {
unsigned int n = binSearch(x, y);
if (n == distlist.size() - 1)
distlist.push_back(town);
else
distlist.insert(distlist.begin() + n, town);
}
if (alphalist.size() > 0) {
unsigned int n = binSearch(x, y, true, name);
if (n == alphalist.size() - 1)
alphalist.push_back(town);
else
alphalist.insert(alphalist.begin() + n, town);
}
return town;
}
std::vector<TownData*> Datastructures::towns_alphabetically()
{
if (towns.size() == 0)
return {};
if (alphalistUpdated)
return alphalist;
alphalistUpdated = true;
alphalist = mysort(towns, true, 0, towns.size() - 1);
return alphalist;
}
std::vector<TownData*> Datastructures::towns_distance_increasing()
{
if (towns.size() == 0)
return {};
if (distlistUpdated)
return distlist;
distlistUpdated = true;
distlist = mysort(towns, false, 0, towns.size() - 1);
return distlist;
}
TownData* Datastructures::find_town(std::string const& name)
{
if (alphalistUpdated) {
unsigned int n = binSearch(0, 0, true, name);
if (alphalist[n]->name == name)
return alphalist[n];
} else {
for (unsigned int i = 0; i < towns.size(); ++i) {
if (towns[i]->name == name)
return towns[i];
}
}
return nullptr;
}
TownData* Datastructures::min_distance()
{
if (towns.size() == 0)
return nullptr;
else if (distlistUpdated || distlist.size() == 1)
return distlist[0];
else {
distlist = mysort(towns, false, 0, towns.size() - 1);
distlistUpdated = true;
return distlist[0];
}
}
TownData* Datastructures::max_distance()
{
if (towns.size() == 0)
return nullptr;
else if (distlistUpdated || distlist.size() == 1)
return distlist[towns.size() - 1];
else {
distlist = mysort(towns, false, 0, towns.size() - 1);
distlistUpdated = true;
return distlist[distlist.size() - 1];
}
}
TownData* Datastructures::nth_distance(unsigned int n)
{
if (towns.size() < n || n == 0)
return nullptr;
else if (distlistUpdated)
return distlist[n - 1];
else {
distlist = mysort(towns, false, 0, towns.size() - 1);
distlistUpdated = true;
return distlist[n - 1];
}
}
void Datastructures::remove_town(const std::string& town_name)
{
for (unsigned int i = 0; i < towns.size(); ++i) {
if (towns[i]->name == town_name) {
delete towns[i];
towns.erase(towns.begin() + i);
distlistUpdated = false;
alphalistUpdated = false;
}
}
}
std::vector<TownData*> Datastructures::towns_distance_increasing_from(int x, int y)
{
return mysort(towns, false, 0, towns.size() - 1, x, y);
}
std::vector<TownData*> Datastructures::mysort(std::vector<TownData *> towns, const bool& alpha,
const int& left, const int& right,
const int& x, const int& y) {
unsigned int maxDepth = 2*log2(towns.size());
introsort(towns, maxDepth, left, right, alpha, x, y);
return towns;
}
void Datastructures::introsort(std::vector<TownData *> &towns, unsigned int maxDepth,
const int& left, const int& right, const bool& alpha,
const int& x, const int& y) {
if (right - left <= 16) {
insertionsort(towns, alpha, left, right, x, y);
} else if (maxDepth == 0) {
heapsort(towns, alpha, left, right, x, y);
} else {
if (left < right) {
unsigned int p = part(towns, left, right, alpha, x, y);
introsort(towns, maxDepth - 1, left, p - 1, alpha, x, y);
introsort(towns, maxDepth - 1, p + 1, right, alpha, x, y);
}
}
}
void Datastructures::maxHeapify(std::vector<TownData *> &towns, const int &left,
const int &right, const bool& alpha, const int &x,
const int &y, const int& i, const int &n) {
int largest;
int l = 2*i;
int r = 2*i + 1;
if (alpha) {
if (l <= n && towns[l]->name > towns[i]->name)
largest = l;
else
largest = i;
if (r <= n && towns[r]->name > towns[largest]->name)
largest = r;
} else {
if (l <= n && abs(towns[l]->x - x) + abs(towns[l]->y - y) >
abs(towns[i]->x - x) + abs(towns[i]->y - y))
largest = l;
else
largest = i;
if (r <= n && abs(towns[r]->x - x) + abs(towns[r]->y - y) >
abs(towns[largest]->x - x) + abs(towns[largest]->y - y))
largest = r;
}
if (largest != i) {
std::swap(towns[i], towns[largest]);
maxHeapify(towns, left, right, alpha, x, y, largest, n);
}
}
void Datastructures::buildMaxHeap(std::vector<TownData *> &towns, const int &left,
const int &right, const bool& alpha, const int &x,
const int &y) {
int n = right - left;
for (int i = (right - left)/2; i >= 1; --i) {
maxHeapify(towns, left, right, alpha, x, y, i, n);
}
}
void Datastructures::heapsort(std::vector<TownData *> &towns, const bool& alpha,
const int& left, const int& right,
const int& x, const int& y) {
int n = right - left;
buildMaxHeap(towns, left, right, alpha, x, y);
for (int i = n; i >= left + 1; --i) {
std::swap(towns[i], towns[1]);
n -= 1;
maxHeapify(towns, left, right, alpha, x, y, 1, n);
}
}
void Datastructures::insertionsort(std::vector<TownData *> &towns, const bool& alpha,
const int& left, const int& right,
const int& x, const int& y) {
int j;
for (int i = left; i <= right; ++i) {
j = i;
if (alpha) {
while (j > 0 && towns[j]->name < towns[j-1]->name){
std::swap(towns[j], towns[j-1]);
--j;
}
} else {
while (j > 0 && abs(towns[j]->x - x) + abs(towns[j]->y - y) <
abs(towns[j - 1]->x - x) + abs(towns[j - 1]->y - y)){
std::swap(towns[j], towns[j-1]);
--j;
}
}
}
}
unsigned int Datastructures::part(std::vector<TownData *> &towns, const int &left,
const int &right, const bool& alpha, const int& x,
const int& y) {
// int pt = random_in_range(left, right);
int pt = left + (right - left)/2;
pivot = towns[pt];
std::swap(towns[left], towns[pt]);
int i = left + 1;
int j = right;
if (alpha) {
while (i <= j) {
while (i <= j && towns[i]->name <= pivot->name) {
++i;
}
while (i <= j && towns[j]->name > pivot->name) {
--j;
}
if (i < j) {
std::swap(towns[i], towns[j]);
}
}
} else {
while (i <= j) {
while (i <= j && abs(towns[i]->x - x) + abs(towns[i]->y - y) <=
abs(pivot->x - x) + abs(pivot->y - y)) {
++i;
}
while (i <= j && abs(towns[j]->x - x) + abs(towns[j]->y - y) >
abs(pivot->x - x) + abs(pivot->y - y)) {
--j;
}
if (i < j) {
std::swap(towns[i], towns[j]);
}
}
}
std::swap(towns[left], towns[i-1]);
return i - 1;
}
//TownData* Datastructures::myselect(std::vector<TownData *> towns, const int &left,
// const int &right, unsigned int n) {
// n -= 1;
// if (left == right) {
// return towns[right];
// } else {
// unsigned int maxDepth = 2*log2(right - left);
// return introselect(towns, left, right, n, maxDepth);
// }
//}
//TownData* Datastructures::introselect(std::vector<TownData *> towns, unsigned int left,
// unsigned int right, const unsigned int &n, unsigned int maxDepth) {
// while (right - left > 3) {
// if (maxDepth == 0) {
// return heapselect(towns, left, right, n);
// }
// --maxDepth;
// unsigned int pt = part(towns, left, right, false);
// if (pt <= n) {
// left = pt;
// } else {
// right = pt;
// }
// }
// insertionsort(towns, false, left, right);
// return towns[n];
//}
//TownData* Datastructures::heapselect(std::vector<TownData *> towns, unsigned int left,
// unsigned int right, unsigned int n) {
// unsigned int p = (right - left)/2;
// for (int i = p; i >= 0; --i){
// heapMove(towns, i, right);
// }
// unsigned int limit = right - n + 1;
// for (unsigned int i = right; i > limit; --i) {
// if (abs(towns[0]->x) + abs(towns[0]->y) > abs(towns[i]->x) + abs(towns[i]->y)) {
// std::swap(towns[0], towns[i]);
// heapMove(towns, 0, i - 1);
// }
// }
// return towns[0];
//}
//void Datastructures::heapMove(std::vector<TownData *> towns, unsigned int first, unsigned int last) {
// unsigned int largest = 2*first + 1;
// while (largest <= last) {
// if (largest < last && abs(towns[largest]->x) + abs(towns[largest]->y) >
// abs(towns[largest + 1]->x) + abs(towns[largest + 1]->y)) {
// ++largest;
// }
// if (abs(towns[first]->x) + abs(towns[first]->y) <
// abs(towns[largest]->x) + abs(towns[largest]->y)) {
// std::swap(towns[first], towns[largest]);
// first = largest;
// largest = 2*first + 1;
// } else
// return;
// }
//}
unsigned int Datastructures::binSearch(const int &x, const int &y, const bool &alpha,
const std::string &townName) {
int low = 0, high = distlist.size() - 1;
int mid;
if (alpha) {
while (low < high) {
mid = low + (high - low)/2;
if (alphalist[mid]->name == townName)
return mid;
else if (alphalist[mid]->name > townName)
high = mid;
else
low = mid + 1;
}
} else {
while (low < high) {
mid = low + (high - low)/2;
if (abs(distlist[mid]->x) + abs(distlist[mid]->y) ==
abs(x) + abs(y))
return mid;
else if (abs(distlist[mid]->x) + abs(distlist[mid]->y) >
abs(x) + abs(y))
high = mid;
else
low = mid + 1;
}
}
return low;
}
|
#ifndef forme
#define forme
#include <iostream>
class Shape
{
public:
Shape() {}
virtual double getArea() = 0;
virtual std::ostream &put(std::ostream &s) const
{
s << "Forma Shape: " << std::endl;
return s;
}
};
class Rectangle : public Shape
{
double base;
double altezza;
public:
Rectangle(double b, double a) : base(b), altezza(a) {}
Rectangle() : Rectangle(0.0, 0.0) {}
double getBase() { return base; }
double getAltezza() { return altezza; }
double getArea() { return base * altezza; }
std::ostream &put(std::ostream &s) const
{
s << "Figura: Rettangolo" << std::endl;
s << "Base: " << base << std::endl;
s << "Altezza: " << altezza << std::endl;
s << std::endl;
return s;
}
};
class Circle : public Shape
{
double raggio;
public:
Circle(double r) : raggio(r) {}
Circle() : Circle(0.0) {}
double getRaggio() { return raggio; }
double getArea() { return raggio * raggio * 3.14; }
std::ostream &put(std::ostream &s) const
{
s << "Figura: Cerchio" << std::endl;
s << "raggio: " << raggio << std::endl;
s << std::endl;
return s;
}
};
class Triangolo : public Shape
{
double base;
double altezza;
public:
Triangolo(double b, double a) : base(b), altezza(a) {}
Triangolo() : Triangolo(0.0, 0.0) {}
double getBase() { return base; }
double getAltezza() { return altezza; }
double getArea() { return (base * altezza) / 2; }
std::ostream &put(std::ostream &s) const
{
s << "Figura: Triangolo" << std::endl;
s << "Base: " << base << std::endl;
s << "Altezza: " << altezza << std::endl;
s << std::endl;
return s;
}
};
std::ostream &operator<<(std::ostream &out, const Shape &a)
{
return a.put(out);
}
#endif
|
#include <bitset>
#include <iostream>
#include <cstdint>
auto get_bits(auto v) {
return std::bitset<sizeof(v)*8>(*reinterpret_cast<unsigned long long*>(&v));
}
int main() {
// Basic types
bool a = true;
std::cout << "bool a: " << a << std::endl;
std::cout << "sizeof(a): " << sizeof(a) << " bytes" << std::endl;
std::cout << get_bits(a) << std::endl;
std::cout << std::endl;
int b = 25;
std::cout << "int b: " << b << std::endl;
std::cout << "sizeof(b): " << sizeof(b) << " bytes" << std::endl;
std::cout << get_bits(b) << std::endl;
std::cout << std::endl;
double c = 1.34;
std::cout << "double c: " << c << std::endl;
std::cout << "sizeof(c): " << sizeof(c) << " bytes" << std::endl;
std::cout << get_bits(c) << std::endl;
std::cout << std::endl;
char d = 'g';
std::cout << "char d: " << d << std::endl;
std::cout << "sizeof(d): " << sizeof(d) << " bytes" << std::endl;
std::cout << get_bits(d) << std::endl;
std::cout << std::endl;
// Integer implicit precision
long g = 25;
std::cout << "long g: " << g << std::endl;
std::cout << "sizeof(g): " << sizeof(g) << " bytes" << std::endl;
std::cout << get_bits(g) << std::endl;
std::cout << std::endl;
long long h = 8271;
std::cout << "long long h: " << h << std::endl;
std::cout << "sizeof(h): " << sizeof(h) << " bytes" << std::endl;
std::cout << get_bits(h) << std::endl;
std::cout << std::endl;
// Unsigned integer - implicit precision
unsigned long i = 987312;
std::cout << "unsigned long i: " << i << std::endl;
std::cout << "sizeof(i): " << sizeof(i) << " bytes" << std::endl;
std::cout << get_bits(i) << std::endl;
std::cout << std::endl;
unsigned long long j = 4398271;
std::cout << "unsigned long long j: " << j << std::endl;
std::cout << "sizeof(j): " << sizeof(j) << " bytes" << std::endl;
std::cout << get_bits(j) << std::endl;
std::cout << std::endl;
// Integer explicit precision
int8_t k = 25;
std::cout << "int8_t k: " << k << std::endl;
std::cout << "sizeof(k): " << sizeof(k) << " bytes" << std::endl;
std::cout << get_bits(k) << std::endl;
std::cout << std::endl;
int64_t l = 542;
std::cout << "int64_t l: " << l << std::endl;
std::cout << "sizeof(l): " << sizeof(l) << " bytes" << std::endl;
std::cout << get_bits(l) << std::endl;
std::cout << std::endl;
// Unsigned integer explicit precision
uint8_t m = 54;
std::cout << "uint8_t m: " << m << std::endl;
std::cout << "sizeof(m): " << sizeof(m) << " bytes" << std::endl;
std::cout << get_bits(m) << std::endl;
std::cout << std::endl;
uint64_t n = 76354346;
std::cout << "uint64_t n: " << n << std::endl;
std::cout << "sizeof(n): " << sizeof(n) << " bytes" << std::endl;
std::cout << get_bits(n) << std::endl;
std::cout << std::endl;
// Floating point precision
float o = 25.54;
std::cout << "float o: " << o << std::endl;
std::cout << "sizeof(o): " << sizeof(o) << " bytes" << std::endl;
std::cout << get_bits(o) << std::endl;
std::cout << std::endl;
long double p = 987312.325;
std::cout << "long double p: " << p << std::endl;
std::cout << "sizeof(p): " << sizeof(p) << " bytes" << std::endl;
std::cout << get_bits(p) << std::endl;
std::cout << std::endl;
// Char
unsigned char q = 'c';
std::cout << "unsigned char m: " << q << std::endl;
std::cout << "sizeof(q): " << sizeof(q) << " bytes" << std::endl;
std::cout << get_bits(q) << std::endl;
std::cout << std::endl;
return 0;
}
|
#include "stdio.h"
#include "conio.h"
void main () {
int num1,num2,op;
clrscr();
printf("Enter number1: ");
scanf("%d",&num1);
printf("Enter number2: ");
scanf("%d",&num2);
printf("Enter case: ");
scanf("%d",&op);
switch (op) {
case 1:
printf(" = %d",num1+num2);
break;
case 2:
printf(" = %d",num1-num2);
break;
case 3:
printf(" = %d",num1*num2);
break;
case 4:
printf(" = %d",num1/num2);
break;
default:
printf("Invalid character");
}
getch();
}
|
uint8_t value1 = 0xFE;
uint8_t value = 0x01;
uint8_t digit[16] = { 0xC0, 0xF9, 0xA4, 0xB0, 0x99, 0x92, 0x82, 0xD8,
0x80, 0x90, 0x88, 0x83, 0xC6, 0xA1, 0x86, 0x8E
};
const int delayTime = 200;
int count = 0;
void setup() {
DDRC = 0xFF;
DDRA = 0xFF;
PORTC = digit[0];
}
void loop() {
PORTA = value1;
delay(delayTime);
value = value << 1;
value1 = ~value;
if (value1 == 0x7F) {
PORTA = value1;
delay(delayTime);
value1 = 0xFE;
value = 0x01;
PORTC = digit[count + 1];
count++;
if (count == 15) {
count = -1;
}
}
}
|
#include <sstream>
#include <fstream>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <map>
#include "steprun.h"
using namespace std;
//////////////////// print run step by step ////////////////////////////
void print_step_run(const char* bin, const char* traceFile, const char* outFile)
{
assert(traceFile && outFile);
ofstream fout(outFile, ios::out);
assert(fout);
ifstream fin(traceFile, ios::in);
assert(fin);
char line[16];
if (!fin.getline(line, sizeof(line)))
{
fin.clear();
fin.close();
assert(0);
return;
}
char type = 0;
int addr = 0;
sscanf(line, "%c%x", &type, &addr);
if (type != 'E')
{
fin.clear();
fin.close();
assert(0);
return;
}
char cmd[256];
STEP_NODE* pNow = new STEP_NODE;
bool bLastE = true;
int len = 0;
do{
sscanf(line, "%c%x", &type, &addr);
sprintf(cmd, "addr2line -e %s -f -s 0x%x", bin, addr);
printf("%s \n", cmd);
if(type == 'E')
{
char func_file[256];
FILE* p = NULL;
if((p = popen(cmd, "r")) != NULL)
{
usleep(20);
char parse[256] = {0};
char file[128];
fread(parse, sizeof(parse), 1, p);
sscanf(parse, "%s\n%s\n", (char*)func_file, (char*)file);
strcat(func_file, "/");
strcat(func_file, file);
}
pclose(p);
STEP_NODE* pNode = new STEP_NODE;
assert(pNode);
pNode->addr = addr;
strcpy(pNode->func_file, func_file);
pNode->prev = pNow;
pNow = pNode;
if(bLastE == false)
{
fout << endl;
for(int i = 0; i < len; ++i)
fout << " ";
}
fout << " => " << pNode->func_file;
fout.flush();
len += 4;
len += strlen(pNode->func_file);
bLastE = true;
}
else if(type == 'X')
{
STEP_NODE* pNode = pNow;
pNow = pNow->prev;
len -= strlen(pNode->func_file);
len -= 4;
bLastE = false;
delete pNode;
}
else
{
assert(0);
}
}while(fin.getline(line, sizeof(line)));
delete pNow;
pNow = NULL;
fin.clear();
fin.close();
fout.clear();
fout.close();
}
|
#include "precompiled.h"
#include "q3shader/q3shadercache.h"
#include "q3shader/q3shader.h"
#include "q3shader/q3shaderpass.h"
#include "render/render.h"
#include "texture/texturecache.h"
#include "texture/texture.h"
#include "timer/timer.h"
namespace q3shader
{
Q3ShaderPass::parse_map Q3ShaderPass::s_parseMap;
static void init();
static unordered_map<string, DWORD> blend_modes;
}
using namespace q3shader;
REGISTER_STARTUP_FUNCTION(Q3ShaderPass, Q3ShaderPass::initParseMap, 10);
void Q3ShaderPass::initParseMap()
{
blend_modes["gl_one"] = D3DBLEND_ONE;
blend_modes["gl_zero"] = D3DBLEND_ZERO;
blend_modes["gl_dst_color"] = D3DBLEND_DESTCOLOR;
blend_modes["gl_one_minus_dst_color"] = D3DBLEND_INVDESTCOLOR;
blend_modes["gl_src_alpha"] = D3DBLEND_SRCALPHA;
blend_modes["gl_one_minus_src_alpha"] = D3DBLEND_INVSRCALPHA;
blend_modes["gl_src_color"] = D3DBLEND_SRCCOLOR;
blend_modes["gl_one_minus_src_color"] = D3DBLEND_INVSRCCOLOR;
blend_modes["gl_dst_alpha"] = D3DBLEND_DESTALPHA;
blend_modes["gl_one_minus_dst_alpha"] = D3DBLEND_INVDESTALPHA;
Q3ShaderPass::s_parseMap["map"] = &Q3ShaderPass::parseMap;
Q3ShaderPass::s_parseMap["rgbgen"] = &Q3ShaderPass::parseRGBGen;
Q3ShaderPass::s_parseMap["blendfunc"] = &Q3ShaderPass::parseBlendFunc;
Q3ShaderPass::s_parseMap["tcgen"] = &Q3ShaderPass::parseTCGen;
Q3ShaderPass::s_parseMap["tcmod"] = &Q3ShaderPass::parseTCMod;
Q3ShaderPass::s_parseMap["clampmap"] = &Q3ShaderPass::parseClampMap;
Q3ShaderPass::s_parseMap["alphafunc"] = &Q3ShaderPass::parseAlphaFunc;
Q3ShaderPass::s_parseMap["depthfunc"] = &Q3ShaderPass::parseDepthFunc;
Q3ShaderPass::s_parseMap["depthwrite"] = &Q3ShaderPass::parseDepthWrite;
Q3ShaderPass::s_parseMap["alphagen"] = &Q3ShaderPass::parseAlphaGen;
Q3ShaderPass::s_parseMap["detail"] = &Q3ShaderPass::parseDetail;
Q3ShaderPass::s_parseMap["animmap"] = &Q3ShaderPass::parseAnimMap;
Q3ShaderPass::s_parseMap["alphamap"] = &Q3ShaderPass::parseAlphaMap;
}
void Q3ShaderPass::parseAlphaMap(const params& p)
{
// this is not used
}
void Q3ShaderPass::parseAnimMap(const params& p)
{
m_animfrequency = 1000.0 / lexical_cast<float>(p[1]);
for(int i = 2; i < p.size(); i++)
m_animapnames.push_back(p[i]);
m_activate.push_back(bind(&Q3ShaderPass::setAnimatedTexture, this));
}
void Q3ShaderPass::parseDetail(const params& p)
{
// this is not used
}
void Q3ShaderPass::parseAlphaGen(const params& p)
{
// TODO: parse alpha gen
}
void Q3ShaderPass::parseDepthWrite(const params& p)
{
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ZWRITEENABLE, TRUE));
m_overridedepth = true;
}
void Q3ShaderPass::parseDepthFunc(const params& p)
{
if(p[1] == "equal")
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ZFUNC, D3DCMP_EQUAL));
else
ASSERT(false);
m_deactivate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ZFUNC, D3DCMP_LESSEQUAL));
}
void Q3ShaderPass::parseAlphaFunc(const params& p)
{
if(p[1] == "gt0")
{
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHAFUNC, D3DCMP_GREATER));
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHAREF, 0));
}
else if(p[1] == "ge128")
{
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL));
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHAREF, 128));
}
else if (p[1] == "lt128")
{
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHAFUNC, D3DCMP_LESS));
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHAREF, 128));
}
else
ASSERT(false);
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHATESTENABLE, TRUE));
m_deactivate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHATESTENABLE, FALSE));
}
void Q3ShaderPass::parseClampMap(const params& p)
{
//m_activate.push_back(bind(&Q3ShaderPass::setSamplerState, this, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP));
//m_activate.push_back(bind(&Q3ShaderPass::setSamplerState, this, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP));
//m_deactivate.push_back(bind(&Q3ShaderPass::setSamplerState, this, 0, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP));
//m_deactivate.push_back(bind(&Q3ShaderPass::setSamplerState, this, 0, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP));
parseMap(p);
}
void Q3ShaderPass::parseTCMod(const params& p)
{
// TODO: parse tcmod params
}
void Q3ShaderPass::parseTCGen(const params& p)
{
// TODO: parse tcgen params
}
void Q3ShaderPass::parseBlendFunc(const params& p)
{
if(p.size() == 2) // shortcut
{
params sp;
sp.push_back("blendfunc");
if(p[1] == "add" || p[1] == "gl_add")
{
sp.push_back("gl_one");
sp.push_back("gl_one");
}
else if(p[1] == "filter")
{
sp.push_back("gl_dst_color");
sp.push_back("gl_zero");
}
else if(p[1] == "blend")
{
sp.push_back("gl_src_alpha");
sp.push_back("gl_one_minus_src_alpha");
}
else
ASSERT(false);
return parseBlendFunc(sp);
}
ASSERT(blend_modes.find(p[1]) != blend_modes.end());
ASSERT(blend_modes.find(p[2]) != blend_modes.end());
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_SRCBLEND, blend_modes[p[1]]));
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_DESTBLEND, blend_modes[p[2]]));
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHABLENDENABLE, TRUE));
m_activate.push_back(bind(&Q3ShaderPass::setTextureStageState, this, 0, D3DTSS_COLOROP, D3DTOP_SELECTARG1));
if(!m_overridedepth)
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ZWRITEENABLE, FALSE));
m_deactivate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ALPHABLENDENABLE, FALSE));
m_deactivate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_ZWRITEENABLE, TRUE));
m_deactivate.push_back(bind(&Q3ShaderPass::setTextureStageState, this, 0, D3DTSS_COLOROP, D3DTOP_MODULATE2X));
}
void Q3ShaderPass::parseRGBGen(const params& p)
{
if(p[1] == "identity")
{
// do nothing? material should be 1.0 1.0 1.0
}
else if (p[1] == "const")
{
float rgb[3];
for(int i = 0; i < 3; i++)
rgb[i] = lexical_cast<float>(p[i + 3]);
D3DCOLOR color = D3DXCOLOR(rgb[0], rgb[1], rgb[2], 1.0f);
m_activate.push_back(bind(&Q3ShaderPass::setRenderState, this, D3DRS_TEXTUREFACTOR, color));
m_activate.push_back(bind(&Q3ShaderPass::setTextureStageState, this, 0, D3DTSS_COLORARG1, D3DTA_TFACTOR));
m_deactivate.push_back(bind(&Q3ShaderPass::setTextureStageState, this, 0, D3DTSS_COLORARG1, D3DTA_TEXTURE));
}
}
void Q3ShaderPass::parseMap(const params& p)
{
if(p[1] == "$lightmap")
{
useLightmapHack = true;
//m_activate.push_back(bind(&Q3ShaderPass::setLightmapTexture, this));
m_activate.push_back(bind(&Q3ShaderPass::setTextureStageState, this, 0, D3DTSS_TEXCOORDINDEX, 1));
m_deactivate.push_back(bind(&Q3ShaderPass::setTextureStageState, this, 0, D3DTSS_TEXCOORDINDEX, 0));
// hacky: activate z-writing for anything that accepts a lightmap
parseDepthWrite(p);
m_shader->is_useslightmap = true;
}
//else if(p[1] == "$whiteimage")
//{
// m_mapname = "textures/default/white";
// m_activate.push_back(bind(&Q3ShaderPass::setTexture, this));
//}
else
{
ASSERT(m_mapname.empty());
m_mapname = p[1];
m_activate.push_back(bind(&Q3ShaderPass::setTexture, this));
}
}
Q3ShaderPass::Q3ShaderPass(Q3Shader* shader, const shader_lines& shadertext)
: m_shader(shader), m_activated(false), m_animfrequency(0), m_overridedepth(false), m_current_map(0),
m_lastswitched(0.0), useLightmapHack(false)
{
for(shader_lines::const_iterator it = shadertext.begin(); it != shadertext.end(); ++it)
{
vector<string> v;
split(v, *it, is_space(), token_compress_on);
to_lower(v[0]);
(this->*s_parseMap[v[0]])(v);
}
}
Q3ShaderPass::~Q3ShaderPass()
{
}
void Q3ShaderPass::activate()
{
for(function_list::iterator it = m_activate.begin(); it != m_activate.end(); it++)
(*it)();
}
void Q3ShaderPass::deactivate()
{
for(function_list::iterator it = m_deactivate.begin(); it != m_deactivate.end(); it++)
(*it)();
}
HRESULT Q3ShaderPass::setTexture()
{
if(!m_activated)
{
m_map = texture::getTexture(m_mapname.c_str());
if(!m_map)
{
m_mapname = string(m_mapname.begin(), boost::find_last(m_mapname, ".").begin());
m_map = texture::getTexture(m_mapname.c_str());
}
m_activated = true;
if(!m_map)
INFO("ERROR: unable to load texture: %s", m_mapname.c_str());
}
if(m_map)
return render::device->SetTexture(0, m_map->texture);
else
return render::device->SetTexture(0, NULL);
}
HRESULT Q3ShaderPass::setAnimatedTexture()
{
if(!m_activated)
{
for(vector<string>::iterator it = m_animapnames.begin(); it != m_animapnames.end(); ++it)
{
string mapname = *it;
texture::DXTexture* map = texture::getTexture(mapname.c_str());
if(!map)
{
mapname = string(mapname.begin(), boost::find_last(mapname, ".").begin());
map = texture::getTexture(mapname.c_str());
}
m_animaps.push_back(map);
}
m_activated = true;
}
if(m_lastswitched + m_animfrequency < timer::game_ms)
{
m_current_map++;
m_lastswitched = timer::game_ms;
if(m_current_map == m_animaps.size())
m_current_map = 0;
}
if(m_animaps[m_current_map])
return render::device->SetTexture(0, m_animaps[m_current_map]->texture);
else
return render::device->SetTexture(0, NULL);
}
HRESULT Q3ShaderPass::setRenderState(D3DRENDERSTATETYPE state, DWORD value)
{
return render::device->SetRenderState(state, value);
}
HRESULT Q3ShaderPass::setSamplerState( DWORD sampler, D3DSAMPLERSTATETYPE type, DWORD value )
{
return render::device->SetSamplerState(sampler, type, value);
}
HRESULT Q3ShaderPass::setTextureStageState(DWORD stage, D3DTEXTURESTAGESTATETYPE type, DWORD value)
{
return render::device->SetTextureStageState(stage, type, value);
}
HRESULT Q3ShaderPass::setLightmapTexture()
{
return D3D_OK;
}
|
#include<iostream>
using namespace std;
int main()
{
int w, k, n, i;
int total = 0;
int pay;
cin >> k >> n >> w;
for (i = 1; i <= w; i++)
{
total = k * i + total;
}
cout << total << endl;
if (n > total)
{
cout << "0";
}
else
{
pay = total - n;
cout << pay;
}
return 0;
}
|
#include <stdio.h>
#include <conio.h>
#include <windows.h>
void SetColor(int);
void gotoxy(short x, short y) {
COORD pos = {x, y};
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), pos);
}
void matrix(char[],int,int);
int checkwin(char[]);
int main()
{
int l=0,m=0,n=0;
Here:
char arr[10]={'1','2','3','4','5','6','7','8','9'},ch;
int i,k;
for(i=1;i<10;i++)
{
matrix(arr,l,m);
if(i%2!=0)
{
SetColor(3);
printf("\t\t\t\t\t\t\t");
printf("\r\t\t\tPLAYER 1-> ");
plr1:
ch=getche();
Beep(900, 500);
k=ch-49;
if(k>9||k<=-1||arr[k]=='O'||arr[k]=='X')
{
printf("\n\t\tPLAYER 1!! Try Again!! ");
Sleep(2000);
printf("\r\t\t\t\t\t\t\t\t\t\t\t\r");
goto plr1;
}
arr[k]='X';
if(checkwin(arr)==1)
{
l=l+1;
n=n+1;
matrix(arr,l,m);
SetColor(13);
printf("\n\n\t\t\tPLAYER 1 WON !!!\t\t\r");
Beep(600, 500);
Sleep(2000);
SetColor(4);
printf("\t\tPREVIOUS MATCH PLAYER 1 ");
break;
}
}
else
{
SetColor(7);
printf("\t\t\t\t\t\t\t");
printf("\r\t\t\tPLAYER 2-> ");
plr2:
ch=getche();
Beep(750, 300);
k=ch-49;
if(k>9||k<=-1||arr[k]=='X'||arr[k]=='O')
{
printf("\n\t\tPLAYER 2!! Try Again!! ");
Sleep(2000);
printf("\r\t\t\t\t\t\t\t\t\t\r");
goto plr2;
}
arr[k]='O';
if(checkwin(arr)==1)
{
m=m+1;
n=n+1;
matrix(arr,l,m);
printf("\n\n\t\tPLAYER 2 WON!!!\t\t\r");
Beep(500, 1000);
Sleep(2000);
SetColor(1);
printf("\t\tPREVIOUS MATCH PLAYER 2 ");
break;
}
}
}
if(i==10)
{
matrix(arr,l,m);
printf("\n\n\t\t\tTHE GAME WAS A DRAW!!");
n=n+1;
}
if(l==3)
{
SetColor(9);
printf("\n\n\t\tPLAYER 1 WON THE SERIES!!");
Beep(400, 1000);
Beep(600,1000);
Beep(800,600);
return 0;
}
if(m==3)
{
SetColor(6);
printf("\n\n\t\tPLAYER 2 WON THE SERIES!!");
Beep(800, 600);
Beep(600, 1000);
Beep(400, 1000);
return 0;
}
if(l==m&&n==5)
{
SetColor(8);
printf("\n\n\t\tTHE SERIES WAS A DRAW");
Beep(400,1000);
Beep(300,1000);
Beep(200,1000);
Beep(100,1000);
return 0;
}
goto Here;
return 0;
}
void matrix(char brr[],int l,int m)
{
gotoxy(0,0);
SetColor(14);
printf("\t\t Player 1 <X> Player 2<O>\n");
SetColor(12);
printf("\n\t\t IT IS A FIVE MATCH SERIES\n\n");
SetColor(6);
printf("\t\tINPUTS MUST BE GIVEN FROM 1 TO 9\n\n");
SetColor(15);
printf("\t\t\t SCORE:\n\t\t Player 1: %d | Player 2: %d\n\n",l,m);
SetColor(15);
printf("\t\t\t | |\n\t\t\t %c | %c | %c \n\t\t\t_____|_____|_____\n\t\t\t | | \n\t\t\t %c | %c | %c \n\t\t\t_____|_____|_____\n\t\t\t | |\n\t\t\t %c | %c | %c \n\t\t\t | | \n\n\n",brr[0],brr[1],brr[2],brr[3],brr[4],brr[5],brr[6],brr[7],brr[8]);
}
int checkwin(char brr[])
{
if(brr[0]==brr[3]&&brr[3]==brr[6])
return 1;
else if(brr[1]==brr[4]&&brr[4]==brr[7])
return 1;
else if(brr[2]==brr[5]&&brr[5]==brr[8])
return 1;
else if(brr[0]==brr[1]&&brr[1]==brr[2])
return 1;
else if(brr[3]==brr[4]&&brr[4]==brr[5])
return 1;
else if(brr[6]==brr[7]&&brr[7]==brr[8])
return 1;
else if(brr[0]==brr[4]&&brr[4]==brr[8])
return 1;
else if(brr[2]==brr[4]&&brr[4]==brr[6])
return 1;
else
return 0;
}
void SetColor(int ForgC)
{
WORD wColor;
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
CONSOLE_SCREEN_BUFFER_INFO csbi;
if(GetConsoleScreenBufferInfo(hStdOut, &csbi))
{
wColor = (csbi.wAttributes & 0xF0) + (ForgC & 0x0F);
SetConsoleTextAttribute(hStdOut, wColor);
}
return;
}
|
//
// EPITECH PROJECT, 2018
// nanotekspice
// File description:
// simulate chipsets
//
#ifndef __COMPONENTS_HPP__
# define __COMPONENTS_HPP__
#include <vector>
#include <string>
class Components
{
public:
Components();
~Components();
void init_component_tab();
int find_in_component_tab(std::string str);
std::vector<std::string> getComponentTab();
private:
std::vector<std::string> _my_components;
};
#endif /* __COMPONENTS_HPP__ */
|
#ifndef THIRDMONSTER_H
#define THIRDMONSTER_H
#include "monster.h"
#include "launcher.h"
#include "fireball.h"
class ThirdMonster : public Monster, public Launcher {
Q_OBJECT
public:
ThirdMonster(QObject *parent = nullptr);
ThirdMonster(int x,
int y,
int width,
int height,
QObject *parent = nullptr);
void updatePos(int judge_unit) override;
FlyingProp* launchFlyingProp() override;
protected:
static int Num;
int _num;
int _originMoveSpeed;
QTimer _launchTimer;
protected slots:
void launchOver();
};
#endif // THIRDMONSTER_H
|
#include "pch.h"
#include "DBServer.h"
DBServer::DBServer()
{
}
DBServer::~DBServer()
{
}
BOOL DBServer::Begin()
{
m_ServerConnector = new CServerConnector();
return TRUE;
}
BOOL DBServer::End()
{
return TRUE;
}
|
// Name : Angel E Hernandez
// Date : April 17
// CIS 1202.800
// Project name : Inheritance
#pragma once
#ifndef TRUCK_H
#define TRUCK_H
#include "Vehicle.h"
#include <string>
using namespace std;
// Truck is a type of vehicle that inherits members variables
//and functions from the class vehicle
class Truck : public Vehicle
{
private:
int capacity = 0;
public:
// defaul constructor
Truck() : Vehicle()
{
int capacity = 0;
}
// constructor 2
Truck(string vehicleManf, int vehicleYear, int vehicleCapacity)
: Vehicle(vehicleManf, vehicleYear)
{
capacity = vehicleCapacity;
}
// Accesor for capacity attribute
int getCapacity()
{
return capacity;
}
// display info
void displayInfo(); // define in truck.cpp
};
#endif
|
#include "generator.h"
#include "widget.h"
extern Widget* widget;
Generator::Generator(QObject *parent) : QObject(parent)
{
counter = 0;
numbers = new int*[9];
for(int i = 0; i < 9; i++)
numbers[i] = new int [9];
}
void Generator::recieveDifficulty(int diff)
{
difficulty = diff;
for(int i = 0; i < 9; i++)
for(int j = 0; j < 9; j++)
numbers[i][j] = 0;
startGeneration(0);
oneVariantRemoving();
for(int i = 0; i < 9; i++)
if(i%difficulty == 0)
rowLastHeroRemoving(i);
for(int j = 0; j< 9; j++)
if(j%difficulty == 0)
rowLastHeroRemoving(j);
widget->recievePuzzle(numbers);
}
int Generator::startGeneration(int row)
{
counter++;
for(int I = row; I < 9; I++)
{
for(int J = 0; J < 9; J++)
{
removeVariantsForCell(I, J);
if(variants.empty())
{
if (counter == 5)
{
counter = 0;
for(int n = 0; n < 9; n++)
{
numbers[I][n] = 0;
numbers[I-1][n] = 0;
}
startGeneration(I-1);
}
else
startGeneration(I);
return 0;
}
else
numbers[I][J] = possibleVariant();
}
}
counter = 0;
return 1;
}
void Generator::fillVariants()
{
variants.clear();
for(int i = 1; i <= 9; i++)
variants.push_back(i);
}
int Generator::possibleVariant()
{
return variants[rand()%variants.size()];
}
void Generator::removeVariant(int v)
{
for(int i = 0; i < variants.size(); i++)
if(variants[i] == v)
variants.erase(variants.begin()+i);
}
void Generator::removeVariantsForCell(int I, int J)
{
fillVariants();
for(int i = 0; i < 9; i++)
removeVariant(numbers[i][J]);
for(int j = 0; j < 9; j++)
removeVariant(numbers[I][j]);
for(int i = I-(I%3); i < (I/3)*3+3; i++)
for(int j = J-(J%3); j < (J/3)*3+3; j++)
removeVariant(numbers[i][j]);
}
int Generator::oneVariantRemoving()
{
int I = rand()%9;
int J = rand()%9;
int temp = numbers[I][J];
numbers[I][J] = 0;
for(int i = 0 ; i < 9; i++)
for(int j = 0 ; j < 9; j++)
{
fillVariants();
removeVariantsForCell(i, j);
if(variants.size() > 1)
{
numbers[I][J] = temp;
counter++;
}
}
if(counter > 100)
{
counter = 0;
return 0;
}
oneVariantRemoving();
return 1;
}
int Generator::rowLastHeroRemoving(int I)
{
int J = rand()%9;
while(numbers[I][J] == 0)
J = rand()%9;
int oldValue = numbers[I][J];
numbers[I][J] = 0;
removeVariantsForCell(I, J);
buffer.clear();
buffer = variants;
for(int j = 0; j < 9; j++)
{
if(j != J && numbers[I][j] == 0)
{
QVector<int> temp;
setWrongVariantsForCell(I, j);
std::set_intersection(buffer.begin(), buffer.end(),
wrongVariants.begin(), wrongVariants.end(),
std::back_inserter(temp));
buffer = temp;
}
}
if(buffer.size() != 1)
{
numbers[I][J] = oldValue;
counter++;
if(counter > 100)
{
counter = 0;
return 0;
}
}
else
counter = 0;
rowLastHeroRemoving(I);
return 1;
}
int Generator::columnLastHeroRemoving(int J)
{
int I = rand()%9;
while(numbers[I][J] == 0)
I = rand()%9;
int oldValue = numbers[I][J];
numbers[I][J] = 0;
removeVariantsForCell(I, J);
buffer.clear();
buffer = variants;
for(int i = 0; i < 9; i++)
{
if(i != I && numbers[i][J] == 0)
{
QVector<int> temp;
setWrongVariantsForCell(i, J);
std::set_intersection(buffer.begin(), buffer.end(),
wrongVariants.begin(), wrongVariants.end(),
std::back_inserter(temp));
buffer = temp;
}
}
if(buffer.size() != 1)
{
numbers[I][J] = oldValue;
counter++;
if(counter > 100)
{
counter = 0;
return 0;
}
}
else
counter = 0;
columnLastHeroRemoving(J);
return 1;
}
void Generator::setWrongVariantsForCell(int I, int J)
{
removeVariantsForCell(I, J);
QVector<int> temp = variants;
fillVariants();
wrongVariants.clear();
std::set_difference(variants.begin(), variants.end(),
temp.begin(), temp.end(),
std::inserter(wrongVariants,
wrongVariants.begin()));
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n, m;
cin >> n >> m;
vector<int> v(n+2);
for(int i=0; i<m; i++){
int l, r;
cin >> l >> r;
v[l]++;
v[r+1]--;
}
for(int i=0; i<n; i++) v[i+1] += v[i];
int ans = 0;
for(int i=0; i<v.size(); i++) ans += (v[i] == m);
cout << ans << endl;
}
|
#pragma once
#include "Mesh.h"
#include <vector>
#include <glm\glm.hpp>
using namespace std;
void generatePlaneData(vector<Vertex>& vertices, vector<unsigned int>& indices, unsigned int width, unsigned int length)
{
// right now we are hard coded at 8 floats per vertex and 6 vertices per cell of the plane
const int VERTICES_PER_CELL = 6;
const Vertex CELL_VERTICES[VERTICES_PER_CELL] = {
Vertex {
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f),
glm::vec2(0.0f, 0.0f)
},
Vertex {
glm::vec3(0.0f, 0.0f, 1.0f),
glm::vec3(0.0f, 1.0f, 0.0f),
glm::vec2(0.0f, 1.0f)
},
Vertex {
glm::vec3(1.0f, 0.0f, 1.0f),
glm::vec3(0.0f, 1.0f, 0.0f),
glm::vec2(1.0f, 1.0f)
},
Vertex {
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f),
glm::vec2(0.0f, 0.0f)
},
Vertex {
glm::vec3(1.0f, 0.0f, 1.0f),
glm::vec3(0.0f, 1.0f, 0.0f),
glm::vec2(1.0f, 1.0f)
},
Vertex {
glm::vec3(1.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f),
glm::vec2(1.0f, 0.0f)
}
};
// Use these offsets to center the plane on the origin, instead of having it's corner there
const float Z_OFF = (float)length / 2.0f * -1.0f;
const float X_OFF = (float)width / 2.0f * -1.0f;
unsigned int curIndex = 0;
for (unsigned int z = 0; z < length; z++)
{
for (unsigned int x = 0; x < width; x++)
{
for (unsigned int v = 0; v < VERTICES_PER_CELL; v++)
{
Vertex vert = CELL_VERTICES[v];
vert.Position += glm::vec3((float)x + X_OFF, 0.0f, (float)z + Z_OFF);
vertices.push_back(vert);
indices.push_back(curIndex++);
}
}
}
}
|
/* XMRig
* Copyright 2010 Jeff Garzik <jgarzik@pobox.com>
* Copyright 2012-2014 pooler <pooler@litecoinpool.org>
* Copyright 2014 Lucas Jones <https://github.com/lucasjones>
* Copyright 2014-2016 Wolf9466 <https://github.com/OhGodAPet>
* Copyright 2016 Jay D Dee <jayddee246@gmail.com>
* Copyright 2017-2018 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
* Copyright 2018-2020 SChernykh <https://github.com/SChernykh>
* Copyright 2016-2020 XMRig <https://github.com/xmrig>, <support@xmrig.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "base/net/stratum/NetworkState.h"
#include "3rdparty/rapidjson/document.h"
#include "base/io/log/Log.h"
#include "base/kernel/interfaces/IClient.h"
#include "base/kernel/interfaces/IStrategy.h"
#include "base/net/stratum/Job.h"
#include "base/net/stratum/Pool.h"
#include "base/net/stratum/SubmitResult.h"
#include "base/tools/Chrono.h"
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <uv.h>
namespace xmrig {
inline static void printCount(uint64_t accepted, uint64_t rejected)
{
float percent = 100.0;
int color = 2;
if (!accepted) {
percent = 0.0;
color = 1;
}
else if (rejected) {
percent = static_cast<float>(accepted) / (accepted + rejected) * 100.0;
color = 3;
}
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") CSI "1;3%dm%" PRIu64 CLEAR CSI "0;3%dm (%1.1f%%)", "accepted", color, accepted, color, percent);
if (rejected) {
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") RED_BOLD("%" PRIu64), "rejected", rejected);
}
}
inline static void printHashes(uint64_t accepted, uint64_t hashes)
{
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") CYAN_BOLD("%" PRIu64) " avg " CYAN("%1.0f"),
"pool-side hashes", hashes, static_cast<double>(hashes) / accepted);
}
inline static void printAvgTime(uint64_t time)
{
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") CSI "1;3%dm%1.1fs", "avg result time", (time < 10000 ? 3 : 2), time / 1000.0);
}
static void printDiff(uint64_t diff)
{
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") CYAN_BOLD("%s"), "difficulty", NetworkState::humanDiff(diff).c_str());
}
inline static void printDiff(size_t i, uint64_t diff, uint64_t hashes)
{
if (!diff) {
return;
}
const double effort = static_cast<double>(hashes) / diff * 100.0;
const double target = (i + 1) * 100.0;
const int color = effort > (target + 100.0) ? 1 : (effort > target ? 3 : 2);
Log::print("%3zu | %10s | " CSI "0;3%dm%8.2f" CLEAR " |", i + 1, NetworkState::humanDiff(diff).c_str(), color, effort);
}
inline static void printLatency(uint32_t latency)
{
if (!latency) {
return;
}
const int color = latency < 100 ? 2 : (latency > 500 ? 1 : 3);
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") CSI "1;3%dm%ums", "ping time", color, latency);
}
} // namespace xmrig
xmrig::NetworkState::NetworkState(IStrategyListener *listener) : StrategyProxy(listener)
{
}
#ifdef XMRIG_FEATURE_API
rapidjson::Value xmrig::NetworkState::getConnection(rapidjson::Document &doc, int version) const
{
using namespace rapidjson;
auto &allocator = doc.GetAllocator();
Value connection(kObjectType);
connection.AddMember("pool", StringRef(m_pool), allocator);
connection.AddMember("ip", m_ip.toJSON(), allocator);
connection.AddMember("uptime", connectionTime() / 1000, allocator);
connection.AddMember("uptime_ms", connectionTime(), allocator);
connection.AddMember("ping", latency(), allocator);
connection.AddMember("failures", m_failures, allocator);
connection.AddMember("tls", m_tls.toJSON(), allocator);
connection.AddMember("tls-fingerprint", m_fingerprint.toJSON(), allocator);
connection.AddMember("algo", m_algorithm.toJSON(), allocator);
connection.AddMember("diff", m_diff, allocator);
connection.AddMember("accepted", m_accepted, allocator);
connection.AddMember("rejected", m_rejected, allocator);
connection.AddMember("avg_time", avgTime() / 1000, allocator);
connection.AddMember("avg_time_ms", avgTime(), allocator);
connection.AddMember("hashes_total", m_hashes, allocator);
if (version == 1) {
connection.AddMember("error_log", Value(kArrayType), allocator);
}
return connection;
}
rapidjson::Value xmrig::NetworkState::getResults(rapidjson::Document &doc, int version) const
{
using namespace rapidjson;
auto &allocator = doc.GetAllocator();
Value results(kObjectType);
results.AddMember("diff_current", m_diff, allocator);
results.AddMember("shares_good", m_accepted, allocator);
results.AddMember("shares_total", m_accepted + m_rejected, allocator);
results.AddMember("avg_time", avgTime() / 1000, allocator);
results.AddMember("avg_time_ms", avgTime(), allocator);
results.AddMember("hashes_total", m_hashes, allocator);
Value best(kArrayType);
best.Reserve(m_topDiff.size(), allocator);
for (uint64_t i : m_topDiff) {
best.PushBack(i, allocator);
}
results.AddMember("best", best, allocator);
if (version == 1) {
results.AddMember("error_log", Value(kArrayType), allocator);
}
return results;
}
#endif
void xmrig::NetworkState::printConnection() const
{
if (!m_active) {
LOG_NOTICE(YELLOW_BOLD_S "no active connection");
return;
}
Log::print(MAGENTA_BOLD_S " - CONNECTION");
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") CYAN_BOLD("%s ") BLACK_BOLD("(%s) ") GREEN_BOLD("%s"),
"pool address", m_pool, m_ip.data(), m_tls.isNull() ? "" : m_tls.data());
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") WHITE_BOLD("%s"), "algorithm", m_algorithm.shortName());
printDiff(m_diff);
printLatency(latency());
Log::print(GREEN_BOLD(" * ") WHITE_BOLD("%-17s") CYAN_BOLD("%" PRIu64 "s"), "connection time", connectionTime() / 1000);
}
void xmrig::NetworkState::printResults() const
{
if (!m_hashes) {
LOG_NOTICE(YELLOW_BOLD_S "no results yet");
return;
}
Log::print(MAGENTA_BOLD_S " - RESULTS");
printCount(m_accepted, m_rejected);
printHashes(m_accepted, m_hashes);
printDiff(m_diff);
if (m_active && !m_latency.empty()) {
printAvgTime(avgTime());
}
Log::print(MAGENTA_BOLD_S " - TOP 10");
Log::print(WHITE_BOLD_S " # | DIFFICULTY | EFFORT %% |");
for (size_t i = 0; i < m_topDiff.size(); ++i) {
printDiff(i, m_topDiff[i], m_hashes);
}
}
const char *xmrig::NetworkState::scaleDiff(uint64_t &diff)
{
if (diff >= 100000000000) {
diff /= 1000000000;
return "G";
}
if (diff >= 100000000) {
diff /= 1000000;
return "M";
}
if (diff >= 1000000) {
diff /= 1000;
return "K";
}
return "";
}
std::string xmrig::NetworkState::humanDiff(uint64_t diff)
{
const char *scale = scaleDiff(diff);
return std::to_string(diff) + scale;
}
void xmrig::NetworkState::onActive(IStrategy *strategy, IClient *client)
{
snprintf(m_pool, sizeof(m_pool) - 1, "%s:%d", client->pool().host().data(), client->pool().port());
m_ip = client->ip();
m_tls = client->tlsVersion();
m_fingerprint = client->tlsFingerprint();
m_active = true;
m_connectionTime = Chrono::steadyMSecs();
StrategyProxy::onActive(strategy, client);
}
void xmrig::NetworkState::onJob(IStrategy *strategy, IClient *client, const Job &job, const rapidjson::Value ¶ms)
{
m_algorithm = job.algorithm();
m_diff = job.diff();
StrategyProxy::onJob(strategy, client, job, params);
}
void xmrig::NetworkState::onPause(IStrategy *strategy)
{
if (!strategy->isActive()) {
stop();
}
StrategyProxy::onPause(strategy);
}
void xmrig::NetworkState::onResultAccepted(IStrategy *strategy, IClient *client, const SubmitResult &result, const char *error)
{
add(result, error);
StrategyProxy::onResultAccepted(strategy, client, result, error);
}
uint32_t xmrig::NetworkState::latency() const
{
const size_t calls = m_latency.size();
if (calls == 0) {
return 0;
}
auto v = m_latency;
std::nth_element(v.begin(), v.begin() + calls / 2, v.end());
return v[calls / 2];
}
uint64_t xmrig::NetworkState::avgTime() const
{
if (m_latency.empty()) {
return 0;
}
return connectionTime() / m_latency.size();
}
uint64_t xmrig::NetworkState::connectionTime() const
{
return m_active ? ((Chrono::steadyMSecs() - m_connectionTime)) : 0;
}
void xmrig::NetworkState::add(const SubmitResult &result, const char *error)
{
if (error) {
m_rejected++;
return;
}
m_accepted++;
m_hashes += result.diff;
const size_t ln = m_topDiff.size() - 1;
if (result.actualDiff > m_topDiff[ln]) {
m_topDiff[ln] = result.actualDiff;
std::sort(m_topDiff.rbegin(), m_topDiff.rend());
}
m_latency.push_back(result.elapsed > 0xFFFF ? 0xFFFF : static_cast<uint16_t>(result.elapsed));
}
void xmrig::NetworkState::stop()
{
m_active = false;
m_diff = 0;
m_ip = nullptr;
m_tls = nullptr;
m_fingerprint = nullptr;
m_failures++;
m_latency.clear();
}
|
#if OCAML_MINOR >= 8
let attributeTxt = (x: Parsetree.attribute) => x.attr_name.txt;
#else
let attributeTxt = (x: Parsetree.attribute) => fst(x).txt;
#endif
#if OCAML_MINOR >= 8
let mkAttribute = (~loc, ~txt) => {
Parsetree.attr_loc: loc,
attr_name: Location.{loc, txt},
attr_payload: Parsetree.PStr([Ast_helper.Str.eval(Ast_helper.Exp.constant(Pconst_string("-3", None)))]),
};
#else
let mkAttribute = (~loc, ~txt) => (
Location.{loc, txt},
Parsetree.PStr([Ast_helper.Str.eval(Ast_helper.Exp.constant(Pconst_string("-3", None)))]),
);
#endif
|
// OgreEditorView.cpp : implementation of the COgreEditorView class
//
#include "stdafx.h"
#include "OgreEditor.h"
#include "OgreEditorView.h"
#include "Editor.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#endif
// COgreEditorView
IMPLEMENT_DYNCREATE(COgreEditorView, CView)
BEGIN_MESSAGE_MAP(COgreEditorView, CView)
ON_WM_SIZE()
ON_WM_DESTROY()
ON_WM_KEYDOWN()
ON_WM_KEYUP()
ON_WM_MOUSEMOVE()
ON_WM_MOUSEWHEEL()
ON_WM_LBUTTONDOWN()
ON_WM_LBUTTONUP()
ON_WM_RBUTTONDOWN()
ON_WM_RBUTTONUP()
ON_WM_MBUTTONDOWN()
ON_WM_MBUTTONUP()
ON_WM_SETFOCUS()
ON_WM_KILLFOCUS()
ON_WM_ERASEBKGND()
END_MESSAGE_MAP()
// COgreEditorView construction/destruction
COgreEditorView::COgreEditorView() : m_bInit(false)
{
// TODO: add construction code here
}
COgreEditorView::~COgreEditorView()
{
}
BOOL COgreEditorView::OnEraseBkgnd(CDC* pDC)
{
// "Tile" bitmap (see demo for actual code)
return TRUE; // tell Windows we handled it
}
BOOL COgreEditorView::PreCreateWindow(CREATESTRUCT& cs)
{
// TODO: Modify the Window class or styles here by modifying
// the CREATESTRUCT cs
return CView::PreCreateWindow(cs);
}
void COgreEditorView::OnInitialUpdate()
{
CView::OnInitialUpdate();
if ( !m_bInit )
{
m_bInit = true;
// TODO: Add your specialized code here and/or call the base class
CRect rect;
GetClientRect( rect );
GetEditor()->Create( GetSafeHwnd(), rect.Width(), rect.Height() );
//tooltip = new CBitmapTooltip(CRect(300,300,0,0));
//tooltip->ShowWindow(SW_SHOW);
}
}
// COgreEditorView drawing
void COgreEditorView::OnDraw(CDC* /*pDC*/)
{
// TODO: add draw code for native data here
}
void COgreEditorView::OnDestroy()
{
GetEditor()->Destroy();
CView::OnDestroy();
}
// COgreEditorView diagnostics
#ifdef _DEBUG
void COgreEditorView::AssertValid() const
{
CView::AssertValid();
}
void COgreEditorView::Dump(CDumpContext& dc) const
{
CView::Dump(dc);
}
#endif //_DEBUG
// COgreEditorView message handlers
void COgreEditorView::OnSize(UINT nType, int cx, int cy)
{
CView::OnSize(nType, cx, cy);
CRect rect;
GetClientRect(&rect);
GetEditor()->Resize( rect.Width(), rect.Height() );
}
void COgreEditorView::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags)
{
CView::OnKeyDown(nChar, nRepCnt, nFlags);
GetEditor()->OnKeyDown(nChar,nRepCnt,nFlags);
}
void COgreEditorView::OnKeyUp(UINT nChar, UINT nRepCnt, UINT nFlags)
{
CView::OnKeyUp(nChar, nRepCnt, nFlags);
GetEditor()->OnKeyUp(nChar,nRepCnt,nFlags);
}
void COgreEditorView::OnLButtonDown(UINT nFlags, CPoint point)
{
CView::OnLButtonDown(nFlags, point);
GetEditor()->OnLButtonDown(nFlags,point);
}
void COgreEditorView::OnLButtonUp(UINT nFlags, CPoint point)
{
CView::OnLButtonUp(nFlags, point);
GetEditor()->OnLButtonUp(nFlags,point);
}
void COgreEditorView::OnMButtonDown(UINT nFlags, CPoint point)
{
CView::OnMButtonDown(nFlags, point);
}
void COgreEditorView::OnMButtonUp(UINT nFlags, CPoint point)
{
CView::OnMButtonUp(nFlags, point);
}
void COgreEditorView::OnMouseMove(UINT nFlags, CPoint point)
{
CView::OnMouseMove(nFlags, point);
GetEditor()->OnMouseMove(nFlags,point);
}
BOOL COgreEditorView::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
GetEditor()->OnMouseWheel( nFlags, zDelta, pt);
return CView::OnMouseWheel( nFlags, zDelta, pt);
}
void COgreEditorView::OnRButtonDown(UINT nFlags, CPoint point)
{
GetEditor()->OnRButtonDown(nFlags,point);
CView::OnRButtonDown(nFlags, point);
}
void COgreEditorView::OnRButtonUp(UINT nFlags, CPoint point)
{
GetEditor()->OnRButtonUp(nFlags,point);
CView::OnRButtonUp(nFlags, point);
}
void COgreEditorView::OnSetFocus(CWnd* pOldWnd)
{
CView::OnSetFocus(pOldWnd);
}
void COgreEditorView::OnKillFocus(CWnd* pOldWnd)
{
CView::OnKillFocus(pOldWnd);
}
|
/**
\file gabaritoGerador.cpp
\author UnBeatables
\name gabaritoGerador
*/
#include "opencv2/opencv.hpp"
#include <iostream>
#include <stdlib.h>
#include <fstream>
#include <iterator>
#include <string>
#include <vector>
using namespace std;
using namespace cv;
vector<int> posX, posY;
bool flag = false;
/**
\brief Put in the vectors posX and posY the coodinates of the mouse click if the left button is pressed or the value -1, which means there is no ball in the frame, if the right button is pressed.
\param event can be either left button of the mouse click or right button of the mouse click.
*/
void CallBackFunc(int event, int x, int y, int flags, void* userdata)
{
if ( event == EVENT_LBUTTONDOWN )
{
cout << "Left button of the mouse is clicked - position (" << x << ", " << y << ")" << endl;
flag = true;
posX.push_back(x);
posY.push_back(y);
}
else if ( event == EVENT_RBUTTONDOWN )
{
cout << "Right button of the mouse is clicked - position (" << x << ", " << y << ")" << endl;
flag = true;
posX.push_back(-1);
posY.push_back(-1);
}
}
/**
\brief Receive a video and create a file containing the real position of the center of the ball defined by the mouse click.
\param argv[1] Name of the input file (video), if the input is the web camera, pass 0 instead of the video file name.
\param argv[2] Number of frames to skip to achieve the desired fps.
\param argv[3] Name of the output file, which is a type .txt that contains the position of the center of the ball in each frame.
*/
int main(int argc, char *argv[]){ //argv == argv[0], *(argv+1) == argv[1]
int skip, fps; ///< skip is the number of frames to skip at the video and fps is the resulting fps.
// Create a VideoCapture object and open the input file
// If the input is the web camera, pass 0 instead of the video file name
VideoCapture cap(argv[1]);
//Get the video frame rate
fps = cap.get(CV_CAP_PROP_FPS);
skip = atoi(argv[2]);
cout << "SKIP: " << skip << endl;
// Check if camera opened successfully
if(!cap.isOpened()){
cout << "Error opening video stream or file" << endl;
return -1;
}
while(1){
Mat frame;
// Capture frame-by-frame in the specified frame rate fps_new
cap >> frame;
// If the frame is empty, break immediately
if (frame.empty())
break;
//Create a window
namedWindow("Frame", 1);
setMouseCallback("Frame", CallBackFunc, NULL);
// Display the resulting frame
imshow("Frame", frame );
// Press ESC on keyboard to exit
// Wait 1000/fps_new ms
// char c=(char)waitKey(fr_period);
// if(c==27)
// break;
while(!flag){
char c=(char)waitKey(50);
if(c==27){
posX.push_back(-1);
posY.push_back(-1);
break;
}
}
flag = false;
for(int i=0; i < skip; i++)
cap >> frame;
}
vector<int>::iterator itX, itY;
ofstream myfile(argv[3]);
//Saves SKIP
myfile << skip << endl;
if(myfile.is_open()){
itX = posX.begin();
itY = posY.begin();
while(itX!=posX.end()){
myfile << (*itX) << endl;
myfile << (*itY) << endl;
itX++;
itY++;
}
myfile.close();
}
else
cout << "Not possible to open the file." << endl;
// When everything is done, release the video capture object
cap.release();
// Closes all the frames
destroyAllWindows();
return 0;
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 1995-2011 Opera Software AS. All rights reserved.
*
* This file is part of the Opera web browser.
* It may not be distributed under any circumstances.
*/
#include "core/pch.h"
#include "adjunct/quick/widgets/PagebarButton.h"
#include "adjunct/quick/widgets/OpPagebar.h"
#include "adjunct/quick/widgets/OpThumbnailPagebar.h"
#include "adjunct/quick/models/DesktopHistoryModel.h"
#include "adjunct/quick/models/DesktopGroupModelItem.h"
#include "adjunct/quick/Application.h"
#include "adjunct/quick/menus/DesktopMenuHandler.h"
#include "adjunct/quick/WindowCommanderProxy.h"
#include "adjunct/quick/windows/DocumentDesktopWindow.h"
#include "adjunct/quick/hotlist/HotlistManager.h"
#include "adjunct/quick/widgets/OpToolbarMenuButton.h"
#include "adjunct/quick/windows/BrowserDesktopWindow.h"
#include "adjunct/quick/widgets/OpTabGroupButton.h"
#include "adjunct/quick/managers/opsetupmanager.h"
#include "adjunct/quick/quick-widget-names.h"
#include "modules/display/vis_dev.h"
#include "modules/dragdrop/dragdrop_manager.h"
#include "modules/inputmanager/inputmanager.h"
#include "modules/locale/oplanguagemanager.h"
#include "modules/prefs/prefsmanager/collections/pc_ui.h"
#include "modules/skin/OpSkinManager.h"
#include "modules/util/opswap.h"
#include "modules/widgets/WidgetContainer.h"
#ifdef VEGA_OPPAINTER_SUPPORT
#include "adjunct/quick/managers/AnimationManager.h"
#endif
namespace PagebarButtonConstants
{
const unsigned long TitleUpdateDelay = 300;
const int WindowLimitThreshold = 4;
const int DragThreshold = 3;
// Thresholds relative to the size of the button they affect
struct Fraction
{
int num;
int denom;
};
const Fraction MoveThreshold = { 1, 5 };
const Fraction StackThreshold = { 2, 3 };
const Fraction SwapGroupThreshold = { 4, 5 };
const Fraction ExitGroupThreshold = { 5, 6 };
};
#ifdef _DEBUG // Safeguard to avoid printfs in release
// Turn on to get debug output for group number
//#define GROUP_NUMBER_DEBUGGING
//#define TAB_DRAG_DEBUGGING
#endif // _DEBUG
/***********************************************************************************
**
** PagebarButton
**
***********************************************************************************/
OP_STATUS PagebarButton::Construct(PagebarButton** obj, DesktopWindow* desktop_window)
{
OpAutoPtr<PagebarButton> new_button (OP_NEW(PagebarButton, (desktop_window)));
if (!new_button.get())
return OpStatus::ERR_NO_MEMORY;
RETURN_IF_ERROR(new_button->InitPagebarButton());
*obj = new_button.release();
return OpStatus::OK;
}
PagebarButton::PagebarButton(DesktopWindow* desktop_window)
: OpPagebarItem(desktop_window->GetID(), 0)
, m_maximize_button(NULL)
, m_minimize_button(NULL)
, m_indicator_button(NULL)
, m_old_min_width(0)
, m_old_max_width(0)
, m_desktop_window(desktop_window)
, m_delayed_title_update_in_progress(FALSE)
, m_is_move_window_button(FALSE)
, m_is_moving_window(FALSE)
, m_use_hover_stack_overlay(FALSE)
, m_is_compact_button(FALSE)
, m_original_group_number(-1)
, m_between_groups(FALSE)
, m_mouse_move_dragging(FALSE)
, m_can_start_drag(FALSE)
, m_show_page_loading(false)
, m_is_delayed_activation_scheduled(false)
{
if (desktop_window)
{
desktop_window->AddListener(this);
}
SetOnMoveWanted(TRUE);
}
PagebarButton::~PagebarButton()
{
m_activation_timer.Stop();
if (m_desktop_window)
{
m_desktop_window->RemoveListener(this);
if (m_desktop_window->GetType() == WINDOW_TYPE_DOCUMENT)
{
DocumentDesktopWindow *win = static_cast<DocumentDesktopWindow *>(m_desktop_window);
win->RemoveDocumentWindowListener(this);
}
}
}
OP_STATUS PagebarButton::InitPagebarButton()
{
SetEllipsis(g_pcui->GetIntegerPref(PrefsCollectionUI::EllipsisInCenter) == 1 ? ELLIPSIS_CENTER : ELLIPSIS_END );
RETURN_IF_ERROR(OpButton::Construct(&m_close_button, OpButton::TYPE_CUSTOM));
m_close_button->SetName(WIDGET_NAME_PAGEBAR_BUTTON_CLOSE);
AddChild(m_close_button);
m_indicator_button = OP_NEW(OpIndicatorButton, (m_desktop_window, OpIndicatorButton::RIGHT));
RETURN_OOM_IF_NULL(m_indicator_button);
AddChild(m_indicator_button);
RETURN_IF_ERROR(m_indicator_button->Init("Tabbar Indicator Skin"));
m_indicator_button->SetIconState(OpIndicatorButton::CAMERA, OpIndicatorButton::ACTIVE);
m_indicator_button->SetIconState(OpIndicatorButton::GEOLOCATION, OpIndicatorButton::ACTIVE);
m_indicator_button->SetVisibility(FALSE);
if(m_desktop_window)
{
OpInputAction *action = OP_NEW(OpInputAction, (OpInputAction::ACTION_CLOSE_WINDOW));
RETURN_OOM_IF_NULL(action);
action->SetActionData(m_desktop_window->GetID());
m_close_button->GetBorderSkin()->SetImage("Pagebar Close Button Skin");
m_close_button->GetBorderSkin()->SetForeground(TRUE);
m_close_button->SetAction(action);
SetCloseButtonTooltip();
if(m_desktop_window->GetType() == WINDOW_TYPE_DOCUMENT)
{
DocumentDesktopWindow *win = static_cast<DocumentDesktopWindow *>(m_desktop_window);
win->AddDocumentWindowListener(this);
}
}
return g_main_message_handler->SetCallBack(this, MSG_QUICK_UPDATE_PAGEBAR_BUTTON_TITLE, 0);
}
void PagebarButton::SetShowPageLoading(bool show_page_loading)
{
m_show_page_loading = show_page_loading;
}
void PagebarButton::SetIsMoveWindowButton()
{
m_is_move_window_button = TRUE;
RETURN_VOID_IF_ERROR(OpButton::Construct(&m_maximize_button, OpButton::TYPE_CUSTOM));
m_maximize_button->SetName(WIDGET_NAME_PAGEBAR_BUTTON_MAXIMIZE);
AddChild(m_maximize_button);
if(m_desktop_window)
{
OpInputAction *action = OP_NEW(OpInputAction, (OpInputAction::ACTION_MAXIMIZE_PAGE));
if (!action)
return;
action->SetActionData(m_desktop_window->GetID());
m_maximize_button->GetBorderSkin()->SetImage("Pagebar Maximize Button Skin");
m_maximize_button->GetBorderSkin()->SetForeground(TRUE);
m_maximize_button->SetAction(action);
// Set maximize button tooltip
OpString tooltip_string, fmt_string, shortcut_string;
g_input_manager->GetShortcutStringFromAction(action, shortcut_string, this);
if (OpStatus::IsSuccess(g_languageManager->GetString(Str::M_PAGE_MAXIMIZE, tooltip_string)))
{
if (shortcut_string.IsEmpty())
fmt_string.Set(tooltip_string);
else
fmt_string.AppendFormat(UNI_L("%s (%s)"), tooltip_string.CStr(), shortcut_string.CStr());
m_maximize_button->GetAction()->GetActionInfo().SetTooltipText(fmt_string.CStr());
}
}
RETURN_VOID_IF_ERROR(OpButton::Construct(&m_minimize_button, OpButton::TYPE_CUSTOM));
m_minimize_button->SetName(WIDGET_NAME_PAGEBAR_BUTTON_MINIMIZE);
AddChild(m_minimize_button);
if(m_minimize_button)
{
OpInputAction *action = OP_NEW(OpInputAction, (OpInputAction::ACTION_MINIMIZE_PAGE));
if (!action)
return;
action->SetActionData(m_desktop_window->GetID());
m_minimize_button->GetBorderSkin()->SetImage("Pagebar Minimize Button Skin");
m_minimize_button->GetBorderSkin()->SetForeground(TRUE);
m_minimize_button->SetAction(action);
// Set minimize button tooltip
OpString tooltip_string, fmt_string, shortcut_string;
g_input_manager->GetShortcutStringFromAction(action, shortcut_string, this);
if (OpStatus::IsSuccess(g_languageManager->GetString(Str::M_MINIMIZE_PAGE, tooltip_string)))
{
if (shortcut_string.IsEmpty())
fmt_string.Set(tooltip_string);
else
fmt_string.AppendFormat(UNI_L("%s (%s)"), tooltip_string.CStr(), shortcut_string.CStr());
m_minimize_button->GetAction()->GetActionInfo().SetTooltipText(fmt_string.CStr());
}
}
}
void PagebarButton::UpdateLockedTab()
{
BOOL is_locked = IsLockedByUser();
BOOL is_closable = IsClosableByUser();
BOOL show_close_button = TRUE;
BOOL need_relayout = FALSE;
if (is_locked)
show_close_button = TRUE; // but with a "pinned" image
else if (!is_closable)
show_close_button = FALSE;
else
show_close_button = !GetParent()->IsOfType(WIDGET_TYPE_PAGEBAR) || ((OpPagebar*)GetParent())->IsCloseButtonVisible(m_desktop_window, FALSE);
if(IsCompactButton())
{
m_close_button->SetVisibility(FALSE);
}
else
{
need_relayout = m_close_button->IsVisible() && !show_close_button;
m_close_button->SetVisibility(show_close_button);
m_close_button->GetBorderSkin()->SetImage(is_locked ? "Pagebar Locked Button Skin" : "Pagebar Close Button Skin");
// ignore mouse events so they are handled by PagebarButton instead
m_close_button->SetIgnoresMouse(is_locked);
if(is_locked)
{
m_close_button->GetAction()->GetActionInfo().SetTooltipText(UNI_L(""));
}
else
{
SetCloseButtonTooltip();
}
}
if (need_relayout)
Relayout();
}
void PagebarButton::UpdateCompactStatus()
{
if(m_desktop_window)
{
OpPagebar *pagebar = GetPagebar();
BOOL is_compact = m_desktop_window->IsLockedByUser() && !IsGrouped() && pagebar && pagebar->IsHorizontal();
SetIsCompactButton(is_compact);
}
}
void PagebarButton::SetUseHoverStackOverlay(BOOL use_hover_stack_overlay)
{
if (m_use_hover_stack_overlay != use_hover_stack_overlay)
{
m_use_hover_stack_overlay = use_hover_stack_overlay;
InvalidateAll();
}
}
void PagebarButton::SetHidden(BOOL is_hidden)
{
if (!GetParent())
return;
if (is_hidden == IsHidden())
return;
if (g_animation_manager->GetEnabled() && !GetAnimation())
{
if (!is_hidden) // Done on animation completion
OpButton::SetHidden(is_hidden);
OpPagebar *pagebar = GetPagebar();
bool is_horizontal = pagebar ? !!pagebar->IsHorizontal() : true;
QuickAnimationWidget *animation = OP_NEW(QuickAnimationWidget, (this, is_hidden ? ANIM_MOVE_SHRINK : ANIM_MOVE_GROW, is_horizontal));
if (animation)
{
animation->SetHideOnCompletion(!!is_hidden);
g_animation_manager->startAnimation(animation, ANIM_CURVE_SLOW_DOWN, TAB_GROUP_ANIMATION_DURATION, TRUE);
}
}
else
{
if (GetAnimation())
{
GetAnimation()->SetHideOnCompletion(FALSE);
if (!is_hidden && GetAnimation()->GetMoveType() == ANIM_MOVE_SHRINK)
SetAnimation(NULL);
}
OpButton::SetHidden(is_hidden);
InvalidateAll();
parent->Relayout(TRUE, FALSE);
}
}
BOOL PagebarButton::IsHiddenOrHiding()
{
if (GetAnimation())
return IsHidden() || GetAnimation()->GetHideOnCompletion();
return IsHidden();
}
void PagebarButton::OnShow(BOOL show)
{
SetFixedMinMaxWidth((show && m_indicator_button->IsVisible()) || IsCompactButton());
UpdateMinAndMaxWidth();
if (show)
Relayout();
}
void PagebarButton::OnRemoving()
{
OpTabGroupButton* group_button = GetTabGroupButton();
if (group_button)
{
group_button->RefreshIndicatorState();
}
}
void PagebarButton::OnDeleted()
{
g_main_message_handler->UnsetCallBack(this, MSG_QUICK_UPDATE_PAGEBAR_BUTTON_TITLE, 0);
OpButton::OnDeleted();
}
void PagebarButton::HandleCallback(OpMessage msg, MH_PARAM_1 par1, MH_PARAM_2 par2)
{
if(msg == MSG_QUICK_UPDATE_PAGEBAR_BUTTON_TITLE && m_desktop_window)
{
#if defined(GROUP_NUMBER_DEBUGGING) && defined(_DEBUG)
OpString debug_title, debug_title_format;
debug_title_format.Set(UNI_L("%d "));
debug_title_format.Append(m_desktop_window->GetTitle());
debug_title.AppendFormat(debug_title_format, GetGroupNumber());
SetTitle(debug_title);
#else
SetTitle(m_desktop_window->GetTitle());
#endif // _DEBUG && GROUP_NUMBER_DEBUGGING
m_delayed_title_update_in_progress = FALSE;
}
else
{
// we didn't recognize the message, pass it on
OpButton::HandleCallback(msg, par1, par2);
}
}
void PagebarButton::OnStartLoading(DocumentDesktopWindow* document_window)
{
if (document_window->HasURLChanged())
SetShowPageLoading(true);
const OpWidgetImage *image = m_desktop_window->GetWidgetImage();
if(image)
{
GetIconSkin()->SetWidgetImage(image);
}
}
void PagebarButton::OnLoadingFinished(DocumentDesktopWindow* document_window, OpLoadingListener::LoadingFinishStatus status, BOOL was_stopped_by_user)
{
SetShowPageLoading(false);
UpdateTextAndIcon(true, true, true);
}
void PagebarButton::OnAuthenticationRequired(OpWindowCommander* commander, OpAuthenticationCallback* callback)
{
SetShowPageLoading(false);
UpdateTextAndIcon(true, true, true);
}
BOOL PagebarButton::IsDocumentLoading()
{
if(GetDesktopWindow() && GetDesktopWindow()->GetType() == WINDOW_TYPE_DOCUMENT)
{
DocumentDesktopWindow *win = static_cast<DocumentDesktopWindow *>(GetDesktopWindow());
return win->IsLoading();
}
return FALSE;
}
void PagebarButton::UpdateTextAndIcon(bool update_icon, bool update_text, bool delay_update)
{
bool update_text_now = false;
if(update_text)
{
if(delay_update)
{
// only delay update if we already have a title
OpString old_title;
GetTitle(old_title);
if(old_title.HasContent())
{
if(!m_delayed_title_update_in_progress)
{
m_delayed_title_update_in_progress = TRUE;
g_main_message_handler->PostDelayedMessage(MSG_QUICK_UPDATE_PAGEBAR_BUTTON_TITLE, (MH_PARAM_1)this, (MH_PARAM_2)0, PagebarButtonConstants::TitleUpdateDelay);
}
}
else
{
update_text_now = true;
}
}
else
{
update_text_now = true;
}
}
if(update_text_now && m_desktop_window)
{
SetTitle(m_desktop_window->GetTitle());
}
if(update_icon && !m_show_page_loading)
{
BOOL show_icon = ShouldShowFavicon();
if(show_icon && ShouldUpdateIcon() && m_desktop_window)
{
const OpWidgetImage *image = m_desktop_window->GetWidgetImage();
if(g_skin_manager->GetOptionValue("Inverted Pagebar Icons", 0))
{
OpString8 image_name;
image_name.Set(image->GetImage());
if(image_name.FindI(" Inverted") == KNotFound)
{
image_name.Append(" Inverted");
}
if(g_skin_manager->GetSkinElement(image_name.CStr()))
{
GetIconSkin()->SetImage(image_name.CStr());
}
else
{
GetIconSkin()->SetWidgetImage(image);
GetIconSkin()->SetRestrictImageSize(TRUE);
}
}
else
{
GetIconSkin()->SetWidgetImage(image);
}
}
}
}
OpToolTipListener::TOOLTIP_TYPE PagebarButton::GetToolTipType(OpToolTip* tooltip)
{
// Check for the debug tooltip first
if (IsDebugToolTipActive())
return OpToolTipListener::TOOLTIP_TYPE_NORMAL;
DesktopGroupModelItem* group = GetGroup();
if (group && group->IsCollapsed())
return OpToolTipListener::TOOLTIP_TYPE_MULTIPLE_THUMBNAILS;
return OpToolTipListener::TOOLTIP_TYPE_THUMBNAIL;
}
void PagebarButton::GetToolTipThumbnailCollection(OpToolTip* tooltip, OpVector<OpToolTipThumbnailPair>& thumbnail_collection)
{
OpPagebar *pagebar = GetPagebar();
if(!pagebar)
{
return;
}
for(INT32 index = 0; index < pagebar->GetWidgetCount(); index++)
{
OpWidget *widget = pagebar->GetWidget(index);
if(widget && widget->IsOfType(WIDGET_TYPE_PAGEBAR_BUTTON))
{
PagebarButton *button = static_cast<PagebarButton *>(widget);
if(button->GetGroupNumber() == GetGroupNumber())
{
OpToolTipThumbnailPair *entry = OP_NEW(OpToolTipThumbnailPair, ());
if(entry)
{
DesktopWindow *window = button->GetDesktopWindow();
if(window)
{
entry->title.Set(window->GetTitle());
entry->thumbnail = window->GetThumbnailImage(THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, FALSE);
entry->is_fixed_image = window->HasFixedThumbnailImage();
entry->show_close_button = TRUE;
entry->window_id = window->GetID();
entry->active = window->IsActive();
}
thumbnail_collection.Add(entry);
}
}
}
}
}
void PagebarButton::GetToolTipText(OpToolTip* tooltip, OpInfoText& text)
{
// Check for the debug tooltip first
if (IsDebugToolTipActive())
OpWidget::GetToolTipText(tooltip, text);
else
m_desktop_window->GetToolTipText(tooltip, text);
}
BOOL PagebarButton::GetPreferredPlacement(OpToolTip* tooltip, OpRect &ref_rect, PREFERRED_PLACEMENT &placement)
{
if (parent->GetType() == WIDGET_TYPE_PAGEBAR)
{
ref_rect = GetRect(TRUE);
CoreView *view = GetWidgetContainer()->GetView();
OpPoint container_pos = view->ConvertToScreen(OpPoint());
ref_rect.OffsetBy(container_pos.x, container_pos.y);
OpPagebar *pagebar = (OpPagebar *) parent;
switch (pagebar->GetAlignment())
{
case OpBar::ALIGNMENT_LEFT:
placement = PREFERRED_PLACEMENT_RIGHT;
break;
case OpBar::ALIGNMENT_RIGHT:
placement = PREFERRED_PLACEMENT_LEFT;
break;
case OpBar::ALIGNMENT_BOTTOM:
placement = PREFERRED_PLACEMENT_TOP;
break;
default:
placement = PREFERRED_PLACEMENT_BOTTOM;
break;
};
return TRUE;
}
return FALSE;
}
void PagebarButton::SetCloseButtonTooltip()
{
OpInputAction *action = OP_NEW(OpInputAction, (OpInputAction::ACTION_CLOSE_PAGE));
if (!action)
return;
action->SetActionData(1);
OpString tooltip_string, fmt_string, shortcut_string;
g_input_manager->GetShortcutStringFromAction(action, shortcut_string, this);
if (OpStatus::IsSuccess(g_languageManager->GetString(Str::MI_IDM_MENU_PAGEBAR_REMOVE, tooltip_string)))
{
fmt_string.AppendFormat(UNI_L("%s (%s)"), tooltip_string.CStr(), shortcut_string.CStr());
m_close_button->GetAction()->GetActionInfo().SetTooltipText(fmt_string.CStr());
}
OP_DELETE(action);
}
void PagebarButton::OnMouseMove(const OpPoint &point)
{
OpButton::OnMouseMove(point);
if (!m_desktop_window)
return;
if (GetParentDesktopWindow())
{
OpInfoText text;
m_desktop_window->GetToolTipText(NULL, text);
GetParentDesktopWindow()->SetStatusText(text.GetStatusText());
}
if (m_is_moving_window)
OnMouseMoveWindow(point);
else if (parent->GetType() == WIDGET_TYPE_PAGEBAR)
OnMouseMoveOnPagebar(point);
}
void PagebarButton::OnMouseMoveWindow(const OpPoint& point)
{
INT32 x, y;
m_desktop_window->GetOuterPos(x, y);
x += point.x - m_mousedown_point.x;
y += point.y - m_mousedown_point.y;
OpWindow *parent_window = m_desktop_window->GetOpWindow()->GetParentWindow();
if (parent_window)
{
// Limit position within the parent so the user can move it back again.
UINT32 parent_w, parent_h;
parent_window->GetInnerSize(&parent_w, &parent_h);
x = MAX(x, -m_mousedown_point.x + PagebarButtonConstants::WindowLimitThreshold);
y = MAX(y, -m_mousedown_point.y + PagebarButtonConstants::WindowLimitThreshold);
x = MIN(x, (INT32)parent_w - m_mousedown_point.x - PagebarButtonConstants::WindowLimitThreshold);
y = MIN(y, (INT32)parent_h - m_mousedown_point.y - PagebarButtonConstants::WindowLimitThreshold);
}
m_desktop_window->SetOuterPos(x, y);
}
void PagebarButton::DelayedActivation(unsigned time)
{
m_activation_timer.Stop();
m_activation_timer.SetTimerListener(this);
m_activation_timer.Start(time);
m_is_delayed_activation_scheduled = true;
}
void PagebarButton::CancelDelayedActivation()
{
m_is_delayed_activation_scheduled = false;
m_activation_timer.Stop();
}
void PagebarButton::OnTimeOut(OpTimer* timer)
{
if (timer != &m_activation_timer)
{
OpPagebarItem::OnTimeOut(timer);
}
else if (m_is_delayed_activation_scheduled)
{
m_is_delayed_activation_scheduled = false;
DesktopDragObject* drag_object = static_cast<DesktopDragObject*>(g_drag_manager->GetDragObject());
if (drag_object)
drag_object->SetRestoreCaptureWhenLost(true);
Click();
if (drag_object)
drag_object->SetRestoreCaptureWhenLost(false);
}
}
bool PagebarButton::HasScheduledDelayedActivation()
{
return m_is_delayed_activation_scheduled;
}
void PagebarButton::OnMouseMoveOnPagebar(const OpPoint& point)
{
OpPagebar* pagebar = static_cast<OpPagebar*>(parent);
int delta = pagebar->IsHorizontal() ? point.x - m_mousedown_point.x : point.y - m_mousedown_point.y;
// Drag far enough out of pagebar, and we will start drag'n'drop instead!
if (!parent->GetBounds().InsetBy(-20).Contains(OpPoint(point.x + rect.x, point.y + rect.y)) ||
// Use old dragging for wrapping toolbar for now. Smooth dragging doesn't handle multiple lines.
(packed2.is_down && op_abs(delta) > PagebarButtonConstants::DragThreshold && pagebar->GetWrapping() == OpBar::WRAPPING_NEWLINE))
{
if (m_can_start_drag)
{
StopMoving();
pagebar->ClearAllHoverStackOverlays();
m_can_start_drag = FALSE;
StartDrag(point);
}
return;
}
// Start floating mode so we can move the button along the toolbar, overriding the layout.
if (packed2.is_down && !IsFloating() && op_abs(delta) > PagebarButtonConstants::DragThreshold && !g_drag_manager->IsDragging())
SetMouseMoveDragging(TRUE);
// Handle positioning of the button and reordering of tabs as we go.
if (m_mouse_move_dragging)
OnMouseMoveDragging(point, delta);
}
void PagebarButton::StartDrag(const OpPoint& point)
{
#ifdef _MACINTOSH_
// Widgets must not be deleted while handling the drag, since on Mac, this operation is tracked
// inside the StartDrag call and we may end up with the PagebarButton being deleted before we return.
LockDeletedWidgetsCleanup lock;
#endif
OpPagebar* const pagebar = static_cast<OpPagebar*>(parent);
pagebar->StartDrag(this, 0, point.x, point.y);
SetMouseMoveDragging(FALSE);
}
void PagebarButton::OnMouseMoveDragging(const OpPoint& point, int delta)
{
OpPagebar* const pagebar = static_cast<OpPagebar*>(parent);
// calculate new position
INT32 button_length = pagebar->IsHorizontal() ? rect.width : rect.height;
INT32 move_threshold = button_length * PagebarButtonConstants::MoveThreshold.num / PagebarButtonConstants::MoveThreshold.denom;
INT32 min_move = pagebar->GetPagebarButtonMin() - (move_threshold + 1);
INT32 max_move = pagebar->GetPagebarButtonMax() + (move_threshold + 1);
max_move -= button_length;
int x = rect.x;
int y = rect.y;
int& moving = pagebar->IsHorizontal() ? x : y;
moving += delta;
moving = MAX(moving, min_move);
moving = MIN(moving, max_move);
SetRect(OpRect(x, y, rect.width, rect.height));
pagebar->ClearAllHoverStackOverlays();
// force button to the front if it's not already
if(op_abs(delta) >= PagebarButtonConstants::DragThreshold && m_desktop_window && !m_desktop_window->IsActive())
{
Click();
}
// Hide tab group button while moving collapsed stacks
DesktopGroupModelItem* group = GetGroup();
if (group && group->IsCollapsed())
pagebar->HideGroupOpTabGroupButton(this, TRUE);
// Check which widgets we might be hovering over
OpRect nomargin = GetRectWithoutMargins();
PagebarButton* target_before = pagebar->GetPagebarButton(nomargin.TopLeft());
OpPoint delta_to_before = target_before ? rect.TopLeft() - target_before->rect.TopLeft() : OpPoint();
PagebarButton* target_after = pagebar->GetPagebarButton(nomargin.BottomRight() - OpPoint(1, 1));
OpPoint delta_to_after = target_after ? target_after->rect.BottomRight() - rect.BottomRight(): OpPoint();
if (pagebar->IsHorizontal() && GetRTL())
{
op_swap(target_before, target_after);
op_swap(delta_to_before, delta_to_after);
}
if (target_before)
return OnDragOver(target_before, delta_to_before, FALSE);
else if (target_after)
return OnDragOver(target_after, delta_to_after, TRUE);
// Check if we're perhaps a grouped item floating on the edge
DesktopWindowCollectionItem* item = GetModelItem();
DesktopWindowCollectionItem* parent = pagebar->GetWorkspace()->GetModelItem();
if (!GetGroupNumber())
return;
if (pagebar->IsHorizontal() && GetRTL())
op_swap(min_move, max_move);
if (moving == min_move)
g_application->GetDesktopWindowCollection().ReorderByItem(*item, parent, NULL);
else if (moving == max_move)
g_application->GetDesktopWindowCollection().ReorderByItem(*item, parent, parent->GetLastChildItem());
}
void PagebarButton::OnDragOver(PagebarButton* target, const OpPoint& delta_coords, BOOL target_after)
{
if (!GetDesktopWindow() || !target->GetDesktopWindow())
return;
OpPagebar* const pagebar = static_cast<OpPagebar*>(parent);
DesktopWindowCollectionItem* item = GetModelItem();
DesktopWindowCollectionItem* target_item = target->GetModelItem();
int delta = pagebar->IsHorizontal() ? delta_coords.x : delta_coords.y;
int target_length = pagebar->IsHorizontal() ? target->rect.width : target->rect.height;
using namespace PagebarButtonConstants;
if (delta * MoveThreshold.denom <= target_length * MoveThreshold.num)
{
// Move the item in front of or after the target
DesktopWindowCollectionItem* move_after = target_after ? target_item : target_item->GetPreviousItem();
DesktopWindowCollectionItem* move_parent = move_after ? move_after->GetParentItem() : target_item->GetParentItem();
return g_application->GetDesktopWindowCollection().ReorderByItem(*item, move_parent, move_after);
}
else if (delta * StackThreshold.denom <= target_length * StackThreshold.num &&
(target_item->GetType() == WINDOW_TYPE_GROUP || !target->GetGroupNumber()))
{
// Stack possibility
return target->SetUseHoverStackOverlay(TRUE);
}
else if (delta * SwapGroupThreshold.denom <= target_length * SwapGroupThreshold.num &&
target_item->GetType() != WINDOW_TYPE_GROUP && target->GetGroupNumber() != GetGroupNumber() &&
(target->GetGroupNumber() || item->GetType() != WINDOW_TYPE_GROUP))
{
// Group swap
DesktopWindowCollectionItem* move_after = target_after ? target_item->GetPreviousItem() : target_item;
return g_application->GetDesktopWindowCollection().ReorderByItem(*item, target_item->GetParentItem(), move_after);
}
else if (delta * ExitGroupThreshold.denom <= target_length * ExitGroupThreshold.num &&
GetGroupNumber() && target->GetGroupNumber() && target->GetGroupNumber() != GetGroupNumber())
{
// Exit the group
DesktopWindowCollectionItem* target_group = target->GetGroup();
DesktopWindowCollectionItem* move_after = target_after ? target_group->GetPreviousItem() : target_group;
DesktopWindowCollectionItem* parent = target_group->GetParentItem();
return g_application->GetDesktopWindowCollection().ReorderByItem(*item, parent, move_after);
}
}
DesktopWindowCollectionItem* PagebarButton::GetModelItem()
{
DesktopGroupModelItem* group = GetGroup();
if (group && group->IsCollapsed())
return group;
return &m_desktop_window->GetModelItem();
}
void PagebarButton::StopMoving()
{
m_is_moving_window = FALSE;
m_between_groups = FALSE;
OpPagebar* pagebar = GetPagebar();
if (pagebar)
{
if (GetGroupNumber())
pagebar->HideGroupOpTabGroupButton(this, FALSE);
if (m_original_group_number > -1)
GetPagebar()->ResetOriginalGroupNumber();
}
m_original_group_number = -1;
if (parent && IsFloating())
{
parent->Relayout();
SetMouseMoveDragging(FALSE);
#ifdef VEGA_OPPAINTER_SUPPORT
// Make the tab animate back to its non-floating position (if it's not already doing that or some other animation).
if (g_animation_manager->GetEnabled() && !GetAnimation())
{
QuickAnimationParams params(this);
params.curve = ANIM_CURVE_SLOW_DOWN;
params.move_type = ANIM_MOVE_RECT_TO_ORIGINAL;
g_animation_manager->startAnimation(params);
}
#endif
}
}
void PagebarButton::OnMouseLeave()
{
if (m_is_moving_window || m_mouse_move_dragging)
StopMoving();
OpButton::OnMouseLeave();
}
void PagebarButton::OnMouseDown(const OpPoint &point, MouseButton button, UINT8 nclicks)
{
m_can_start_drag = TRUE;
m_selected_before_click = GetValue() ? TRUE : FALSE;
m_mousedown_point = point;
OpButton::OnMouseDown(point, button, nclicks);
if (button == MOUSE_BUTTON_1 && m_is_move_window_button)
{
m_is_moving_window = TRUE;
m_desktop_window->Activate();
}
if (button == MOUSE_BUTTON_2)
m_can_start_drag = FALSE;
BOOL speeddial_active = FALSE;
DocumentDesktopWindow * win = g_application->GetActiveDocumentDesktopWindow();
if(win)
{
speeddial_active = win->IsSpeedDialActive();
}
// Click button immediately on mouse down to achieve better perceived performance.
// We also get around Z-order problems for the floating button when rearranged.
if (!speeddial_active && button == MOUSE_BUTTON_1 && !m_selected_before_click)
Click();
}
BOOL PagebarButton::HasSpeedDialActive()
{
BOOL active = FALSE;
if(m_desktop_window && m_desktop_window->GetType() == WINDOW_TYPE_DOCUMENT)
{
active = static_cast<DocumentDesktopWindow *>(m_desktop_window)->IsSpeedDialActive();
}
return active;
}
void PagebarButton::SetIsCompactButton(BOOL compact)
{
if (compact == m_is_compact_button)
return;
m_is_compact_button = compact;
if (compact)
{
SetFixedMinMaxWidth(TRUE);
SetText(UNI_L(""));
if(!m_old_min_width && m_old_min_width != 16)
{
m_old_min_width = GetMinWidth();
}
if(!m_old_max_width && m_old_max_width != 16)
{
m_old_max_width = GetMaxWidth();
}
UpdateMinAndMaxWidth();
}
else
{
SetFixedMinMaxWidth(FALSE);
UpdateTextAndIcon(false, true);
if(m_old_min_width)
{
SetMinWidth(m_old_min_width);
}
if(m_old_max_width)
{
SetMaxWidth(m_old_max_width);
}
}
UpdateLockedTab();
ResetRequiredSize();
OnCompactChanged();
}
void PagebarButton::OnResize(INT32* new_w, INT32* new_h)
{
OpButton::OnResize(new_w, new_h);
InvalidateGroupRect();
}
void PagebarButton::OnMove()
{
OpButton::OnMove();
InvalidateGroupRect();
}
void PagebarButton::InvalidateGroupRect()
{
// Invalidate old rect for group skin
if (parent && !m_old_group_skin_rect.IsEmpty())
{
if (!GetGroupNumber())
{
// Since we leave the group in the opposite direction of the group, we will have to extend the
// area a bit to cover the edge within the group (The part that is not in this button change too)
m_old_group_skin_rect.InsetBy(-20, -20);
}
parent->Invalidate(m_old_group_skin_rect);
m_old_group_skin_rect.Empty();
}
OpPagebar *pagebar = GetPagebar();
if (pagebar && GetGroupNumber())
{
// Make sure the areas painted with the group skin is repainted when the button is moved.
OpSkinElement *elm = pagebar->GetGroupBackgroundSkin(CanUseThumbnails());
if(elm)
{
INT32 left, right, top, bottom;
elm->GetMargin(&left, &top, &right, &bottom, 0);
OpRect rect = GetRect();
if (IsFloating())
{
// Extend area to everything between new and old position
rect.UnionWith(GetOriginalRect());
}
rect.x += left;
rect.y += top;
rect.width -= left + right;
rect.height -= top + bottom;
pagebar->Invalidate(rect);
m_old_group_skin_rect = rect;
}
}
}
void PagebarButton::SetMouseMoveDragging(BOOL is_dragging)
{
if (m_mouse_move_dragging == is_dragging)
return;
m_mouse_move_dragging = is_dragging;
SetFloating(is_dragging);
if (!is_dragging)
return;
SetOriginalRect(GetRect());
OpPagebar* pagebar = GetPagebar();
if (!pagebar)
return;
// If this is a collapsed group we need to save the original number
// for this tab and all of the other ones in its current group
DesktopGroupModelItem* group = GetGroup();
if (group && group->IsCollapsed())
{
m_original_group_number = GetGroupNumber();
pagebar->SetOriginalGroupNumber(GetGroupNumber());
}
}
// Can you use the point to figure out where exactly it was dropped?
void PagebarButton::OnMouseUp(const OpPoint &point, MouseButton button, UINT8 nclicks)
{
BOOL was_floating = IsFloating();
OpPagebarItem::OnMouseUp(point, button, nclicks);
OpPagebar* pagebar = GetPagebar();
if (pagebar && !(parent && IsFloating()) && button == MOUSE_BUTTON_1 && m_selected_before_click &&
g_pcui->GetIntegerPref(PrefsCollectionUI::ClickToMinimize) && m_desktop_window)
m_desktop_window->Minimize();
if (pagebar && m_original_group_number > -1 &&
IsGrouped() &&
(UINT32)m_original_group_number != GetGroupNumber() &&
pagebar->IsGroupExpanded(GetGroupNumber()))
{
// This was a collapsed group being dragged into an expanded group, blend in to the other group
g_application->GetDesktopWindowCollection().UnGroup(GetModelItem());
pagebar->SetGroupCollapsed(GetGroupNumber(), FALSE);
}
StopMoving();
if (m_is_move_window_button && button == MOUSE_BUTTON_1 && nclicks == 2 && m_desktop_window)
{
m_desktop_window->Maximize();
}
// double click on a group -> expand it inline or compact if expanded
if(!g_pcui->GetIntegerPref(PrefsCollectionUI::ClickToMinimize) && IsGrouped() && button == MOUSE_BUTTON_1 && nclicks == 2)
{
SetMouseMoveDragging(FALSE);
if (DesktopGroupModelItem* group = GetGroup())
group->SetCollapsed(!group->IsCollapsed());
}
else if(pagebar && was_floating)
{
PagebarButton* target_button = pagebar->FindDropButton();
if(target_button && (!target_button->IsGrouped() || target_button->GetGroup()->IsCollapsed()))
{
// Add to group if it's not already in a group or it is in a different group
g_application->GetDesktopWindowCollection().MergeInto(*target_button->GetModelItem(), *GetModelItem(), GetDesktopWindow());
}
// clear all overlays from stacking
pagebar->ClearAllHoverStackOverlays();
}
}
void PagebarButton::OnLayout()
{
bool is_close_button_visible = IsCloseButtonVisible();
OpRect inner_rect = GetBounds();
GetBorderSkin()->AddPadding(inner_rect);
UpdateCompactStatus();
OpRect rect;
INT32 width, height, indicator_button_shift = 0;
if(!IsCompactButton() && is_close_button_visible)
{
rect = inner_rect;
m_close_button->UpdateActionStateIfNeeded();
m_close_button->GetBorderSkin()->AddMargin(rect);
m_close_button->GetBorderSkin()->GetSize(&width, &height);
if(!g_skin_manager->GetOptionValue("PageCloseButtonOnLeft", 0))
{
rect.x = rect.x + rect.width - width;
inner_rect.width -= width;
indicator_button_shift = width;
}
else
{
inner_rect.x += width;
inner_rect.width -= width;
}
rect.width = width;
if(g_skin_manager->GetOptionValue("PageCloseButtonOnTop", 0))
{
rect.y = 0;
}
else
{
rect.y = rect.y + (rect.height - height) / 2;
}
rect.height = height;
SetChildRect(m_close_button, rect);
}
if (m_indicator_button->IsVisible())
{
m_indicator_button->ShowSeparator(is_close_button_visible);
rect = GetBounds();
GetBorderSkin()->AddPadding(rect);
INT32 width = m_indicator_button->GetPreferredWidth();
rect.x += rect.width - width;
inner_rect.width = rect.width - width;
rect.width = width;
rect.x -= indicator_button_shift;
SetChildRect(m_indicator_button, rect);
}
if (IsCompactButton())
{
return;
}
if (m_maximize_button)
{
rect = inner_rect;
m_maximize_button->UpdateActionStateIfNeeded();
m_maximize_button->GetBorderSkin()->AddMargin(rect);
INT32 width, height;
m_maximize_button->GetBorderSkin()->GetSize(&width, &height);
if(!g_skin_manager->GetOptionValue("PageCloseButtonOnLeft", 0))
{
rect.x = rect.x + rect.width - width;
inner_rect.width -= width;
}
else
{
inner_rect.x += width;
inner_rect.width -= width;
}
rect.width = width;
if(g_skin_manager->GetOptionValue("PageCloseButtonOnTop", 0))
{
rect.y = 0;
}
else
{
rect.y = rect.y + (rect.height - height) / 2;
}
rect.height = height;
SetChildRect(m_maximize_button, rect);
}
if (m_minimize_button)
{
rect = inner_rect;
m_minimize_button->UpdateActionStateIfNeeded();
m_minimize_button->GetBorderSkin()->AddMargin(rect);
INT32 width, height;
m_minimize_button->GetBorderSkin()->GetSize(&width, &height);
if(!g_skin_manager->GetOptionValue("PageCloseButtonOnLeft", 0))
{
rect.x = rect.x + rect.width - width;
}
rect.width = width;
if(g_skin_manager->GetOptionValue("PageCloseButtonOnTop", 0))
{
rect.y = 0;
}
else
{
rect.y = rect.y + (rect.height - height) / 2;
}
rect.height = height;
SetChildRect(m_minimize_button, rect);
}
UpdateLockedTab();
}
bool PagebarButton::IsCloseButtonVisible()
{
// Don't show close button for pin tabs.
if (m_is_compact_button)
{
return false;
}
// If pagebar is missing it is an unmaximized window and we
// should always show close button for such windows (DSK-363950)
if (!GetPagebar())
{
return true;
}
BOOL is_locked = IsLockedByUser();
BOOL is_closable = IsClosableByUser();
if (!is_locked && (!is_closable || !g_pcui->GetIntegerPref(PrefsCollectionUI::ShowCloseButtons)))
{
return false;
}
return (is_locked || is_closable) &&
g_pcui->GetIntegerPref(PrefsCollectionUI::ShowCloseButtons) &&
GetPagebar() && GetPagebar()->IsCloseButtonVisible(m_desktop_window, TRUE);
}
void PagebarButton::GetPadding(INT32* left, INT32* top, INT32* right, INT32* bottom)
{
OpButton::GetPadding(left, top, right, bottom);
if (m_indicator_button->IsVisible())
{
*right += m_indicator_button->GetPreferredWidth();
}
if(IsCompactButton())
return;
INT32 width = 0;
INT32 height = 0;
if (IsCloseButtonVisible())
{
m_close_button->GetBorderSkin()->GetSize(&width, &height);
}
INT32 left_margin, top_margin, right_margin, bottom_margin;
m_close_button->GetBorderSkin()->GetMargin(&left_margin, &top_margin, &right_margin, &bottom_margin);
if(!g_skin_manager->GetOptionValue("PageCloseButtonOnLeft", 0))
*right += width + left_margin + right_margin;
else
*left += width + left_margin + right_margin;
if (m_maximize_button)
{
m_maximize_button->GetBorderSkin()->GetSize(&width, &height);
m_close_button->GetBorderSkin()->GetMargin(&left_margin, &top_margin, &right_margin, &bottom_margin);
if(!g_skin_manager->GetOptionValue("PageCloseButtonOnLeft", 0))
*right += width + left_margin + right_margin;
else
*left += width + left_margin + right_margin;
}
if (m_minimize_button)
{
m_minimize_button->GetBorderSkin()->GetSize(&width, &height);
m_close_button->GetBorderSkin()->GetMargin(&left_margin, &top_margin, &right_margin, &bottom_margin);
if(!g_skin_manager->GetOptionValue("PageCloseButtonOnLeft", 0))
*right += width + left_margin + right_margin;
else
*left += width + left_margin + right_margin;
}
}
void PagebarButton::GetSkinMargins(INT32 *left, INT32 *top, INT32 *right, INT32 *bottom)
{
OpButton::GetSkinMargins(left, top, right, bottom);
// Use the group skin spacing for the extra gaph for the group start
OpPagebar* pagebar = GetPagebar();
if (pagebar && IsGrouped())
{
BOOL first_in_group = !m_desktop_window->GetModelItem().GetPreviousItem() || GetGroup()->IsCollapsed();
BOOL soon_first_in_group = pagebar->IsGroupCollapsing(GetGroupNumber()) && IsActiveTabForGroup();
if (first_in_group || soon_first_in_group)
{
INT32 spacing = pagebar->GetGroupSpacing(CanUseThumbnails());
if (pagebar->IsHorizontal())
*left += spacing;
else
*top += spacing;
}
}
}
INT32 PagebarButton::GetDropArea( INT32 x, INT32 y )
{
INT32 flag = DROP_CENTER;
if( x >= 0 )
{
if( x < rect.width/4 )
flag |= DROP_LEFT;
else if( x > (rect.width*3)/4 )
flag |= DROP_RIGHT;
}
if( y >= 0 )
{
if( y < rect.height/4 )
flag |= DROP_TOP;
else if( y > (rect.height*3)/4 )
flag |= DROP_BOTTOM;
}
if( flag & (DROP_LEFT|DROP_RIGHT|DROP_TOP|DROP_BOTTOM) )
{
flag &= ~DROP_CENTER;
}
return flag;
}
void PagebarButton::OnImageChanged(OpWidgetImage* widget_image)
{
if(widget_image == GetForegroundSkin() && GetParent())
{
INT32 left = 0, top = 0, right = 0, bottom = 0;
GetPadding(&left, &top, &right, &bottom);
OpRect rect = GetBounds();
OpRect content_rect(rect.x + left, rect.y + top, rect.width - left - right, rect.height - top - bottom);
OpRect image_rect = content_rect;
BOOL invalidate = !GetParent()->IsOfType(WIDGET_TYPE_PAGEBAR);
switch (m_button_style)
{
case OpButton::STYLE_IMAGE_AND_TEXT_ON_RIGHT:
{
image_rect = GetForegroundSkin()->CalculateScaledRect(image_rect, FALSE, TRUE);
Relayout(TRUE, invalidate);
Invalidate(image_rect);
return;
}
case OpButton::STYLE_IMAGE_AND_TEXT_ON_LEFT:
{
image_rect = GetForegroundSkin()->CalculateScaledRect(image_rect, FALSE, TRUE);
image_rect.x = content_rect.x + content_rect.width - image_rect.width;
Relayout(TRUE, invalidate);
Invalidate(image_rect);
return;
}
}
}
OpButton::OnImageChanged(widget_image);
}
OP_STATUS PagebarButton::SetTitle(const OpStringC& title)
{
if(IsCompactButton())
{
return OpStatus::OK;
}
// Set script to allow better font switch
if (m_desktop_window && m_desktop_window->GetWindowCommander())
m_script = m_desktop_window->GetWindowCommander()->GetPreferredScript(FALSE);
return SetText(title.CStr());
}
OpPagebar* PagebarButton::GetPagebar()
{
return (parent && parent->GetType() == WIDGET_TYPE_PAGEBAR) ? static_cast<OpPagebar*>(parent) : NULL;
}
void PagebarButton::SetGroupNumber(UINT32 group_number, BOOL update_active_and_hidden)
{
if (GetGroupNumber() == group_number)
return;
// Change the group number
OpPagebarItem::SetGroupNumber(group_number);
InvalidateGroupRect();
}
UINT32 PagebarButton::GetGroupNumber(BOOL prefer_original_number)
{
if (prefer_original_number && m_original_group_number > -1)
return (UINT32)m_original_group_number;
return OpPagebarItem::GetGroupNumber(prefer_original_number);
}
BOOL PagebarButton::IsActiveTabForGroup()
{
DesktopGroupModelItem* group = GetGroup();
return group && group->GetActiveDesktopWindow() == GetDesktopWindow();
}
DesktopGroupModelItem* PagebarButton::GetGroup()
{
DesktopWindow* window = GetDesktopWindow();
return window ? window->GetParentGroup() : NULL;
}
void PagebarButton::OnPaintAfterChildren(OpWidgetPainter* widget_painter, const OpRect &paint_rect)
{
if(GetUseHoverStackOverlay())
{
OpSkinElement *elm = g_skin_manager->GetSkinElement("Pagebar Hover Overlay Skin");
if(elm)
{
elm->DrawOverlay(GetVisualDevice(), GetBounds(), GetBorderSkin()->GetState(), GetBorderSkin()->GetHoverValue(), NULL);
}
}
}
DesktopDragObject* PagebarButton::GetDragObject(OpTypedObject::Type type, INT32 x, INT32 y)
{
DesktopWindow* window = (DesktopWindow*) GetUserData();
if (!window)
{
return OpWidget::GetDragObject(type, x, y);
}
Image image = window->GetThumbnailImage(THUMBNAIL_WIDTH, THUMBNAIL_HEIGHT, TRUE);
if(image.IsEmpty())
{
return OpWidget::GetDragObject(type, x, y);
}
OpDragObject* op_drag_object;
if (OpStatus::IsError(OpDragObject::Create(op_drag_object, type)))
return NULL;
DesktopDragObject* drag_object = static_cast<DesktopDragObject*>(op_drag_object);
OpBitmap* bitmap = NULL;
OpRect rect(0, 0, image.Width(), image.Height());
RETURN_VALUE_IF_ERROR(OpBitmap::Create(&bitmap, rect.width, rect.height, FALSE, TRUE, 0, 0, TRUE), drag_object);
VisualDevice vd;
vd.painter = bitmap->GetPainter();
if (vd.painter)
{
vd.painter->SetColor(OP_RGB(255, 255, 255));
vd.painter->FillRect(rect);
vd.ImageOut(image, rect, rect, NULL);
vd.painter = NULL;
bitmap->ReleasePainter();
drag_object->SetBitmap(bitmap);
// find pos
OpPoint point(0, 0);
drag_object->SetBitmapPoint(point);
}
else
{
OP_DELETE(bitmap);
}
return drag_object;
}
OpRect PagebarButton::GetRectWithoutMargins()
{
INT32 left, top, right, bottom;
GetSkinMargins(&left, &top, &right, &bottom);
OpRect rect(GetRect());
rect.x -= left;
rect.y -= top;
rect.width += right;
rect.height += bottom;
return rect;
}
void PagebarButton::SetValue(INT32 value)
{
m_indicator_button->SetVisibility(value ? FALSE : TRUE);
BOOL is_indicator_visible = m_indicator_button->IsVisible();
SetFixedMinMaxWidth(is_indicator_visible || m_is_compact_button);
UpdateMinAndMaxWidth();
OpButton::SetValue(value);
}
void PagebarButton::UpdateMinAndMaxWidth()
{
INT32 min_width = -1;
if (m_indicator_button->IsVisible())
{
min_width = m_indicator_button->GetPreferredWidth();
INT32 left, top, right, bottom;
OpButton::GetPadding(&left, &top, &right, &bottom);
min_width += left + right;
}
else if (m_is_compact_button)
{
min_width = 16;
}
SetMinWidth(min_width);
if (m_is_compact_button)
{
SetMaxWidth(min_width);
}
}
void PagebarButton::AddIndicator(OpIndicatorButton::IndicatorType type)
{
m_indicator_button->AddIndicator(type);
OpTabGroupButton* group_button = GetTabGroupButton();
if (group_button)
{
group_button->RefreshIndicatorState();
}
UpdateMinAndMaxWidth();
}
void PagebarButton::RemoveIndicator(OpIndicatorButton::IndicatorType type)
{
m_indicator_button->RemoveIndicator(type);
OpTabGroupButton* group_button = GetTabGroupButton();
if (group_button)
{
group_button->RefreshIndicatorState();
}
UpdateMinAndMaxWidth();
}
OpTabGroupButton* PagebarButton::GetTabGroupButton()
{
OpTabGroupButton* button = NULL;
OpWidget* pagebar = GetParent();
if (pagebar && pagebar->GetType() == WIDGET_TYPE_PAGEBAR)
{
button = static_cast<OpPagebar*>(pagebar)->FindTabGroupButtonByGroupNumber(GetGroupNumber());
}
return button;
}
|
#include <Windows.h>
#include <iostream>
#include "WPDException.h"
#include "WPDObject.h"
#include "WPDEnumerator.h"
#include "WPDDevice.h"
#include "WPDObjectIterator.h"
using namespace std;
using namespace WPD;
void printDate(const SYSTEMTIME &date) {
char dateStr[100];
GetDateFormatA(LOCALE_USER_DEFAULT, 0, &date, nullptr, dateStr, 100);
cout << dateStr << " ";
GetTimeFormatA(LOCALE_USER_DEFAULT, 0, &date, nullptr, dateStr, 100);
cout << dateStr;
}
void printSize(const ULONGLONG size) {
if (size < 1024)
cout << size << " b";
else if (size < 1024 * 1024)
cout << (float) size / 1024 << " Kb";
else if (size < 1024 * 1024 * 1024)
cout << (float) size / 1024 / 1024 << " Mb";
else
cout << (float) size / 1024 / 1024 / 1024 << " Gb";
}
void enumerate_files() {
try {
WPDEnumerator wpdEnumerator;
auto pathes = wpdEnumerator.getDevicePathes();
if (pathes.empty())
return;
const wstring &path = pathes[0];
WPDDevice device(path);
// Get root directory
WPDObject rootDirectory = device.getObject(L"");
// or some directory
//path = L"o91900000";
//WPDObject item = device.getObject(path);
cout << "Device #0 root directory:" << endl;
for (const wstring &itemPath : rootDirectory) {
wcout << endl << L"Path: " << itemPath << endl;
auto item = device.getObject(itemPath);
wcout << L"Name: " << item.getFileName() << endl;
if (item.isStorage()) {
cout << "Storage" << endl;
uint64_t total = item.getSpace();
cout << "Total space: ";
printSize(total);
cout << endl;
uint64_t free = item.getSpaceFree();
cout << "Free space: ";
printSize(free);
cout << endl;
wstring FS = item.getFileSystem();
wcout << L"File System: " << FS << endl;
} else {
if (item.isDirectory())
cout << "Directory" << endl;
else if (item.isFile())
cout << "File" << endl;
else
cout << "Unsupported item type" << endl;
uint64_t size = item.getFileSize();
cout << "File size: ";
printSize(size);
cout << endl;
SYSTEMTIME created = item.getFileDateCreated();
cout << "Created: ";
printDate(created);
cout << endl;
SYSTEMTIME modified = item.getFileDateModified();
cout << "Modified: ";
printDate(modified);
cout << endl;
}
cout << endl;
}
}
catch (WPDException &e) {
cout << "Error: " << e.what() << endl;
cout << "HRESULT: " << (void *) e.code() << " - " << e.explain() << endl;
}
}
int main() {
setlocale(0, "");
CoInitializeEx(nullptr, COINIT_MULTITHREADED);
enumerate_files();
CoUninitialize();
system("pause");
return 0;
}
|
//===- OR1KSubtarget.cpp - OR1K Subtarget Information -----------*- C++ -*-=//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the OR1K specific subclass of TargetSubtarget.
//
//===----------------------------------------------------------------------===//
#include "OR1KSubtarget.h"
#include "OR1K.h"
#define GET_SUBTARGETINFO_TARGET_DESC
#define GET_SUBTARGETINFO_CTOR
#include "OR1KGenSubtargetInfo.inc"
using namespace llvm;
void OR1KSubtarget::anchor() { }
OR1KSubtarget::OR1KSubtarget(const std::string &TT,
const std::string &CPU, const std::string &FS)
: OR1KGenSubtargetInfo(TT, CPU, FS),
HasMul(false),
HasDiv(false),
HasRor(false),
HasCmov(false)
{
std::string CPUName = CPU;
if (CPUName.empty())
CPUName = "generic";
ParseSubtargetFeatures(CPUName, FS);
}
|
/* -*- Mode: c++; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
**
** Copyright (C) 2003-2008 Opera Software AS. All rights reserved.
**
** This file is part of the Opera web browser. It may not be distributed
** under any circumstances.
**
** Yngve Pettersen
**
*/
#include "core/pch.h"
#if defined(_NATIVE_SSL_SUPPORT_)
#if defined LIBSSL_AUTO_UPDATE_ROOTS
#include "modules/libssl/sslbase.h"
#include "modules/libssl/options/sslopt.h"
#include "modules/libssl/data/ssl_xml_update.h"
#include "modules/libssl/data/root_auto_retrieve.h"
#include "modules/libssl/certs/certinstaller.h"
class UpdateRootStoreInstaller : public SSL_Certificate_Installer
{
public:
UpdateRootStoreInstaller(){overwrite_exisiting = TRUE;}
};
SSL_Auto_Root_Retriever::SSL_Auto_Root_Retriever()
{
}
SSL_Auto_Root_Retriever::~SSL_Auto_Root_Retriever()
{
}
OP_STATUS SSL_Auto_Root_Retriever::Construct(SSL_varvector32 &issuer_id, OpMessage fin_msg)
{
URL url;
if(issuer_id.GetLength() == 0)
return OpStatus::ERR_OUT_OF_RANGE;
OpString8 issuer_id_string;
uint32 i, id_len= issuer_id.GetLength();
unsigned char *id_bytes = issuer_id.GetDirect();
char *id_string = issuer_id_string.Reserve(((id_len+1)/2)*5+10);
RETURN_OOM_IF_NULL(id_string);
i =0;
op_sprintf(id_string, "%.2X", id_bytes[i]);
for(i++, id_string+=2;i<id_len; i+=2, id_string+=5)
op_sprintf(id_string, (i+2 < id_len ? "%.2X%.2X_" : "%.2X%.2X.xml"), id_bytes[i], id_bytes[i+1]);
OpString8 issuer_query;
issuer_query.SetConcat(AUTOUPDATE_SCHEME "://" AUTOUPDATE_SERVER "/" AUTOUPDATE_VERSION "/roots/", issuer_id_string);
url = g_url_api->GetURL(issuer_query);
g_url_api->MakeUnique(url);
return SSL_XML_Updater::Construct(url, fin_msg);
}
OP_STATUS SSL_Auto_Root_Retriever::ProcessFile()
{
if(!CheckOptionsManager(SSL_LOAD_CA_STORE | SSL_LOAD_INTERMEDIATE_CA_STORE))
return OpStatus::ERR;
if(!parser.EnterElement(UNI_L("certificates")))
return OpStatus::ERR;
while(parser.EnterElement(UNI_L("certificate")))
{
RETURN_IF_ERROR(ProcessCertificate());
parser.LeaveElement();
}
parser.LeaveElement();
return OpStatus::OK;
}
OP_STATUS SSL_Auto_Root_Retriever::ProcessCertificate()
{
SSL_ASN1Cert certificate_data;
#if defined SSL_CHECK_EXT_VALIDATION_POLICY
SSL_varvector32 ev_oids;
#endif
BOOL warn = FALSE, deny =FALSE;
OpString suggested_name;
const uni_char *before_cond = parser.GetAttribute(UNI_L("before")); // active only before the identified version
const uni_char *after_cond = parser.GetAttribute(UNI_L("after")); // active only from (inclusive) the identified
if(before_cond && uni_atoi(before_cond) <= ROOTSTORE_CATEGORY)
return OpStatus::OK; // If we are after this number, don't process
if(after_cond && uni_atoi(after_cond) > ROOTSTORE_CATEGORY)
return OpStatus::OK; // If we are before this number, don't process
while(parser.EnterAnyElement())
{
SSL_varvector32 *base_64_target = NULL;
if(parser.GetElementName() == UNI_L("certificate-data"))
base_64_target = &certificate_data;
else if(parser.GetElementName() == UNI_L("warn"))
warn = TRUE;
else if(parser.GetElementName() == UNI_L("deny"))
deny= TRUE;
else if(parser.GetElementName() == UNI_L("shortname"))
{
OpStatus::Ignore(suggested_name.Set(parser.GetText()));
suggested_name.Strip();
OP_ASSERT(suggested_name.FindFirstOf(UNI_L("\n\r")) == KNotFound);
}
#if defined SSL_CHECK_EXT_VALIDATION_POLICY
else if(parser.GetElementName() == UNI_L("ev-oids"))
base_64_target = &ev_oids;
#endif
if(base_64_target != NULL)
{
RETURN_IF_ERROR(GetBase64Data(*base_64_target));
if(base_64_target->GetLength() == 0)
return OpStatus::ERR;
}
parser.LeaveElement();
}
OpAutoPtr<UpdateRootStoreInstaller> installer(OP_NEW(UpdateRootStoreInstaller, ()));
if(installer.get() == NULL)
return OpStatus::ERR_NO_MEMORY;
SSL_Certificate_Installer_flags flags(SSL_CA_Store, warn, deny);
RETURN_IF_ERROR(installer->Construct(certificate_data, flags, optionsManager));
installer->SetSuggestedName(suggested_name);
if(installer.get() == NULL)
return OpStatus::ERR_NO_MEMORY;
installer->Raise_SetPreshippedFlag(TRUE);
RETURN_IF_ERROR(installer->StartInstallation());
#if defined SSL_CHECK_EXT_VALIDATION_POLICY
SSL_CertificateItem *cert_item = NULL;
int n=0;
while((cert_item = optionsManager->Find_Certificate(SSL_CA_Store, n))!= NULL)
{
n++;
if(cert_item->certificate == certificate_data)
{
cert_item->ev_policies = ev_oids;
if(cert_item->cert_status == Cert_Not_Updated)
cert_item->cert_status = Cert_Updated;
break;
}
}
#endif
return OpStatus::OK;
}
#endif // LIBSSL_AUTO_UPDATE_ROOTS
#endif
|
// my name is pvp.
#include "stdafx.h"
#include "SuperMonsterSelect.h"
#include "pvpModeSelect.h"
#include <string>
#include "../GameCursor.h"
#include "ModeSelect.h"
#include "../StageSetup/StageSetup.h"
#include "../Game.h"
#include "../SaveLoad/PythonFileLoad.h"
#include "PMMonster.h"
#include "../Fade/Fade.h"
#include "../Fade/MusicFade.h"
#include "../ReturnButton/ReturnButton.h"
#include "..//ToAiEditModeButton.h"
//#include "MonAIPreset/MonAIPresetSave.h"
//#include "MonAIPreset/MonAIPresetLoad.h"
//#include "MonAIPreset/MonAIPresetOpen.h"
#include "MonAIPreset/MonAIPresetOpenSuper.h"
#include "MonAIPreset/MonAIPresetSaveOpen.h"
#include "MonAIPreset/MonAIPresetLoadOpen.h"
#include "GObutton.h"
#include "MonsterSelectBack.h"
PvPModeSelect::~PvPModeSelect()
{
}
void PvPModeSelect::OnDestroy()
{
DeleteGO(m_cursor);
for (auto go : m_pmms)
{
DeleteGO(go);
}
//DeleteGO(m_GO);
DeleteGO(m_back);
DeleteGO(m_return);
DeleteGO(m_returnMoji);
//DeleteGO(m_mapo);
DeleteGO(m_msRed);
DeleteGO(m_mlRed);
DeleteGO(m_msBlue);
DeleteGO(m_mlBlue);
DeleteGO(m_aibutton);
DeleteGO(m_returnButton);
DeleteGO(m_GOb);
DeleteGO(m_msb);
}
bool PvPModeSelect::Start()
{
m_BGM = FindGO<Sound>("BGM");
if (m_BGM == nullptr)
{
m_BGM = NewGO<Sound>(0,"BGM");
m_BGM->Init(L"Assets/sound/BGM/PerituneMaterial_Strategy5_loop.wav", true);
m_BGM->SetVolume(m_vol);
m_BGM->Play();
}
m_aibutton = NewGO< ToAiEditModeButton>(0);
m_aibutton->SetCurrentScene(this);
m_fade = FindGO<Fade>("fade");
m_fade->FadeIn();
//m_back = NewGO<SpriteRender>(0, "sp");
//m_back->Init(L"Assets/sprite/monsel_back.dds", 1280, 720);
m_msb = NewGO<MonsterSelectBack>(0, "msb");
m_files = PythonFileLoad::FilesLoad();
m_cursor = NewGO<GameCursor>(0, "cursor");
// 紅組用のチームを保存するやつ
m_msRed = NewGO<MonAIPresetSaveOpen>(0, "mapso");
m_msRed->init(this, m_cursor, L"チームを保存", { 410,130,0 }, 0);
// 紅組用のチームを開くやつ
m_mlRed = NewGO<MonAIPresetLoadOpen>(0, "maplo");
m_mlRed->init(this, m_cursor, L"チームを開く", { 410,60,0 }, 0);
// AO組用のチームを保存するやつ
m_msBlue = NewGO<MonAIPresetSaveOpen>(0, "mapso");
m_msBlue->init(this, m_cursor, L"チームを保存", { 410,-230,0 }, 1);
// AO組用のチームを開くやつ
m_mlBlue = NewGO<MonAIPresetLoadOpen>(0, "maplo");
m_mlBlue->init(this, m_cursor, L"チームを開く", { 410,-300,0 }, 1);
CVector3 pos = { -290,180,0 };
for (int i = 0; i < 6; i++)
{
if (i == 3)
{
pos = { -290,-180,0 };
}
PMMonster* pmm = NewGO<PMMonster>(0, "pmm");
pmm->init(i,pos);
pmm->Setteam(i >= 3);
pos += {260, 0, 0};
if (g_AIset[i].AImode == 0) //AImode python
{
std::wstring ws = std::wstring(m_files[g_AIset[i].AInum].begin(), m_files[g_AIset[i].AInum].end());
pmm->SetPython(ws.c_str(), g_AIset[i].AInum, g_AIset[i].AImode);
}
else //AImode visualAI
{
wchar_t ws[3];
swprintf_s(ws, L"%d", g_AIset[i].AInum);
pmm->SetPython(ws, g_AIset[i].AInum, g_AIset[i].AImode);
}
m_pmms.push_back(pmm);
}
CVector3 repo = { -520,-260,0 };
m_returnButton = NewGO<ReturnButton>(0, "rb");
m_returnButton->init(this, "modesel", m_cursor);
m_GOb = NewGO<GObutton>(0, "gb");
m_GOb->init(m_cursor, { 520,240,0 });
return true;
}
void PvPModeSelect::Update()
{
if (m_isfade)
{
if (m_fade->isFadeStop())
{
MonsterID moid[6];
int AImodes[6];
for (int i = 0; i < 6; i++)
{
moid[i] = (MonsterID)m_pmms[i]->GetMonsterID();
monai[i] = m_pmms[i]->GetAI();
AImodes[i] = m_pmms[i]->GetAImode();
}
Game* game = NewGO<Game>(0, "Game");
////game->GamePVPmodeInit(m_files, monai,moid);
StageSetup::PVPSetup(m_files, monai, moid,AImodes);
//m_BGM->Stop();
DeleteGO(this);
}
return;
}
bool ispmm = false;
for (auto pmm : m_pmms)
{
ispmm = pmm->isOpen();
if (ispmm)
break;
}
static bool isopen = false;
if (m_aibutton->isFading())
return;
//何か開いていた場合は他のものはクリックしても反応しない。
if (!(m_msRed->IsOpen() || m_mlRed->IsOpen() || m_msBlue->IsOpen() || m_mlBlue->IsOpen() || ispmm || isopen))
{
m_returnButton->UpdateEx<ModeSelect>();
m_aibutton->SetTarget(m_cursor->GetCursor());
m_msRed->UpdateEx();
m_mlRed->UpdateEx();
m_msBlue->UpdateEx();
m_mlBlue->UpdateEx();
//プリセットのセーブ
if (m_msRed->IsClick())
{
m_msRed->Open();
}
if (m_mlRed->IsClick())
{
m_mlRed->Open();
}
if (m_msBlue->IsClick())
{
m_msBlue->Open();
}
if (m_mlBlue->IsClick())
{
m_mlBlue->Open();
}
for (auto pmm : m_pmms)
{
pmm->UpdateEX();
}
bool ismonsel = false;
int count = 0;
for (auto pmm : m_pmms)
{
ismonsel = pmm->isMonSel();
if (ismonsel || pmm->isSelect())
{
break;
}
count++;
}
if (ismonsel)
return;
m_GOb->UpdateEx();
if (m_GOb->isClick())
{
m_fade->FadeOut();
m_isfade = true;
MusicFade* mf = NewGO<MusicFade>(0, "mf");
mf->init(m_BGM, m_vol);
PlayButtonSE();
}
}
isopen = ispmm;
}
void PvPModeSelect::LoadFiles()
{
HANDLE hfind;
WIN32_FIND_DATA win32d;
std::vector<std::string> filenames;
char c[255];
std::string cd;
GetCurrentDirectory(255, c);
cd = c;
std::string key = cd+"/PythonAIs/*.py";
hfind = FindFirstFile(key.c_str(), &win32d);
do
{
if(win32d.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{ }
else
{
std::string p = win32d.cFileName;
p.resize(p.length() - 3);
m_files.push_back(p);
}
} while (FindNextFile(hfind, &win32d));
FindClose(hfind);
}
void PvPModeSelect::PostRender()
{
}
|
//
// Created by arnito on 18/05/17.
//
#ifndef BEAT_THE_BEAT_RESOURCES_H
#define BEAT_THE_BEAT_RESOURCES_H
#define TEXTURETPATH "resources/Textures/"
#define FONTPATH "resources/"
#include "Utils.h"
class Resources {
public:
static void load();
static sf::Font* getFont(std::string key);
static sf::Shader* getShader(std::string key);
static sf::Texture* getTexture(std::string key);
static sf::Image* getImage(std::string key);
private:
static std::map<std::string, sf::Font> fontsMap;
static std::map<std::string, sf::Shader> shadersMap;
static std::map<std::string, sf::Texture> texturesMap;
static std::map<std::string, sf::Image> imagesMap;
static void addFont(std::string key, std::string path);
static void addTexture(std::string key, std::string path);
static void addImage(std::string key, std::string path);
static void addShader(std::string key, std::string shader);
};
#endif //BEAT_THE_BEAT_RESOURCES_H
|
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
int decReverse(int n, int d) {
vector<int> v;
while (n != 0) {
v.push_back(n % d);
n /= d;
}
int sum = 0;
for (int i = v.size() - 1; i >= 0; i--)
sum += v[i] * pow(d, v.size() - 1 - i);
return sum;
}
vector<int> primes = { 2,3,5,7 };
bool isPrime(int n) {
if (n == 1) return false;
bool res = true;
for (int i = 0; ; i++) {
if (primes[i] * primes[i] > n) break;
if (n % primes[i] == 0) {
res = false;
break;
}
}
return res;
}
void generatePrimes() {
for (int i = 11; i < 100000; i++) {
if (isPrime(i)) primes.push_back(i);
}
}
int main() {
int n, d;
generatePrimes();
while (cin >> n >> d) {
if (n < 0) break;
int rev = decReverse(n, d);
if (isPrime(n) && isPrime(rev)) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
return 0;
}
|
#pragma once
class Color
{
public:
Color();
Color(const unsigned char red, const unsigned char green, const unsigned char blue);
Color(const unsigned char red, const unsigned char green, const unsigned char blue, const unsigned char alpha);
const Color operator=(Color rhs);
const unsigned char get_red() const;
const unsigned char get_green() const;
const unsigned char get_blue() const;
const unsigned char get_alpha() const;
int to_raw() const;
int to_bgra_raw() const;
static const Color INVISIBLE;
private:
unsigned char _red;
unsigned char _green;
unsigned char _blue;
unsigned char _alpha;
};
|
/*
* gnucraft.cpp
*
* Created on: 18 Apr 2013
* Author: TRocket
*/
#include <iostream>
#include "version.h"
#include "window.h"
int main(void) {
std::cout << "gnucraft v." << GIT_VERSION << std::endl;
openGNUCraftWindow();
}
|
#include "shader.h"
#include <iostream>
namespace sloth {
Shader::Shader(const char * vertexPath, const char * fragmentPath, const char * geometryPath)
{
std::cout << "vertexPath : " << vertexPath << std::endl;
std::cout << "fragmentPath : " << fragmentPath << std::endl;
if (geometryPath != nullptr)
std::cout << "geometryPath : " << geometryPath << std::endl;
compile(loadStringFromFile(vertexPath).c_str(),
loadStringFromFile(fragmentPath).c_str(),
geometryPath == nullptr ? nullptr : loadStringFromFile(geometryPath).c_str());
}
void Shader::compile(const char * vertexSource, const char * fragmentSource, const char * geometrySource)
{
if (vertexSource == nullptr)
std::cout << "vertex load fail!" << std::endl;
if (fragmentSource == nullptr)
std::cout << "fragment load fail!" << std::endl;
if (geometrySource == nullptr)
std::cout << "geometry load fail!" << std::endl;
GLuint sVertex, sFragment, gShader;
// Vertex Shader
sVertex = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(sVertex, 1, &vertexSource, NULL);
glCompileShader(sVertex);
checkCompileErrors(sVertex, "VERTEX");
// Fragment Shader
sFragment = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(sFragment, 1, &fragmentSource, NULL);
glCompileShader(sFragment);
checkCompileErrors(sFragment, "FRAGMENT");
// If geometry shader source code is given, also compile geometry shader
if (geometrySource != nullptr)
{
gShader = glCreateShader(GL_GEOMETRY_SHADER);
glShaderSource(gShader, 1, &geometrySource, NULL);
glCompileShader(gShader);
checkCompileErrors(gShader, "GEOMETRY");
}
// Shader Program
m_ID = glCreateProgram();
glAttachShader(m_ID, sVertex);
glAttachShader(m_ID, sFragment);
if (geometrySource != nullptr)
glAttachShader(m_ID, gShader);
glLinkProgram(m_ID);
checkCompileErrors(m_ID, "PROGRAM");
// Delete the shaders as they're linked into our m_ID now and no longer necessery
glDeleteShader(sVertex);
glDeleteShader(sFragment);
if (geometrySource != nullptr)
glDeleteShader(gShader);
}
void Shader::storeAllUniformLocation(std::vector<Uniform*> &uniforms)
{
for (auto item : uniforms) {
item->storeUniformLocation(m_ID);
}
glValidateProgram(m_ID);
}
void Shader::loadFloat(const char *name, float value)
{
glProgramUniform1f(m_ID, glGetUniformLocation(this->m_ID, name), value);
}
void Shader::loadInteger(const char *name, int value)
{
glProgramUniform1i(m_ID, glGetUniformLocation(this->m_ID, name), value);
}
void Shader::loadVector2f(const char *name, float x, float y)
{
glProgramUniform2f(m_ID, glGetUniformLocation(this->m_ID, name), x, y);
}
void Shader::loadVector2f(const char *name, const glm::vec2 &value)
{
glProgramUniform2f(m_ID, glGetUniformLocation(this->m_ID, name), value.x, value.y);
}
void Shader::loadVector3f(const char *name, float x, float y, float z)
{
glProgramUniform3f(m_ID, glGetUniformLocation(this->m_ID, name), x, y, z);
}
void Shader::loadVector3f(const char *name, const glm::vec3 &value)
{
glProgramUniform3f(m_ID, glGetUniformLocation(this->m_ID, name), value.x, value.y, value.z);
}
void Shader::loadVector4f(const char *name, float x, float y, float z, float w)
{
glProgramUniform4f(m_ID, glGetUniformLocation(this->m_ID, name), x, y, z, w);
}
void Shader::loadVector4f(const char *name, const glm::vec4 &value)
{
glProgramUniform4f(m_ID, glGetUniformLocation(this->m_ID, name), value.x, value.y, value.z, value.w);
}
void Shader::loadMatrix4(const char *name, const glm::mat4 &matrix)
{
glProgramUniformMatrix4fv(m_ID, glGetUniformLocation(this->m_ID, name), 1, GL_FALSE, glm::value_ptr(matrix));
}
void Shader::loadMatrix4(int location, const glm::mat4 & matrix)
{
glProgramUniformMatrix4fv(m_ID, location, 1, GL_FALSE, glm::value_ptr(matrix));
}
void Shader::checkCompileErrors(const GLuint shader, const std::string type)
{
GLint success;
GLchar infoLog[1024];
if (type != "PROGRAM") {
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
if (!success) {
glGetShaderInfoLog(shader, 1024, nullptr, infoLog);
std::cout << "| ERROR::::SHADER-COMPILATION-ERROR of type: " << type << "|\n" << infoLog << "\n| -- --------------------------------------------------- -- |" << std::endl;
}
}
else {
glGetProgramiv(shader, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(shader, 1024, nullptr, infoLog);
std::cout << "| ERROR::::PROGRAM-LINKING-ERROR of type: " << type << "|\n" << infoLog << "\n| -- --------------------------------------------------- -- |" << std::endl;
}
}
}
}
|
#include <iostream>
#include <string>
#include <cstring>
const int MAX_N = 15;
int k;
std::string word[MAX_N];
int cache[MAX_N][1<<MAX_N], overlap[MAX_N][MAX_N];
int restore(int last, int used) {
if (used == (1 << k) - 1)
return 0;
int& ret = cache[last][used];
if (ret != -1)
return ret;
ret = 0;
for(int next = 0; next < k; ++next) {
if((used & (1 << next)) == 0) {
int cand = overlap[last][next] + restore(next, used + (1 << next));
ret = std::max(ret, cand);
}
}
return ret;
}
std::string reconstruct(int last, int used) {
if (used == (1 << k) - 1)
return "";
for (int next = 0; next < k; ++next) {
if (used & ( 1 << k))
continue;
int ifUsed = restore(next, used + (1 << next)) + overlap[last][next];
if (restore(last, used) == ifUsed)
return (word[next].substr(overlap[last][next]) + reconstruct(next,
used + (1 << next)));
}
return "oops";
}
int getOverlap(const std::string &s1, const std::string &s2)
{
for (int length=std::min(s1.size(), s2.size()); length > 0; length--)
if (s1.substr(s1.size() - length) == s2.substr(0, length))
return length;
return 0;
}
int main() {
int n_case = 0;
std::cin >> n_case;
while (n_case) {
int n_string = 0;
std::cin >> n_string;
k = n_string;
std::memset(cache, -1, sizeof cache);
for (int i = 0; i < k; ++i)
std::cin >> word[i];
while (true) {
bool removed = false;
for(int i = 0; i < k && !removed; i++) {
for(int j = 0; j < k; j++) {
if (i != j && word[i].find(word[j]) != -1) {
word[j] = word[k - 1];
k--;
removed = true;
}
}
}
if (!removed)
break;
}
word[k] = "";
for (int i = 0; i <= k; i++)
for (int j = 0; j <= k; j++)
overlap[i][j] = getOverlap(word[i], word[j]);
std::cout << reconstruct(k, 0) << std::endl;
--n_case;
}
return 0;
}
|
class Nueva_clase :
{
public:
Nueva_clase();
virtual Nueva_clase();
setNuevoAtrib(int atribIn);
private:
unsigned int nuevoAtributo;
}
|
#include "Rectangle.h"
class Block : public Rectangle {
static const int default_w = 50;
static const int default_h = 15;
public:
Block() : Rectangle(0,0, default_w, default_h, 0) {
color = rand() % 0xFFFFFFF00;
broken = false;
}
bool broken;
};
|
// Tests
#include "VnaIntermod.h"
#include "VnaIntermodTest.h"
using namespace RsaToolbox;
// RsaToolbox
#include "Definitions.h"
#include "Test.h"
// Qt
#include <QScopedPointer>
VnaIntermodTest::VnaIntermodTest(QObject *parent) :
VnaTestClass(parent)
{
}
VnaIntermodTest::VnaIntermodTest(ConnectionType type, const QString &address, QObject *parent) :
VnaTestClass(parent)
{
setConnectionType(type);
setAddress(address);
}
VnaIntermodTest::~VnaIntermodTest()
{
}
void VnaIntermodTest::initTestCase() {
_applicationName = "VnaIntermod Test";
_version = "0.0";
_logDir.setPath(SOURCE_DIR);
_logDir.mkpath("VnaIntermodTest");
_logDir.cd("VnaIntermodTest");
if (isZvaFamily()) {
QString logpath = SOURCE_DIR;
logpath += "/VnaIntermodTest/Zva/Logs";
_logDir.setPath(logpath);
}
else if (isZnbFamily()) {
QString logpath = SOURCE_DIR;
logpath += "/VnaIntermodTest/Znb/Logs";
_logDir.setPath(logpath);
}
_logFilenames << "1 - Settings Test.txt"
<< "2 - Traces Test.txt";
_initTestCase();
_vna.reset(new Vna(_connectionType, _address));
QVERIFY(_vna->properties().isIntermodulation());
_vna.reset();
}
void VnaIntermodTest::settings() {
VnaIntermod im = _vna->channel().intermod();
im.setToneDistance(1, SiPrefix::Kilo);
QVERIFY(!_vna->isError());
QCOMPARE(im.toneDistance_Hz(), 1000.0);
QVERIFY(!_vna->isError());
im.setToneDistance(1, SiPrefix::Mega);
QVERIFY(!_vna->isError());
QCOMPARE(im.toneDistance_Hz(), 1.0E6);
QVERIFY(!_vna->isError());
im.setLowerTonePort(4);
QVERIFY(!_vna->isError());
QCOMPARE(im.lowerTonePort(), uint(4));
QVERIFY(!_vna->isError());
im.setLowerTonePort(1);
QVERIFY(!_vna->isError());
QCOMPARE(im.lowerTonePort(), uint(1));
QVERIFY(!_vna->isError());
VnaIntermod::ToneSource source;
source.setPort(4);
im.setUpperToneSource(source);
QVERIFY(!_vna->isError());
QCOMPARE(source, im.upperToneSource());
QVERIFY(!_vna->isError());
source.setPort(3);
im.setUpperToneSource(source);
QVERIFY(!_vna->isError());
QCOMPARE(source, im.upperToneSource());
QVERIFY(!_vna->isError());
// Test generator
// source.setGenerator(1);
// im.setUpperToneSource(source);
// QVERIFY(!_vna->isError());
// QCOMPARE(source, im.upperToneSource());
// QVERIFY(!_vna->isError());
im.setReceivingPort(4);
QVERIFY(!_vna->isError());
QCOMPARE(im.receivingPort(), uint(4));
QVERIFY(!_vna->isError());
im.setReceivingPort(2);
QVERIFY(!_vna->isError());
QCOMPARE(im.receivingPort(), uint(2));
QVERIFY(!_vna->isError());
im.order3On();
QVERIFY(!_vna->isError());
im.order5On();
QVERIFY(!_vna->isError());
im.order7On();
QVERIFY(!_vna->isError());
im.order9On();
QVERIFY(!_vna->isError());
im.orderOn(3);
QVERIFY(!_vna->isError());
im.orderOn(5);
QVERIFY(!_vna->isError());
im.orderOn(7);
QVERIFY(!_vna->isError());
im.orderOn(9);
QVERIFY(!_vna->isError());
}
void VnaIntermodTest::traces() {
VnaChannel channel = _vna->channel();
VnaLinearSweep sweep = channel.linearSweep();
VnaIntermod intermod = channel.intermod();
sweep.setStart( 1, SiPrefix::Giga);
sweep.setStop( 2, SiPrefix::Giga);
sweep.setIfbandwidth( 1, SiPrefix::Kilo);
intermod.setToneDistance(1, SiPrefix::Mega);
VnaIntermod::ToneSource upperSource;
upperSource.setPort(3);
intermod.setUpperToneSource(upperSource);
intermod.setLowerTonePort(1);
intermod.setReceivingPort(2);
intermod.order3On();
intermod.order5On();
intermod.order7On();
intermod.order9On();
QVERIFY(!_vna->isError());
// Original tones
VnaTrace trc1 = _vna->trace();
trc1.setIntermodTone(VnaTrace::Side::Lower, VnaTrace::At::Input);
QCOMPARE(trc1.parameter(), QString("LTI"));
trc1.setIntermodTone(VnaTrace::Side::Lower, VnaTrace::At::Output);
QCOMPARE(trc1.parameter(), QString("LTO"));
trc1.setIntermodTone(VnaTrace::Side::Upper, VnaTrace::At::Input);
QCOMPARE(trc1.parameter(), QString("UTI"));
trc1.setIntermodTone(VnaTrace::Side::Upper, VnaTrace::At::Output);
QCOMPARE(trc1.parameter(), QString("UTO"));
// Intermod
trc1.setIntermod(3, VnaTrace::Side::Lower);
QCOMPARE(trc1.parameter(), QString("IM3LO"));
trc1.setIntermod(5, VnaTrace::Side::Upper);
QCOMPARE(trc1.parameter(), QString("IM5UO"));
trc1.setIntermod(7, VnaTrace::Side::Major);
QCOMPARE(trc1.parameter(), QString("IM7MO"));
// Intermod rejection
trc1.setIntermodRejection(5, VnaTrace::Side::Lower);
QCOMPARE(trc1.parameter(), QString("IM5LOR"));
trc1.setIntermodRejection(7, VnaTrace::Side::Upper);
QCOMPARE(trc1.parameter(), QString("IM7UOR"));
trc1.setIntermodRejection(9, VnaTrace::Side::Major);
QCOMPARE(trc1.parameter(), QString("IM9MOR"));
// Intercept Point
trc1.setIntermodIntercept(3, VnaTrace::Side::Lower);
QCOMPARE(trc1.parameter(), QString("IP3LO"));
trc1.setIntermodIntercept(5, VnaTrace::Side::Upper);
QCOMPARE(trc1.parameter(), QString("IP5UO"));
trc1.setIntermodIntercept(7, VnaTrace::Side::Major);
QCOMPARE(trc1.parameter(), QString("IP7MO"));
}
|
#include<bits/stdc++.h>
using namespace std;
class MyLinkedList {
public:
struct ListNode {
int val;
ListNode *next;
ListNode() : val(0), next(NULL) {}
ListNode(int x) : val(x), next(NULL) {}
ListNode(int x, ListNode *next) : val(x), next(next) {}
};
ListNode *head;
ListNode *tail;
int count;
/** Initialize your data structure here. */
MyLinkedList() {
head = NULL;
tail = NULL;
count = 0;
}
/** Get the value of the index-th node in the linked list. If the index is invalid, return -1. */
int get(int index) {
ListNode *tmp = head;
while(true){
if(!tmp) return -1;
if(!index) return tmp->val;
index--;
tmp=tmp->next;
}
}
/** Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list. */
void addAtHead(int val) {
if(!head){
head = new ListNode(val,head);
tail = head;
}
else head = new ListNode(val,head);
count++;
}
/** Append a node of value val to the last element of the linked list. */
void addAtTail(int val) {
if(!tail){
head = new ListNode(val,head);
tail = head;
}
else {tail->next = new ListNode(val);
tail=tail->next;}
count++;
}
/** Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted. */
void addAtIndex(int index, int val) {
if(index<=count){
if(index == count){
if(!tail){
head = new ListNode(val,head);
tail = head;
}
else{tail->next = new ListNode(val);
tail=tail->next;}
}
else{
ListNode *tmp = head;
if(index == 0) {
if(!head){
head = new ListNode(val,head);
tail = head;
}
else head = new ListNode(val,head);
}
else{
while(true){
if(--index == 0){
tmp->next = new ListNode(val,tmp->next);
break;
}
tmp=tmp->next;
}
}
}
count++;
}
}
/** Delete the index-th node in the linked list, if the index is valid. */
void deleteAtIndex(int index) {
if(index<count){
if (count == 1){
delete head;
head = NULL;
tail = NULL;
count = 0;
return;
}
if(index == 0){
ListNode *tmp=head->next;
delete head;
head = tmp;
count--;
return;
}
if(index == count-1){
ListNode *tmp=head;
while(--index) tmp=tmp->next;
delete tail;
tail = tmp;
tail->next = NULL;
count--;
return;
}
ListNode *tmp=head;
while(--index) tmp=tmp->next;
ListNode *cur=tmp->next;
tmp->next=cur->next;
delete cur;
count--;
}
}
};
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList* obj = new MyLinkedList();
* int param_1 = obj->get(index);
* obj->addAtHead(val);
* obj->addAtTail(val);
* obj->addAtIndex(index,val);
* obj->deleteAtIndex(index);
*/
|
//
// Created by ahmed on 9/24/2018.
//
#include <iostream>
#include "windchillindex.h"
using namespace std;
using edu::vcccd::vc::csv13::computeWindChillIndex;
int main(int argc, char *argv[]) {
cout << computeWindChillIndex(5,2);
return 0;
}
|
// Created on: 2001-03-06
// Created by: Christian CAILLET
// Copyright (c) 2001-2014 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Lesser General Public License version 2.1 as published
// by the Free Software Foundation, with special exception defined in the file
// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
// distribution for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
#ifndef _IGESSelect_SignColor_HeaderFile
#define _IGESSelect_SignColor_HeaderFile
#include <Standard.hxx>
#include <Standard_Type.hxx>
#include <Standard_Integer.hxx>
#include <IFSelect_Signature.hxx>
#include <Standard_CString.hxx>
class Standard_Transient;
class Interface_InterfaceModel;
class IGESSelect_SignColor;
DEFINE_STANDARD_HANDLE(IGESSelect_SignColor, IFSelect_Signature)
//! Gives Color attached to an entity
//! Several forms are possible, according to <mode>
//! 1 : number : "Dnn" for entity, "Snn" for standard, "(none)" for 0
//! 2 : name : Of standard color, or of the color entity, or "(none)"
//! (if the color entity has no name, its label is taken)
//! 3 : RGB values, form R:nn,G:nn,B:nn
//! 4 : RED value : an integer
//! 5 : GREEN value : an integer
//! 6 : BLUE value : an integer
//! Other computable values can be added if needed :
//! CMY values, Percentages for Hue, Lightness, Saturation
class IGESSelect_SignColor : public IFSelect_Signature
{
public:
//! Creates a SignColor
//! mode : see above for the meaning
//! modes 4,5,6 give a numeric integer value
//! Name is initialised according to the mode
Standard_EXPORT IGESSelect_SignColor(const Standard_Integer mode);
//! Returns the value (see above)
Standard_EXPORT Standard_CString Value (const Handle(Standard_Transient)& ent, const Handle(Interface_InterfaceModel)& model) const Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(IGESSelect_SignColor,IFSelect_Signature)
protected:
private:
Standard_Integer themode;
};
#endif // _IGESSelect_SignColor_HeaderFile
|
/*******************************************
C++ Program for 1D linear-hyperbolic Problem
********************************************/
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <iostream>
#include <string>
#include <fstream>
std::vector<double> x(100,0);
std::vector<double> yi(100,0); //initial condition
std::vector<double> ye(100,0); //exact solution
std::vector<double> ys(100,0); //numerical solution
std::vector<double> work(100,0);
int mx = 99; // number of nodes
int nstep = 30; // number of steps
double c = 1.0;
double cfl = 0.5; //Courant number
double dx = 0.01; // =1/mx
double dt = cfl*dx;
void exact(int i){
double travel = double(nstep) * dt*c;
if(x[i] < (0.5 + travel)) ye[i] = 1.0;
else ye[i] = 0.0;
}
void scheme_1(int i){
work[i] = ys[i] - 0.5*cfl*(ys[i+1]-ys[i-1]);
}
void scheme_2(int i){
work[i] = ys[i] - cfl*(ys[i]-ys[i-1]);
}
void lax_wendroff(int i){
work[i] = 0.5*cfl*(1+cfl)*ys[i-1]+(1-cfl*cfl)*ys[i] - 0.5*cfl*(1-cfl)*ys[i+1];
}
void numerical_sol(int scheme_num,int i){
switch(scheme_num){
case 1:
scheme_1(i);
break;
case 2:
scheme_2(i);
break;
case 3:
lax_wendroff(i);
break;
default:
lax_wendroff(i);
}
}
int main(){
int scheme_num =0;
std::string scheme_str;
std::cout << "Select Scheme Number (1:中心差分,2:風上差分,3:lax_wendroff) :" << std::endl;
std::cin >> scheme_num;
std::cout << "Selected Scheme: ";
switch(scheme_num){
case 1:
scheme_str = "center";
break;
case 2:
scheme_str = "upper_stream";
break;
case 3:
scheme_str = "Lax_Wendroff";
break;
default:
scheme_str = "Lax_Wendroff";
}
std::cout << scheme_str << std::endl;
// set initial condtition
for(int i=0;i<mx;i++){
x[i] = dx * double(i);
if(x[i] < 0.5) yi[i] = 1.0;
else yi[i] = 0.0;
}
// set exact solution
for (int i=0;i<mx;i++){
exact(i);
}
// numerical solution
for(int i=0; i< mx; i++){
ys[i] = yi[i];
}
for(int n=0; n < nstep; n++){
for(int i =0; i < mx; i++){
numerical_sol(scheme_num,i);
}
for(int i=0; i<mx; i++){
ys[i] = work[i];
}
}
// write datafile
// exact solution
std::ofstream fout_ex;
std::string filename_ex = "../datafile/1Dhyperbolic/exact.txt";
fout_ex.open(filename_ex.c_str(), std::ios::out);
for (int i=0; i<mx; i++) {
fout_ex << i*dx << " " << ye[i] << std::endl;
}
fout_ex.close();
// numerical sol
std::ofstream fout_num;
std::string filename_num = "../datafile/1Dhyperbolic/" + scheme_str + ".txt";
fout_num.open(filename_num.c_str(), std::ios::out);
for (int i=0; i<mx; i++) {
fout_num << i*dx << " " << ys[i] << std::endl;
}
fout_num.close();
}
|
#include "list.hpp"
List::List():
head(nullptr)
{}
List::List(const List& other)
: head(nullptr)
{
node* newNode = other.head;
while (nullptr != newNode -> next) {
push(newNode -> key, newNode -> value);
newNode = newNode -> next;
}
push(newNode -> key, newNode -> value);
}
List::~List() {
clear();
}
bool List::push(const std::string key, const std::string value) {
node *newNode = new node(key, value);
if (searchKey(newNode -> key, newNode -> value)) {
return false;
}
newNode -> next = head;
head = newNode;
return true;
}
bool List::getValue(std::string key, std::string& value) {
if (nullptr == head) {
std::cout << "\nMutqagrac Key-ov arjeq chka HashTable-um\n";
return false;
}
if (head -> key == key) {
value = head -> value;
return true;
}
node* tmp = head;
while (nullptr != tmp -> next) {
if (tmp -> next -> key == key) {
value = tmp -> next -> value;
return true;
}
tmp = tmp -> next;
}
std::cout << "\nMutqagrac Key-ov arjeq chka HashTable-um\n";
return false;
}
bool List::deleteValue(std::string& delKey, std::string& value) {
if (nullptr == head) {
return false;
}
if (head -> key == delKey) {
value = head -> value;
node* tmp = head;
head = head->next;
delete tmp;
return true;
}
node* tmp = head;
while (nullptr != tmp -> next) {
if (tmp -> next -> key == delKey) {
tmp -> next -> value = value;
node* n = tmp -> next;
tmp -> next = n -> next;
delete n;
return true;
}
tmp = tmp -> next;
}
value = "";
return false;
}
void List::clear() {
if(nullptr == head) {
return;
}
while(nullptr != head -> next) {
node* tmp = head;
head = head->next;
delete tmp;
}
node* tmp = head;
head = nullptr;
delete tmp;
}
bool List::searchKey(std::string& key, std::string& value) {
if (nullptr == head) {
return false;
}
if (head -> key == key) {
head -> value = value;
return true;
}
node* tmp = head;
while (nullptr != tmp -> next) {
if (tmp -> next -> key == key) {
tmp -> next -> value = value;
return true;
}
tmp = tmp -> next;
}
return false;
}
|
// Name : Angel E Hernandez
// Date : April 17
// CIS 1202.800
// Project name : Inheritance
#pragma once
#include <iostream>
#include "Vehicle.h"
using namespace std;
// define displayInfo function from vehicle class
void Vehicle::displayInfo()
{
string manufact;
int vYear;
cout << "vehicle Program" << endl << endl;
// prompt user to enter information
cout << "Vehicle: \n";
cout << "Enter the manufacturer: ";
getline(cin, manufact);
cout << "Enter the year built: ";
cin >> vYear;
// define a vehicle object
Vehicle veh(manufact, vYear);
// display information
cout << "Vehicle information: \n";
cout << "Manufacturer: " << veh.getManufacturer() << endl;
cout << "Year Buil: " << veh.getYear() << endl;
cout << endl;
}
|
/*
* File: manager.h
* Author: Dirk Vermeir
* Edited by: Wouter Van Rossem
*
* Created on July 22, 2009, 10:54 AM
*/
#ifndef _MANAGER_H
#define _MANAGER_H
#include <set>
#include <map>
#include <dvutil/debug.h>
#include <dvutil/props.h> // for config()
#include <dvthread/thread.h>
#include <dvthread/actor.h>
#include "player.h"
#include "maildrops.h"
/** The class that manages the maildrops. It communicates with
* the players via an Dv::Thread::Actor thread which itself
* uses a Dv::Thread::MailBox: the thread simply
* waits for messages to be delivered to its mailbox and
* then processes them using the Manager::operator() function.
*/
class Manager : public std::unary_function<Player::Message, std::string>,
public Player::Manager
{
public:
enum State
{
Authorization,
Transaction,
Update
};
/** The following is pure virtual in Player::Manager and
* the only thing a Player needs to know about the manager. */
void request (Player::Message m, Player::MailBox* mbox)
{
thread_.request(m, mbox);
}
/** Function called by the Actor thread associated with this Manager.
* The thread will read messages from its mailbox and then
* process them using this function.
* @param m message put by a player in the actor's mailbox.
* @return a string that will be put into the client's reply
* mailbox, if any.
* @exception std::runtime_error if the manager refuses
* for some reason to react to a request
*/
std::string operator()(const Player::Message& m) throw (std::runtime_error);
/** This function will return true after the manager (thread)
* has processed a 'shutdown' command.
* The main server program should check for this
* function in its main loop. If true, it can
* safely call Manager::kill.
* @return true iff the manager may be killed
* @see Manager::kill
*/
bool done () const
{
return done_;
}
/** This function will
* first kill all the players and then the manager thread.
* @warning this function cannot be called from the
* manager thread (otherwise, this would be suicide).
* @see Manager::done
*/
void kill ();
/** The configuration of this program.
* @return the configuration parameters as a Dv::Props object
*/
const Dv::Props& config ()
{
return config_;
}
/** Constructor.
* @param name of this manager
* @param config contains configuration parameters
* @param debug object which allows connected objects (e.g.
* threads) to write debug info
*/
Manager (const std::string& name, const Dv::Props& config, Dv::Debugable* debug = 0);
private:
Manager (const Manager&);
Manager & operator= (const Manager&);
/** Remove all references to a player from the manager's database
* and kill its thread.
* The function is robust: calling it twice will have no effect
* the second time. I.e. it is idempotent.
* @param player pointer to player object
*/
void remove_player (Player* player);
/** The set of active players, including nameless ones. */
Player::Set players_;
/** The set of active players that have 'root' status (via a
* successful 'su' command. */
Player::Set roots_;
/** A map that supports finding an active named player by name. */
Player::Map players_by_name_;
/** Type of the actor thread associated with Manager::manager. */
typedef Dv::Thread::Actor<Manager> Actor;
/** This is the manager's thread. */
Actor thread_;
/** Has the manager thread processed a shutdown command? */
bool done_;
/** The server configuration */
Dv::Props config_;
/** Return a pseudo-stream to write log info on.
* @param i debug level, the pseudo stream is real only
* if the actual debug level is at least @c i
* @return a pseudo stream to write on
*/
Dv::ostream_ptr& log (unsigned int i = 0)
{
return thread_.log(i);
}
/** The active maildrops */
Maildrops _maildrops;
/** A map of players and their current state */
std::map<Player*, State> _players_states;
};
#endif /* _MANAGER_H */
|
#include <cstring>
#include <stdexcept>
#include <string>
#include "../include/catch.hpp"
#include "command_parser.h"
void testCommandParser(const char *command, void(test)(core::CommandParser &)) {
char *dup = new char[strlen(command)];
strcpy(dup, command);
core::CommandParser parser(dup);
test(parser);
delete[] dup;
}
TEST_CASE("throws exception if nullptr") {
core::CommandParser parser(nullptr);
REQUIRE_THROWS_AS(parser.next(), std::invalid_argument);
}
TEST_CASE("splits on ':'") {
testCommandParser("some:thing", [](core::CommandParser &parser) {
REQUIRE(parser.next() == "some");
REQUIRE(parser.next() == "thing");
});
}
TEST_CASE("throws exception if no match") {
testCommandParser("", [](core::CommandParser &parser) {
REQUIRE_THROWS_AS(parser.next(), std::invalid_argument);
});
}
TEST_CASE("throws exception if incomplete") {
testCommandParser("some:", [](core::CommandParser &parser) {
REQUIRE(parser.next() == "some");
REQUIRE_THROWS_AS(parser.next(), std::invalid_argument);
});
}
|
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode* convertBST(TreeNode* root) {
int accumulation = 0;
midOrder(root, accumulation);
return root;
}
void midOrder(TreeNode* root, int& accumulation) {
if(root == NULL) {
return;
}
midOrder(root->right, accumulation);
root->val += accumulation;
accumulation = root->val;
midOrder(root->left, accumulation);
}
};
|
#include <iberbar/Renderer/Font.h>
#include <iberbar/RHI/Device.h>
#include <iberbar/RHI/Texture.h>
#include <iberbar/Renderer/Renderer.h>
//#include <iberbar/Renderer/RendererSprite.h>
#include <iberbar/Font/FreeType.h>
#include <iberbar/Font/FontDrawText.h>
#include <iberbar/Utility/RectClip2d.h>
namespace iberbar
{
namespace Renderer
{
// ÎÆÀí»º´æ
class CFontTextureCache
{
public:
struct UAllocDesc
{
int nCharW;
void* pPixels;
int nTextureIndex;
CRect2f rectTextureCoord;
};
public:
CFontTextureCache( RHI::IDevice* pDevice, int nCharHeight );
~CFontTextureCache();
void AllocRect( int nBitmapWidth, int nBitmapHeight, const void* pPixels, int* pOutTextureIndex, CRect2f* pOutTextureCoord );
RHI::ITexture* GetTexture( int nIndex );
CResult SaveToFilesA( const char* strFile );
#ifdef _WIN32
CResult SaveToFilesW( const wchar_t* strFile );
#endif
private:
int m_nCharH;
int m_nTextureOffsetX;
int m_nTextureOffsetY;
RHI::IDevice* m_pDevice;
std::vector< RHI::ITexture* > m_pTextures;
static const int sm_nTextureMaxSize = 512;
};
}
}
iberbar::Renderer::CFontTextureCache::CFontTextureCache( RHI::IDevice* pDevice, int nCharHeight )
: m_nCharH( nCharHeight )
, m_nTextureOffsetX( 0 )
, m_nTextureOffsetY( 0 )
, m_pDevice( pDevice )
, m_pTextures()
{
if ( m_pDevice->GetApiType() == RHI::UApiType::D3D9 )
{
//m_nFix = 0.5f;
}
}
iberbar::Renderer::CFontTextureCache::~CFontTextureCache()
{
SafeReleaseStdVector( m_pTextures );
}
void iberbar::Renderer::CFontTextureCache::AllocRect( int nBitmapWidth, int nBitmapHeight, const void* pPixels, int* pOutTextureIndex, CRect2f* pOutTextureCoord )
{
RHI::ITexture* pTexture = nullptr;
int nTextureIndex = -1;
int nOffsetX = m_nTextureOffsetX;
int nOffsetY = m_nTextureOffsetY;
if ( (m_nTextureOffsetX + nBitmapWidth) > sm_nTextureMaxSize )
{
nOffsetX = 0;
nOffsetY += m_nCharH;
}
if ( (nOffsetY + m_nCharH) > sm_nTextureMaxSize || m_pTextures.size() == 0 )
{
nOffsetX = 0;
nOffsetY = 0;
m_pDevice->CreateTexture( &pTexture );
pTexture->CreateEmpty( sm_nTextureMaxSize, sm_nTextureMaxSize );
m_pTextures.push_back( pTexture );
}
else
{
pTexture = (*(m_pTextures.rbegin()));
}
nTextureIndex = (int)m_pTextures.size() - 1;
pTexture->SetPixels( pPixels, nOffsetX, nOffsetY, nBitmapWidth, nBitmapHeight );
(*pOutTextureIndex) = nTextureIndex;
(*pOutTextureCoord) = CRect2f(
(float)nOffsetX,
(float)nOffsetY,
(float)(nOffsetX + nBitmapWidth),
(float)(nOffsetY + nBitmapHeight) );
(*pOutTextureCoord) = (*pOutTextureCoord) / (float)sm_nTextureMaxSize;
m_nTextureOffsetX = nOffsetX + nBitmapWidth;
m_nTextureOffsetY = nOffsetY;
}
FORCEINLINE iberbar::RHI::ITexture* iberbar::Renderer::CFontTextureCache::GetTexture( int nIndex )
{
if ( nIndex < 0 || nIndex >= (int)m_pTextures.size() )
return nullptr;
return m_pTextures[ nIndex ];
}
iberbar::CResult iberbar::Renderer::CFontTextureCache::SaveToFilesA( const char* strFile )
{
if ( m_pTextures.empty() == false )
{
size_t nSize = m_pTextures.size();
for ( size_t i = 0; i < nSize; i++ )
{
m_pTextures[ i ]->SaveToFileA( strFile );
}
}
return CResult();
}
#ifdef _WIN32
iberbar::CResult iberbar::Renderer::CFontTextureCache::SaveToFilesW( const wchar_t* strFile )
{
if ( m_pTextures.empty() == false )
{
size_t nSize = m_pTextures.size();
for ( size_t i = 0; i < nSize; i++ )
{
m_pTextures[ i ]->SaveToFileW( strFile );
}
}
return CResult();
}
#endif
iberbar::Renderer::CFont::CFont(
RHI::IDevice* pRHIDevice,
CFontFaceFt* pFace,
const char* strName,
int nSize,
int nWeight,
int nItalic,
UFontCharVocabularyType nVocabularyType )
: m_pFace( pFace )
, m_pCharMapper( new TFontCharMapper<UFontCharBitmap>() )
, m_pTextureCache( new CFontTextureCache( pRHIDevice, nSize ) )
{
m_pFace->AddRef();
m_FontDesc.FamilyName = strName;
m_FontDesc.Size = nSize;
m_FontDesc.Weight = nWeight;
m_FontDesc.Italic = (nItalic == 0) ? false : true;
}
iberbar::Renderer::CFont::~CFont()
{
m_pTextureCache->SaveToFilesA( "font_cache.png" );
UNKNOWN_SAFE_RELEASE_NULL( m_pFace );
SAFE_DELETE( m_pCharMapper );
SAFE_DELETE( m_pTextureCache );
}
int iberbar::Renderer::CFont::LoadText( const wchar_t* strText )
{
if ( StringIsNullOrEmpty( strText ) == true )
return 0;
m_pFace->SetFontSize( m_FontDesc.Size );
m_pFace->SetFontWeight( m_FontDesc.Weight );
const wchar_t* pTemp = strText;
wchar_t nChar;
int nLoadedCount = 0;
while ( *pTemp != 0 )
{
nChar = *pTemp;
if ( GetCharBitmap( nChar ) == nullptr )
{
if ( AddCharBitmap( nChar ) == true )
nLoadedCount++;
}
else
{
nLoadedCount++;
}
pTemp++;
}
return nLoadedCount;
}
int iberbar::Renderer::CFont::LoadText( wchar_t nCharFirst, wchar_t nCharLast )
{
if ( nCharLast < nCharFirst )
return 0;
m_pFace->SetFontSize( m_FontDesc.Size );
m_pFace->SetFontWeight( m_FontDesc.Weight );
int nLoadedCount = 0;
for ( wchar_t nChar = nCharFirst; nChar <= nCharLast; nChar++ )
{
if ( GetCharBitmap( nChar ) == nullptr )
{
if ( AddCharBitmap( nChar ) == true )
nLoadedCount++;
}
else
{
nLoadedCount++;
}
}
return nLoadedCount;
}
iberbar::RHI::ITexture* iberbar::Renderer::CFont::GetTexture( int nIndex )
{
return m_pTextureCache->GetTexture( nIndex );
}
bool iberbar::Renderer::CFont::AddCharBitmap( wchar_t nChar )
{
int nTextureIndex = UFontCharBitmap::sTextureIndex_UnInitialized;
CRect2f rcTextureCoord;
CResult ret;
UFontCharBitmapDesc BitmapDesc;
BitmapDesc.bOutline = false;
ret = m_pFace->CreateCharBitmap( nChar, &BitmapDesc, UFontBitsFormat::ARGB );
if ( ret.IsOK() == true )
{
if ( BitmapDesc.nBmpWidth > 0 && BitmapDesc.nBmpHeight > 0 && BitmapDesc.pBitsFill != nullptr )
{
// ·ÖÅä×Ö·û
m_pTextureCache->AllocRect( BitmapDesc.nBmpWidth, BitmapDesc.nBmpHeight, BitmapDesc.pBitsFill, &nTextureIndex, &rcTextureCoord );
}
else
{
nTextureIndex = UFontCharBitmap::sTextureIndex_JustNoTexture;
}
UFontCharBitmap Bitmap;
Bitmap.nChar = nChar;
Bitmap.nCharWidth = BitmapDesc.nCharWidth;
Bitmap.nDeltaX = BitmapDesc.nDeltaX;
Bitmap.nDeltaY = BitmapDesc.nDeltaY;
Bitmap.nTextureIndex = nTextureIndex;
Bitmap.TextureSize = CSize2i( BitmapDesc.nBmpWidth, BitmapDesc.nBmpHeight );
Bitmap.rcTexCoord = rcTextureCoord;
m_pCharMapper->Add( nChar, Bitmap );
return true;
}
return false;
}
|
// Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "AbilitySystemInterface.h"
#include "CSCharacter.generated.h"
class UCameraComponent;
class USpringArmComponent;
class UCSHealthComponent;
class ACSWeapon;
class UGameplayAbility;
class UCSAttributeSet;
class UAbilitySystemComponent;
/** Event for aim state being changed */
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FCharacterAimStateChangedSignature, ACSCharacter*, Character, bool, NewState);
/** Event for aim state being changed */
DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FCharactereEquipWeaponSignature, ACSCharacter*, Character, ACSWeapon*, NewWeapon);
UENUM(BlueprintType)
enum class EAbilityInput : uint8
{
UseAbility1 UMETA(DisplayName = "Use Spell 1"),
UseAbility2 UMETA(DisplayName = "Use Spell 2"),
UseAbility3 UMETA(DisplayName = "Use Spell 3"),
UseAbility4 UMETA(DisplayName = "Use Spell 4"),
};
UENUM(BlueprintType)
enum class ECharacterAction : uint8
{
ShotFire UMETA(DisplayName = "Shot Fire"),
ShotHit UMETA(DisplayName = "Shot Hit"),
DamageDone UMETA(DisplayName = "Damage Done"),
DamageTaken UMETA(DisplayName = "Damage Taken"),
MaxAction UMETA(Hidden),
};
UCLASS()
class UE4COOP_API ACSCharacter : public ACharacter, public IAbilitySystemInterface
{
GENERATED_BODY()
UAbilitySystemComponent* GetAbilitySystemComponent() const override;
public:
// Sets default values for this character's properties
ACSCharacter();
protected:
/** Begin ACharacter Interface */
virtual void PostInitializeComponents() override;
virtual void BeginPlay() override;
virtual void Tick(float DeltaTime) override;
virtual void SetupPlayerInputComponent(class UInputComponent* PlayerInputComponent) override;
virtual void PossessedBy(AController* NewController) override;
virtual FVector GetPawnViewLocation() const override;
/** End ACharacter Interface */
protected:
//////////////////////////////////////////////////////////////////////////
// Input
/**
* Move forward/back
*
* @param Value Movement input to apply
*/
void MoveForward(float Value);
/**
* Strafe right/left
*
* @param Value Movement input to apply
*/
void MoveRight(float Value);
/** Player pressed jump action */
void MoveJump();
/** Player pressed crouch action */
void BeginCrouch();
/** Player released crouch action */
void EndCrouch();
/** Player pressed reload action */
void OnStartReload();
/** Player pressed Aim Down Sights action */
void OnStartAiming();
/** Player released Aim Down Sights action */
void OnStopAiming();
/** Player pressed fire action */
UFUNCTION(BlueprintCallable, Category = "Player")
void StartFire();
/** Player released fire action */
UFUNCTION(BlueprintCallable, Category = "Player")
void StopFire();
public:
//////////////////////////////////////////////////////////////////////////
// Weapon usage
/** Check if pawn can fire weapon */
bool CanFire() const;
/** Check if pawn can reload weapon */
bool CanReload() const;
/** Spawn default weapon */
virtual void SpawnDefaultWeapon();
/** Equip New Weapon and broadcast the event */
virtual void EquipWeapon(ACSWeapon* NewWeapon);
//////////////////////////////////////////////////////////////////////////
// Animations
/** Play anim montage */
virtual float PlayAnimMontage(class UAnimMontage* AnimMontage, float InPlayRate = 1.f, FName StartSectionName = NAME_None) override;
/** Stop playing montage */
virtual void StopAnimMontage(class UAnimMontage* AnimMontage) override;
/** Stop playing all montages */
void StopAllAnimMontages();
public:
/** Performs character checks when the reloading is complete (Not input related)*/
void OnStopReload();
//////////////////////////////////////////////////////////////////////////
// Camera
/** [server + local] change targeting state */
void SetAiming(bool bNewAiming);
protected:
/** Update targeting state */
UFUNCTION(Reliable, server, WithValidation)
void ServerSetAiming(bool bNewAiming);
//////////////////////////////////////////////////////////////////////////
// Damage and health system
UFUNCTION()
void OnHealthChanged(UCSHealthComponent* OwningHealthComp, float Health, float Damage, const class UDamageType* DamageType, class AController* InstigatedBy, AActor* DamageCauser);
//////////////////////////////////////////////////////////////////////////
// Replication
/** Update hud when current weapon has changed */
UFUNCTION()
void OnRep_CurrentWeapon();
protected:
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UCameraComponent* CameraComp;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
USpringArmComponent* SpringArmComp;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components")
UCSHealthComponent* HealthComp;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess="true"))
UAbilitySystemComponent* AbilitySystem;
UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Components", meta = (AllowPrivateAccess="true"))
UCSAttributeSet* AttributeSet;
UPROPERTY(EditDefaultsOnly, Category = "Player")
float ZoomedFOV;
UPROPERTY(EditDefaultsOnly, Category = "Player", meta = (ClampMin = 0.1, ClampMax = 100.0f))
float ZoomInterpSpeed;
float DefaultFOV;
/** Check if character was aiming before start reloading */
bool bWasAiming;
/** Is Aiming Down Sights? */
UPROPERTY(Transient, Replicated)
bool bAiming;
UPROPERTY(VisibleDefaultsOnly, Category = "Player")
FName WeaponAttachSocketName;
UPROPERTY(Transient, ReplicatedUsing = OnRep_CurrentWeapon)
ACSWeapon* CurrentWeapon;
UPROPERTY(EditDefaultsOnly, Category = "Player")
TSubclassOf<ACSWeapon> StarterWeaponClass;
UPROPERTY(Replicated)
bool bDied;
/** Material instances for setting team color on mesh */
UPROPERTY(Transient)
TArray<class UMaterialInstanceDynamic*> MeshMIDs;
public:
/** Event raised on aiming is changed */
UPROPERTY(BlueprintAssignable, Category = "Player")
FCharacterAimStateChangedSignature OnAimStateChange;
/** Event raised when character equips new weapon */
UPROPERTY(BlueprintAssignable, Category = "Player")
FCharactereEquipWeaponSignature OnWeaponEquip;
UFUNCTION(BlueprintCallable, Category = "Player | Abilities")
void AcquireAbility(TSubclassOf<UGameplayAbility> AbiltyToAcquire);
//////////////////////////////////////////////////////////////////////////
// Statistics
void RegisterAction(ECharacterAction Action, float Amount = 0.0f);
//////////////////////////////////////////////////////////////////////////
// Materials
/** Handle mesh colors on specified material instance */
void UpdateTeamColors(UMaterialInstanceDynamic* UseMID);
/** Update the team color of all player meshes. */
void UpdateTeamColorsAllMIDs();
public:
//////////////////////////////////////////////////////////////////////////
// Reading data
// Current equipped weapon
UFUNCTION(BlueprintCallable, Category = "Character")
ACSWeapon* GetCurrentWeapon() const;
// Get health component
UFUNCTION(BlueprintCallable, Category = "Character")
UCSHealthComponent* GetHealthComponent() const;
/** Check if pawn is aiming down sights */
UFUNCTION(BlueprintCallable, Category = "Character")
bool IsAiming() const;
/** Check if character is alive */
UFUNCTION(BlueprintCallable, Category = "Character")
bool IsAlive() const;
/** Get Weapon Socket Name */
FName GetWeaponAttachPoint() const;
};
|
#include <iostream>
using namespace std;
int main()
{
int year = 0;
int done = 0;
while(done == 0)
{
do {
cout << "Please Enter the year : ";
cin >> year;
}while (year <= 1000 || year >= 3000);
int a = 0;
a = year - (year % 1000);
if ( a == 1000)
{
cout << "M";
}
else
{
cout << "MM";
}
year = year - a;
a = year - (year % 100);
if (a > 500 && a < 1000)
{
if (a >= 700)
{
for (int i = 1000; i > a; i = i - 100)
{
cout << "C";
}
cout << "M";
}
else
{
cout << "DC";
}
}
else if (a < 500 && a > 100)
{
if (a >= 200)
{
for (int i = 500; i > a; i = i - 100)
{
cout << "C";
}
cout << "D";
}
else
{
cout << "C";
}
}
else if (a == 500)
{
cout << "D";
}
year = year - a;
a = year - (year % 10);
if (a > 50 && a < 100)
{
if (a >= 70)
{
for (int i = 100; i > a; i = i - 10)
{
cout << "X";
}
cout << "C";
}
else
{
cout << "LX";
}
}
else if (a < 50 && a > 10)
{
if (a >= 20)
{
for (int i = 50; i > a; i = i - 10)
{
cout << "X";
}
cout << "L";
}
else
{
cout << "X";
}
}
else if (a == 50)
{
cout << "L";
}
year = year - a;
a = year;
if (a > 5 && a < 10)
{
if (a >= 7)
{
for (int i = 10; i > a; i--)
{
cout << "I";
}
cout << "X";
}
else
{
cout << "VI";
}
}
else if (a < 5 && a > 0)
{
if (a >= 2)
{
for (int i = 5; i < a; i--)
{
cout << "I";
}
cout << "V";
}
else
{
cout << "I";
}
}
else if (a == 5)
{
cout << "V";
}
}
}
|
//#include "stdafx.h"
#include "Track.h"
#include <string>
using std::string;
using std::to_string;
const char* Track::getTargetsQuery = "SELECT distinct TARGETID FROM m_preprocessing;";
//extern vector<Track> HistoryTracks;
char* Track::getTargetRecords(char* targetID) {
char* res = new char[800];
sprintf_s(res, 800, "SELECT TARGETID,POSIXTIME,SOURCE,LONGITUDE,LATITUDE,ALTITUDE,OPERATOR,RESERVE1,RESERVE2,TASKINFO,SPEED,ANGLE FROM m_preprocessing WHERE TARGETID = '%s' ORDER BY POSIXTIME; ", targetID);
return res;
//return string("SELECT TARGETID,POSIXTIME,SOURCE,LONGITUDE,LATITUDE,ALTITUDE,OPERATOR,RESERVE1,RESERVE2,TASKINFO FROM preprocessing_copy WHERE TARGETID = '").append(targetID).append("'ORDER BY POSIXTIME; ");
}
Track::Track()
{
}
Track::Track(int trackID, char* TARGETID, char* SOURCE, char* TASKINFO, char* OPERATOR, int STARTTIME) {
this->TRACKID = trackID;
this->TARGETID = TARGETID;
this->SOURCE = SOURCE;
this->TASKINFO = TASKINFO;
this->OPERATOR = OPERATOR;
this->POINTAMOUNT = 1;
this->STARTTIME = STARTTIME;
this->CONFIDENCELEVEL = 1;
}
Track::Track(int trackID, char * TARGETID, char * SOURCE, char * TASKINFO, char * OPERATOR, char * STARTTIME)
{
this->TRACKID = trackID;
this->TARGETID = TARGETID;
this->SOURCE = SOURCE;
this->TASKINFO = TASKINFO;
this->OPERATOR = OPERATOR;
this->POINTAMOUNT = 1;
this->STARTTIME = atoi(STARTTIME);
this->CONFIDENCELEVEL = 1;
}
Track::Track(char * trackID, char * POINTAMOUNT, char * TARGETID, char * STARTTIME, char * ENDTIME, char * LENGTH, char * SOURCE, char * TASKINFO, char * CONFIDENCELEVEL, char * OPERATOR, char * RESERVE1, char * RESERVE2)
{
this->TRACKID = atoi(trackID);
this->POINTAMOUNT = atoi(POINTAMOUNT);
this->TARGETID = TARGETID;
this->STARTTIME = atoi(STARTTIME);
this->ENDTIME = atoi(ENDTIME);
this->length = atof(LENGTH);
this->SOURCE = SOURCE;
this->TASKINFO = TASKINFO;
this->CONFIDENCELEVEL = atof(CONFIDENCELEVEL);
this->RESERVE1 = RESERVE1;
this->RESERVE2 = RESERVE2;
}
int Track::getTrackID() {
return this->TRACKID;
}
void Track::setEndTime(int endTime) {
this->ENDTIME = endTime;
}
int Track::getEndTime()
{
return this->ENDTIME;
}
int Track::getStartTime()
{
return this->STARTTIME;
}
int Track::getPointAmount()
{
return this->POINTAMOUNT;
}
void Track::setPointAmount(int pointAmount) {
this->POINTAMOUNT = pointAmount;
}
void Track::setStartTime(int startTime)
{
this->STARTTIME = startTime;
}
void Track::setTrackID(int trackID) {
this->TRACKID = trackID;
}
void Track::setTrackIDofPoint(int trackID) {
for (vector<TrackPoint>::iterator i = this->historyPoint.begin(); i != historyPoint.end(); i++) {
(*i).setTrackID(trackID);
}
}
void Track::setLength(double length) {
this->length = length;
}
void Track::setTargetID(char * id)
{
this->TARGETID = id;
}
string Track::getTargetID()
{
return this->TARGETID;
}
string Track::insertHisSQL() {
string insertSql = "insert into m_historytrack_main (GUID,TRACKID,POINTAMOUNT,TARGETID,STARTTIME,ENDTIME,SOURCE,TASKINFO,CONFIDENCELEVEL,OPERATOR,LENGTH) values(";
insertSql.append("UUID(),").append(to_string(this->TRACKID)).append(",").append(to_string(POINTAMOUNT)).append(",'").append(this->TARGETID).append("','")
.append(SqlTool::datetimeConvertor(this->STARTTIME)).append("','").append(SqlTool::datetimeConvertor(this->ENDTIME)).append("','").append(this->SOURCE).append("','").append(this->TASKINFO)
.append("',").append(to_string(this->CONFIDENCELEVEL)).append(",'").append(this->OPERATOR).append("',").append(to_string(this->length)).append(");");
return insertSql;
}
char * Track::insertFreqSQL()
{
char res[1000];
sprintf_s(res, 1000, "insert into m_frequentlytrack_main (GUID,TRACKID,POINTAMOUNT,TARGETID,STARTTIME,ENDTIME,LENGTH,CONFIDENCELEVEL,OPERATOR) VALUES\
(UUID(),%d,%d,%s,'%s','%s',%lf,1,'%s')", TRACKID, POINTAMOUNT, TARGETID.data(), SqlTool::datetimeConvertor(this->STARTTIME), SqlTool::datetimeConvertor(this->ENDTIME), length, OPERATOR);
return res;
}
void Track::trackEndProcession(int endTime, int pointAmount, vector<TrackPoint>details, double totallength) {
this->setEndTime(endTime);
this->setPointAmount(pointAmount);
this->setLength(totallength);
this->historyPoint.assign(details.begin(), details.end());
}
Track::~Track()
{
}
|
#include <functional>
#include <iostream>
#include <memory>
#include <sstream>
#include <string>
using namespace std;
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/serialization.hpp>
struct Address {
string street, city;
int suite;
friend ostream& operator<<(ostream& os, const Address& obj) {
return os << "street:\t" << obj.street << "\ncity:\t" << obj.city
<< "\nsuite:\t" << obj.suite << "\n-------------------------";
}
private:
friend class boost::serialization::access;
template <class Ar>
void serialize(Ar& ar, const unsigned int version) {
ar& street;
ar& city;
ar& suite;
}
};
struct Employee {
string name;
Address* address;
friend ostream& operator<<(ostream& os, const Employee& obj) {
return os << "name:\t" << obj.name << "\naddress:\n" << *obj.address;
}
private:
friend class boost::serialization::access;
template <class Archive>
void serialize(Archive& archive, const unsigned int version) {
archive& name;
archive& address;
}
};
int main() {
Employee john;
john.name = "John Doe";
john.address = new Address{"123 East Dr", "London", 123};
// Boost Serialization does a deep copy out-of-the box!
auto clone = [](Employee c) {
// Write employee to an archive
ostringstream oss;
boost::archive::text_oarchive oa(oss);
oa << c;
string s = oss.str();
// Read it back in. Deep copy automatically done!
Employee result;
istringstream iss(s);
boost::archive::text_iarchive ia(iss);
ia >> result;
return result;
};
Employee jane = clone(john);
jane.name = "Jane";
jane.address->street = "123B West Dr";
cout << john << endl << jane << endl;
return 0;
}
|
#include<iostream>
using namespace std;
class Rectangle {
int width, height;
public:
void set_value(int, int);
int area() {
return width*height;
}
};
//using scope operator (::)
void Rectangle::set_value(int x, int y) {
width = x;
height = y;
}
int main() {
Rectangle rect,rectb;
rect.set_value(3, 4);
rectb.set_value(5, 6);
cout << "첫번째 면적 area : " << rect.area()<<endl;
cout << "두번째 면적 area : " << rectb.area() << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.