language stringclasses 15
values | src_encoding stringclasses 34
values | length_bytes int64 6 7.85M | score float64 1.5 5.69 | int_score int64 2 5 | detected_licenses listlengths 0 160 | license_type stringclasses 2
values | text stringlengths 9 7.85M |
|---|---|---|---|---|---|---|---|
Java | UTF-8 | 6,416 | 2.5 | 2 | [
"Apache-2.0"
] | permissive | package com.huxq17.example.utils;
import android.content.Context;
import android.content.res.AssetFileDescriptor;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.media.MediaScannerConnection;
import android.media.ThumbnailUtils;
import android.net.Uri;
import android.os.Environment;
import android.text.TextUtils;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* ๅพ็ๅค็ๅทฅๅ
ท็ฑป
*
* @author wxl
*/
public class YnBitmapUtils {
/**
* appๅ
ๅ
*/
private static final String APPPACKAGENAME = "com.yueniapp.sns";
/**
* ้ๆพbitmap
*
* @param bitmap
*/
public static void freeeBitmap(Bitmap bitmap) {
if (null != bitmap && !bitmap.isRecycled()) {
bitmap.recycle();
}
}
/**
* ้ป่ฎค็bitmapๅ็ผฉ==ใ้ป่ฎคไฟๅญๅฐsd/yueniapp/ไธ ไปฅๅๅคงๅฐๅ็ผฉ
* @param bitmap
* @return
*/
public static String compressBitmapDefault(Bitmap bitmap, int compressSize, CompressFormat type) {
FileOutputStream fileOutputStream = null;
String path = YnBitmapUtils.getProjectSDCardPath();
try {
fileOutputStream = new FileOutputStream(new File(path));
bitmap.compress(type, compressSize, fileOutputStream);
fileOutputStream.flush();
} catch (Exception e) {
LogUtil.i("info",e.getMessage(),e);
} finally {
try {
if(null != fileOutputStream) {
fileOutputStream.close();
}
} catch (Exception e) {
LogUtil.i("info",e.getMessage(),e);
}
}
return path;
}
/**
* ่ทๅพ้กน็ฎSDๅก็ไฝ็ฝฎ
*/
public static String getProjectSDCardPath() {
String sdcard_path = "";
// ๅคๆญSDๅกๆฏๅฆไธบ็ฉบ
if (!Environment.MEDIA_REMOVED.equals(Environment.getExternalStorageState())) {
sdcard_path = FileManager.getFilePath();
String strDate = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
sdcard_path = sdcard_path + APPPACKAGENAME + File.separator + "ypcrop" + strDate + ".jpg";
File file = new File(FileManager.getFilePath() + File.separator + APPPACKAGENAME);
if (!file.exists()) {
file.mkdirs();
}
}
return sdcard_path;
}
/**
* ็จๆฅๅค็ๅพ็็ๅคชๅคง็้ฎ้ข
* @param context
* @param selectedImage ๅพ็็uri
* @return
* @throws FileNotFoundException
*/
public static Bitmap decodeUri(Context context, Uri selectedImage) throws FileNotFoundException {
BitmapFactory.Options options = new BitmapFactory.Options();
int width = 1080;
options.inSampleSize = ImageUtil.computeSampleSize(options, -1, width * width);// ๅพๅฐ็ผฉ็ฅๅพ;
AssetFileDescriptor fileDescriptor ;
fileDescriptor = context.getContentResolver().openAssetFileDescriptor(selectedImage, "r");
Bitmap actuallyUsableBitmap = BitmapFactory.decodeFileDescriptor(fileDescriptor.getFileDescriptor(), null, options);
actuallyUsableBitmap = ThumbnailUtils.extractThumbnail(actuallyUsableBitmap, width, width);
return actuallyUsableBitmap;
}
/*
* ไปๆฐๆฎๆตไธญ่ทๅพๆฐๆฎ
*/
public static byte[] readInputStream(InputStream inputStream) throws IOException {
byte[] buffer = new byte[1024];
int len ;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
while ((len = inputStream.read(buffer)) != -1) {
bos.write(buffer, 0, len);
}
bos.close();
inputStream.close();
return bos.toByteArray();
}
/**
* ็ฝ็ปไธ่ฝฝๅพ็
*/
public static byte[] getImageFromNet(String path) {
byte[] b = null;
try {
URL url = new URL(path);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("GET");
conn.setConnectTimeout(5 * 1000);
InputStream inputStream = conn.getInputStream();
if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
b = readInputStream(inputStream);
}
}catch (Exception e){
LogUtil.i("info",e.getMessage(),e);
}
return b;
}
/**
* ๆ็
งๆถๆๅฎUri
*/
public static String imagePath = null;
public static Uri getCameraUri() {
Uri uri ;
String state = Environment.getExternalStorageState();
if (!TextUtils.isEmpty(state) && state.equals(Environment.MEDIA_MOUNTED)) {
File file = new File(FileUtil.PATH);
if (!file.exists()) {
file.mkdirs();
}
} else { // ่ฟๅๆๆบ็ๅ
ๅญๅฐๅ
File file = new File(Environment.getDataDirectory().getAbsolutePath() + "/data/");
if (!file.exists()) {
file.mkdirs();
}
}
String strDate = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
// ็
ง็็ๅๅญ
String imageName = "yeuniapp_" + strDate + ".jpg";
// ๅพ็็่ทฏๅพ
imagePath = FileUtil.PATH + imageName;
uri = Uri.fromFile(new File(imagePath));
return uri;
}
/**
* ไฟๅญๅพ็ๅฐ็ธๅ
*/
public static void savePic(Context context, String folderName, String fileName, Bitmap bitmap) {
File path = Environment.getExternalStoragePublicDirectory(Environment.DIRECTORY_PICTURES);
System.out.println("path===="+path.toString());
File file = new File(path, folderName + "/" + fileName);
file.getParentFile().mkdirs();
try {
bitmap.compress(CompressFormat.JPEG, 90, new FileOutputStream(file));
MediaScannerConnection.scanFile(context, new String[]{file.toString()}, null, null);
} catch (FileNotFoundException e) {
LogUtil.i("info",e.getMessage(),e);
}
}
}
|
JavaScript | UTF-8 | 6,588 | 2.546875 | 3 | [
"MIT"
] | permissive | const express = require("express");
const users = express.Router();
//Middleware
const protect = require("../middleware/authMiddleware");
//Functions from Controller
const registerUser = require("../controllers/userController").registerUser;
const loginUser = require("../controllers/userController").loginUser;
const getAllUsers = require("../controllers/userController").getAllUsers;
const getUserById = require("../controllers/userController").getUserById;
const registerInstructor = require("../controllers/userController")
.registerInstructor;
/**
* @swagger
* components:
* schemas:
* User:
* type: object
* required:
* -id
* -firstName
* -lastName
* -userName
* -email
* -password
* -isInstructor
* properties:
* id:
* type: string
* description: Autogenerated ID by db
* firstName:
* type: string
* description: The first name of the user
* lastName:
* type: string
* description: The last name of the user
* userName:
* type: string
* description: The user's username
* email:
* type: string
* description: The user's email
* password:
* type: string
* description: the users email address
* isInstructor:
* type: boolean
* description: Determines if the usr is an instructor
* courses:
* type: Array
* description: The list of courses the user has created.
*
*/
/**
* @swagger
* tags:
* name: Users
* description: Users routes
*/
/**
* @swagger
* /api/users/register:
* post:
* summary: Registers one user into the database
* tags: [Users]
* parameters:
* - in: body
* name: user
* description: The user information to add to database
* schema:
* type: object
* required:
* -firstName
* -lastName
* -userName
* -email
* -password
* properties:
* firstName:
* type: string
* lastName:
* type: string
* userName:
* type: string
* email:
* type: string
* password:
* type: string
* responses:
* 200:
* description: Successfully registered one into database.
* 401:
* description: Something went wrong registering a user.
*
*/
users.route("/register").post(registerUser);
/**
* @swagger
* /api/users/login:
* post:
* summary: Authenticates a user
* tags: [Users]
* parameters:
* - in: body
* name: user
* description: The users login information
* schema:
* type: object
* required:
* -email
* -password
* properties:
* email:
* type: string
* password:
* type: string
* responses:
* 200:
* description: User successfully authenticated.
* content:
* application/json:
* schema:
* type: object
* properties:
* firstName:
* type: string
* lastName:
* type: string
* userName:
* type: string
* Token:
* type: string
* 401:
* description: Something went wrong registering a user.
* 409:
* description: Incorrect username or password
*
*/
users.route("/login").post(loginUser);
/**
* @swagger
* /api/users/all:
* get:
* summary: Returns all users in database
* tags: [Users]
* responses:
* 200:
* description: An array of objects with user information
* 401:
* description: An error occured getting the list of users.
*
*/
users.route("/all").get(getAllUsers);
/**
* @swagger
* /api/users/user/{id}:
* get:
* summary: Returns one user that is found by the users id.
* tags: [Users]
* parameters:
* - in: header
* name: JSON Web Token
* type: string
* required: true
* - in: path
* name: id
* schema:
* type: string
* required: true
* description: the id of a user.
* responses:
* 200:
* description: The information of one users returns
* contents:
* application/json:
* schema:
* $ref: '#/components/schemas/User'
*
* 404:
* description: User was not found.
* 401:
* description: Not authorized.
*
*/
users.route("/user/:id").get(protect, getUserById);
/**
* @swagger
* /api/users/instructor/register:
* post:
* summary: Registers one instructor into the database
* tags: [Users]
* parameters:
* - in: body
* name: user
* description: The user information to add to database
* schema:
* type: object
* required:
* -firstName
* -lastName
* -userName
* -email
* -password
* properties:
* firstName:
* type: string
* lastName:
* type: string
* userName:
* type: string
* email:
* type: string
* password:
* type: string
* responses:
* 200:
* description: Successfully registered one instructor into database.
* 401:
* description: Something went wrong registering an instructor.
*
*/
users.route("/instructor/register").post(registerInstructor);
module.exports = users;
|
Markdown | UTF-8 | 5,562 | 2.703125 | 3 | [
"MIT"
] | permissive | ## 2017.7.22.
## Sungkyu Cho - sungkyu1.cho@gmail.com
PWNABLE KR - TODDLER - Passcode - 10pt
์ฝ๊ฒ ํ๋ฆด ์ค ์์๋ ๋ฌธ์ ์ธ๋ฐ, ์์ธ๋ก ์ ๋ง ์ค๋ซ๋์ ์ ๋ฅผ ๋จน์๋ ๋ฌธ์ .
์ด์ ๋ ๋์ค์ ์ค๋ช
์ ํ๊ฒ ์ง๋ง, ์์ ํํธ์ ๋ํด์ ๋๋ฌด ์ฝ๊ฒ ์๊ฐํ๋ ๋ด ์์ดํจ์ด ํฐ ์์ธ์ด์๋ค.
# 0.์ฐ์ ์ ์์ค์ฝ๋ ์ดํด๋ณด๊ธฐ
passcode.c ํ์ผ์ ์ดํด๋ณด๋ฉด welcome() ์์ username ์ ๋ฐ๊ณ , login()์์ ๋ชจ๋ ๋น๊ต ์์
์ ํ๋ ๊ฒ์ ์ ์ ์์. ๋งค์ฐ ๊ฐ๋จํ ์ฝ๋.
๊ทธ๋ผ ์ด์ ์ค์ ๋ก ์ด๋ ๋ณด๋ฉด ์ข์์ง๋ฅผ ์๊ธฐ ์ํด์ gdb ๋ก asm ์ฝ๋๋ฅผ ๋ณด๋
* passcode1 ์๋ 338150, passcode2 ์๋ 13371337์ ์ง์ด๋ฃ์ผ๋ฉด flag๋ฅผ ์ก์ ๊ฒ์ด๊ณ
* passcode1 ๊ณผ passcode2๋ ์๋ง๋ ```$ebp-0x10``` ๊ณผ ```$ebp-0xc```์ ์์ ๊ฒ์ผ๋ก ์ถ์ ๋จ
- ์ด์ ๋,cmp ๋ช
๋ น์ด๊ฐ ๋ ๋ฒ ๋ณด์ด๋๋ฐ ๊ทธ๊ฒ ๊ฐ๊ฐ 338150๊ณผ 13371337์ ๋น๊ตํ๊ธฐ ์ํ ๊ฒ์ผํ
๊ณ
- ๊ทธ ๋น๊ต ๋์์ด๋ผ๊ณ ํ๋ฉด ๊ฒฐ๊ตญ passcode1๊ณผ passcode2 ๋ฐ์ ์๊ธฐ ๋๋ฌธ์
* ์๋ง๋ ์ถ์ ํ๊ธธ ~~์ถ์ ์ ๊ธ๋ฌผ. ๋ ๋ค ํ๋ ค~~ username์ผ๋ก ๋ฐ์๋ค์ธ ๋ณ์๊ฐ passcode1๊ณผ passcode2์ ์ฐฉ์ฐฉ ๋ค์ด๊ฐ๊ฒ ์ง? ๋ผ๋ ์ฐฉ๊ฐ์ผ๋ก ์กฐ๊ธ ๋ ์ดํด๋ณด๊ธฐ ์์ํจ
# 1.์ฒ์์ ์ฝ๊ฒ ์๊ฐํ๋ ์ด์
๋์๋ด์ฉ์ ๋ณด๋ฉด "name" ๋ณ์์ string ์ ๋ฐ์๋ค์ด๋๋ฐ, ์๋ง๋ ์ฌ๊ธฐ์ ๋ญ๊ฐ ํฐ์ง๋ ๋ถ๋ถ์ด ์๊ฒ ๊ฑฐ๋ ํ๋ ๋ง์์ผ๋ก ๋งค์ฐ ๊ธด string์ ํฌํจ์์ผฐ์
์ด ๋, ์ด๋์ ์๋ฌ๋ฅผ ๋ฐ์์ํค๋์ง ์์น๋ฅผ ์ ํํ๊ฒ ํ์
ํ๊ธฐ ์ํด์ ์ฌ์ฉํ string์ ์๋์ ๊ฐ์
```0123456789abcdefghijklmnopqrstuvwxyz0a0b0c0d0f0g0h0i0j0k0l0m0n0o0p0q0r0s0t0u0v0w0x0y0z1a1b1c1d1e1f1g1h1i1j1k1l1m1n1o1p1q1r1s1t1u1v1w1x1y1z2a2b2c2d2e2f2g2h2i2j2k2l2m2n2o2p2q2r2s2t2u2v2w2x2y2z```
* ์์๊ณผ ๋น์ทํ๊ฒ ```$ebp-0x10```๊ณผ ```$ebp-0xc```์๋ ๋น๊ต ๋์์ด ํฌํจ๋์๊ณ , ```$ebp-0x10```์ ```name``` ๋ณ์์ ๋งจ ๋ง์ง๋ง 4 byte๊ฐ ๋ค์ด๊ฐ๋ ๊ฒ์ ํ์ธํจ
* 0x67316631์ ```1f1g``` ์ด๋ฏ๋ก ์
๋ ฅ ๋งจ ๋ง์ง๋ง ๋ณ์๊ฐ ๋น๊ต๋์์ผ๋ก ํฌํจ๋๋ ๊ฒ์ ์ ์ ์์์
# 2. ์๋ จ์ ์ฌ๊ธฐ๋ถํฐ
์ฑํ ์ฝ์ง์ ํด๋, ์ด๋ป๊ฒ๋ ```passcode1```์๋ ๊ฐ์ด ๋ค์ด๊ฐ๊ณ ๋ ๋น๊ต๋ฌธ๊ตฌ๋ ํต๊ณผ๋ ํ์ง๋ง
* ๋ ๊ธด ~~๊ทธ๋ฆฌ๊ณ ๋ ๊ธด, ๊ธด...~~~ username ์ ๋ฃ์ด๋ด๋
* username์ ์งง๊ฒ ํ๊ณ passcode1์ ๊ธด ๊ฐ์ ๋ฃ์ด๋ด๋
์๋ฌด๋๋ ๋ ์งํ์ ์ด๋ ค์ ๋๋ฐ...(์ฌ์ค ๊ฑ ํฌ๊ธฐํ ์ํ์๊ณ , ๊ทธ ์ดํ์ pwnable kr ์ ๋ชจ๋ ํ์ด๋ณด์๋ ๊ทธ๋ฃน์ ๊ฐ์
)
# 3. Assist
GOT์ PLT๋ฅผ ๋ด๋ณด๋ผ๋ ์กฐ์ธ์ผ๋ก ๋ค์ ์์.
[GOT์ PLT #1](https://bpsecblog.wordpress.com/2016/03/07/about_got_plt_1/)
[GOT์ PLT #2](http://expointer.tistory.com/13)
* Special thanks to @hackpupu & @min
# 4. Reload
(์์ ๋งํ๋ ๊ฒ์ฒ๋ผ)๊ฒฐ๋ก ์ ์ผ๋ก ๋ด๊ฐ ๊ฐ์ฅ ๋ฑํ์ ํ๋ ๋ถ๋ถ์ด ๋ฐ๋ก scanf ํจ์์ ๋ํ ์ดํด์์. scanf๋ฅผ ๋๋ฌด ์ฝ๊ฒ ์ฌ์ฉํ์์๋ ๊ทธ๊ฒ์ ๋ํด์ ์ ๊ณ ๋ฏผํด๋ณด๋ ์๊ฐ์ด ์์๋ํฐ๋ผ..
[scanf ์ค๋ช
~~๋๋ฌด๋ ๋น์ฐํ~~~](http://itguru.tistory.com/36)
๊ณฐ๊ณฐํ ์ ์๊ฐํด๋ณด๋ฉด
1) scanf("%d", &var)๋ var์ ์ฃผ์๊ฐ 0x0add ๋ผ๋ฉด 0x0add์ ์
๋ ฅ๋ฐ์ 10์ง์ ์๋ฅผ ์ ์ฅํ๋ผ๋ ๊ฒ์ด๊ณ 1000์ ์
๋ ฅํ๋ฉด 0x0add = 1000 ์ด ๋๋ค. ~~~๋น์ฐํ์ง~~~
2) ๊ทผ๋ฐ ํ์ฌ passcode ์์์์ code ๋ ```&``` ๊ฐ ์๋ ์ํ์ธ๋ฐ ์ฌ๊ธฐ์ 1000์ ์
๋ ฅํ๋ฉด
- 1000์ด๋ผ๋ ์ฃผ์๋ฅผ ์ฌ์ฉ์๊ฐ ์ง์ ํ๊ฒ ๋์ด๋ฒ๋ฆฌ๋ ๊ผด
- ๋ฐ๋ผ์, scanf ํจ์ ๋ด์์ ๋น์ฐํ ์ฃฝ์ด๋ฒ๋ฆฌ๊ฒ ๋จ
3) ๊ฒฐ๋ก ์ ์ผ๋ก **์ฝ๋์์ ์์ฑ๋ scanf์ bug๋ฅผ ์ด์ฉํ์ฌ exploit ํ๋ ๋ฐฉํฅ์ด์๊ณ , ์ด ๋ ํ์ฉํ ์ ์๋ ์นด๋๊ฐ GOT&PLT** ์๋ ๊ฒ์
4) ๊ทธ๋ผ ๋์์ด ์ด๋ป๊ฒ ๋์ด์ผ ํ ๊ฒ์ด๋๋ฅผ ๋ณด๋ฉด, ์ ```gdb) disas login``` ์์์ ์ญ ๋ณด๋ฉด ์๊ฒ ์ง๋ง, ๊ฐ๋จํ๊ฒ fflush๊ฐ ๋ฐ์ด์ผ ํ ์ ์ ์ฃผ์๊ฐ ์๋, ```cmp``` ๋ช
๋ น์ด ์ดํ์ ```0x80485e3```์ผ๋ก ๋ฐ๋ฉด ๋๋ค. ๋ฐ๋ก ๋ค์ system ํจ์๊ฐ ํธ์ถ๋๋ ```0x80485ea```๋ก ๋ฐ์ง ์๋ ์ด์ ๋ ๊ฐ๋จํ๋ค. ``` "/bin/cat flag" ``` ๋ผ๋ ๋ฌธ์์ด์ด ์
์
๋ ์ดํ์ ๋ฐ์ด์ผ ํ๊ธฐ ๋๋ฌธ์
_๊ฐ์ ๋ก ```eip```๋ฅผ 0x80485e3์ผ๋ก ๋ณ๊ฒฝํ ํ ์คํ์ ์ฌ๋ผ์จ ๊ฐ์ ํ์ธํด๋ณด๋ฉด /bin/cat flag๊ฐ ์ถ๊ฒฉ ๋๊ธฐ์ค์_
๊ฒฐ๋ก ์ ์ผ๋ก, scanf๋ฅผ ํตํด(+์ฝ๋ ๋ฒ๊ทธ)
+ passcode1์ ๊ฐ(100byte ๋์ ๋ง์ง๋ง 4byte)๋ฅผ ์ง์ ํ ์ ์๊ณ
+ passcode1๊ฐ ์์นํ ์ฃผ์๋ฅผ ์ ํ ์ ์์ผ๋ฏ๋ก
+ ํน์ ์์น์ ๊ทธ ๊ฐ์ ์ง์ ํ ์ ์๋ค๋ ์๊ธฐ์ด๋ฉฐ
+ ์ด ์กฐ๊ฑด์ fflush ํจ์๋ฅผ ์ดํด๋ณด๋ฉด ์๊ฒ๋๋ฏ์ด, plt ๋ฅผ ํตํด ```jmp *(addr)``` ์ ํ์์ผ๋ก ์ง์ ๋์ด ์๋ fflush ํจ์๋ฅผ ํ์ฉํ ํน์ ์์น๋ก์ ์ฝ๋ ์ ํ๋ฅผ ๊ฐ๋ฅํ๊ฒ ํจ (์๋ ๊ทธ๋ฆผ ์ฐธ์กฐ)
# 5. Exploit
payload ๊ตฌ์ฑ์ ์๋์ ๊ฐ์
+ 96byte์ ์๋ฏธ์๋ byte stream -> "A"
+ scanf๋ฅผ ํตํด ์
๋ ฅ๋ passcode1์ ์์น(์ฃผ์๊ฐ) -> ```"0x8048a004"``` (fflush ์๋ ์ฝ๋๊ฐ ์์นํ๋ jmp ์ดํ์ ์ฃผ์)
+ scanf์์ ๋ค์ด๊ฐ ```passcode1```๊ฐ (```jmp```๋ฅผ ํตํด ์ด๋๋ก ๋ธ ์ง ์ฃผ์๊ฐ) -> ```0x80485e3```(fflush๋ฅผ ํตํด ๋์ํ๊ฒ ๋ ์ฝ๋ ์์น)
์ฌ๊ธฐ์ ```134514147```์ ```0x80485e3```์ decimal value์ธ๋ฐ. ์ด๊ฑธ hexa๋ก ๋ฃ์์ง, ```""``` ๋ฅผ ๋ฃ์์ง ๋บ์ง ๊ฐ์ง๊ณ ๋ ํ์ฐธ ์ฝ์งํ๋ ๊ฒ์ ๋น๋ฐ. ๊ทผ๋ฐ ๊ทธ ๋น๋ฐ์ ์ด์ ๋ ๊ฒฐ๊ตญ ```scanf```๊ฐ ๊ฐ์ง๊ณ ์์๋ค. ```%d"```๋ก ๊ฐ์ ๋ฐ์๋ค์์ผ๋, ๋น์ฐํ decimal๋ก ์
๋ ฅํด์ผ ํ๋ ๊ฒ์ด๋๊น..ใ
|
C++ | UTF-8 | 1,614 | 3.203125 | 3 | [] | no_license | /*
CSE 109: Fall 2018
Lydia Cornwell
lac221
Makes hash map
Program #6
*/
#ifndef HASH_H
#define HASH_H
#include<vector>
#include<cstring>
#include<string>
#include<iostream>
#include<sstream>
using namespace std;
class Hash_t
{
public:
Hash_t();
Hash_t(size_t buckets);
Hash_t(size_t buckets, int(*hashfunc)(const void*, size_t));
Hash_t(Hash_t &src);
Hash_t& operator=(const Hash_t&);
bool insert(unsigned int);
Hash_t& operator+=(unsigned int);
bool find(unsigned int);
bool remove(unsigned int);
Hash_t& operator-=(unsigned int);
string to_string() const;
size_t size() const;
bool resize(size_t);
friend ostream& operator<<(ostream&, const Hash_t&);
class iterator
{
friend class Hash_t;
public:
iterator();
iterator(std::vector<std::vector<unsigned int> >*, size_t, size_t);
iterator(const iterator&);
iterator& operator=(const iterator&);
bool operator!=(const iterator&) const;
bool operator==(const iterator&) const;
iterator operator+(size_t amt) const;
iterator& operator+=(size_t amt);
iterator operator-(size_t amt) const;
iterator& operator-=(size_t amt);
iterator& operator++();
iterator& operator--();
//postfix
iterator operator++(int);
iterator operator--(int);
const unsigned int& operator*() const;
private:
std::vector<std::vector<unsigned int> >* bucket_ptr;
size_t bucket_idx;
size_t data_idx;
};
iterator begin();
iterator end();
iterator remove(iterator& it);
private:
vector<vector<unsigned int>> buckets;
int(*function)(const void*, size_t);
size_t _size;
unsigned int getIndex(const unsigned int&) const;
};
#endif
|
Java | UTF-8 | 466 | 1.695313 | 2 | [
"Apache-2.0"
] | permissive | package io.ebeaninternal.api;
import io.ebeaninternal.server.querydefn.OrmQueryProperties;
import java.util.List;
/**
* The secondary query paths for 'query joins' and 'lazy loading'.
*/
public interface SpiQuerySecondary {
/**
* Return a list of path/properties that are query join loaded.
*/
List<OrmQueryProperties> queryJoins();
/**
* Return the list of path/properties that are lazy loaded.
*/
List<OrmQueryProperties> lazyJoins();
}
|
Java | UTF-8 | 380 | 2.859375 | 3 | [] | no_license | package nl.capgemini.diving.assignmentdequeu;
public class Task {
private String personName;
public Task(String personName) {
this.personName = personName;
}
public String getPersonName() {
return personName;
}
public void execute() {
System.out.println("This is a Task which is invoked for name: "+getPersonName());
}
}
|
C# | UTF-8 | 1,901 | 2.71875 | 3 | [] | no_license | ๏ปฟusing System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.Mvc;
using fitapp.DAL;
using fitapp.Models;
using fitapp.ViewModels;
using PagedList;
namespace fitapp.Controllers
{
public class HomeController : Controller
{
private FitappDbContext db = new FitappDbContext();
//INDEX - zawartosc do usuniecia
public ActionResult Index()
{
var products = db.Products.ToList();
return View(products);
}
// SEARCH
public ActionResult Search(string searchQuery)
{
var products = db.Products.Where(p => p.Name.ToLower().StartsWith(searchQuery.ToLower()) || searchQuery == null).ToList();
return View(products);
}
// PRODUCT SUGGESTIONS
public ActionResult ProductsSuggestions(string term)
{
var products = this.db.Products.Where(p => p.Name.ToLower().StartsWith(term.ToLower())).Take(10).Select(p => new { label = p.Name });
return Json(products, JsonRequestBehavior.AllowGet);
}
// SZCZEGรลY PRODUKTU
//public ActionResult Details(int id)
//{
// var product = db.Products.Find(id);
// if (product == null)
// {
// return HttpNotFound();
// }
// return View(product);
//}
// CAลA BAZA PRODUKTรW
public ActionResult ProductsList(int? page = 1)
{
var products = db.Products.ToList();
int pageNumber = (page ?? 1);
int productsOnPage = 20;
return View(products.ToPagedList(pageNumber, productsOnPage));
}
// STATIC CONTENT
public ActionResult StaticContent(string viewname)
{
return View(viewname);
}
}
} |
Java | UTF-8 | 423 | 2.953125 | 3 | [] | no_license | package com.company;
public class Circle extends Shape{
private String name;
public Circle(int height, int width) {
super(height, width);
}
@Override
float AreaCalc() {
return 0;
}
@Override
int getCenter() {
return 0;
}
@Override
int CircumCalc() {
return 0;
}
@Override
boolean isInsideShape() {
return false;
}
}
|
PHP | UTF-8 | 1,806 | 3.265625 | 3 | [
"BSD-3-Clause"
] | permissive | <?php
if (!function_exists('dd')) {
/**
* Dump the passed variables and end the script.
*
* @param mixed
* @return void
*/
function dd($expression, $_ = null)
{
var_dump(func_get_args());
die(1);
}
}
if (!function_exists('object_get')) {
/**
* Get an item from an object using "dot" notation.
*
* @param object $object
* @param string $key
* @param mixed $default
* @return mixed
*/
function object_get($object, $key, $default = null)
{
if (is_null($key) || trim($key) == '') {
return $object;
}
foreach (explode('.', $key) as $segment) {
if (!is_object($object) || !isset($object->{$segment})) {
return value($default);
}
$object = $object->{$segment};
}
return $object;
}
}
if (!function_exists('class_basename')) {
/**
* Get the class "basename" of the given object / class.
*
* @param string|object $class
* @return string
*/
function class_basename($class)
{
$class = is_object($class) ? get_class($class) : $class;
return basename(str_replace('\\', '/', $class));
}
}
if (!function_exists('loop')) {
/**
* @param callable $handle
* @param integer $count
*/
function loop($handle, $count)
{
foreach (range(1, $count) as $i) {
$handle($i);
}
}
}
if (!function_exists('randomDate')) {
function randomDate($start_date, $end_date)
{
// Convert to timetamps
$min = strtotime($start_date);
$max = strtotime($end_date);
// Generate random number using above bounds
$val = rand($min, $max);
return $val;
}
} |
Java | UTF-8 | 3,271 | 2.203125 | 2 | [] | no_license | package com.springReactive.practice.utils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.xml.bind.ValidationException;
import org.springframework.http.HttpStatus;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerResponse;
import com.springReactive.practice.constant.CommonConstants;
import com.springReactive.practice.error.PlatformError;
import com.springReactive.practice.model.Anime;
import com.springReactive.practice.model.AnimeResponse;
import com.springReactive.practice.model.ValidationResult;
import reactor.core.publisher.Mono;
public final class PlatformErrorUtils {
private static Map<Integer, String> errorMessage = new HashMap<>();
static {
errorMessage.put(HttpStatus.NOT_FOUND.value(), CommonConstants.OBJECT_NOT_FOUND_ERROR);
errorMessage.put(HttpStatus.INTERNAL_SERVER_ERROR.value(),
CommonConstants.INTERNAL_SERVER_ERROR);
errorMessage.put(HttpStatus.BAD_REQUEST.value(), CommonConstants.BAD_REQUEST);
errorMessage.put(HttpStatus.CONFLICT.value(), CommonConstants.CONFLICT_REQUEST);
errorMessage.put(HttpStatus.UNPROCESSABLE_ENTITY.value(), CommonConstants.UNPROCESSABLE_ENTITY);
}
public static PlatformError createPlatformError(String userDesc, int statusCode) {
PlatformError error = new PlatformError();
error.setTimestamp(CommonUtils.getTimeStamp());
error.setMessage(userDesc);
error.setStatus(statusCode);
error.setError(errorMessage.get(statusCode));
return error;
}
public static ValidationResult createValidationResult(List<String> errors, HttpStatus status) {
ValidationResult validationResult = new ValidationResult();
validationResult.setFailureFlag(Boolean.TRUE);
validationResult.setErrors(errors);
validationResult.setStatus(status);
return validationResult;
}
private static Mono<ServerResponse> createErrorResponse(String message, int statusCode) {
return ServerResponse.status(statusCode)
.body(BodyInserters.fromObject(createPlatformError(message, statusCode)));
}
public static Mono<ServerResponse> handleExceptions(Throwable ex) {
if (ex instanceof ValidationException) {
String message = ex.getMessage();
String errorCode = ((ValidationException) ex).getErrorCode();
int statusCode = HttpStatus.valueOf(errorCode).value();
return ServerResponse.status(statusCode)
.body(BodyInserters.fromObject(createErrorResponse(message, statusCode)));
} else {
return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR).body(BodyInserters.fromObject(
createErrorResponse(HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(), 500)));
}
}
public static Mono<AnimeResponse> createValidationError(Anime anime) {
AnimeResponse animeResponse = new AnimeResponse();
PlatformError platformError = createPlatformError(
anime.getValidationResult().getErrors().toString(),
anime.getValidationResult().getStatus().value());
animeResponse.setError(platformError);
animeResponse.setStatus(HttpStatus.BAD_REQUEST.value());
animeResponse.setEntityStatus(CommonConstants.ERROR);
return Mono.just(animeResponse);
}
}
|
Java | UTF-8 | 1,208 | 3.890625 | 4 | [] | no_license | ///////////////////////////////////////////////////////////////////////////
//
// Java5401 Write a program that implements a Queue data structure.
// Complete the <remove(int i)> method so that it removes
// the parameter number, but leaves the remaining queue intact.
//
// eg.
// 43 92 41 39 10 32 62 17 29 51 35 44 24 15 72 66
//
// remove(6);
//
// 62 17 29 51 35 44 24 15 72 66
//
//
///////////////////////////////////////////////////////////////////////////
import java.util.*;
import static java.lang.System.*;
public class Java5401{
public static void main(String[] args) {
new Model();
}}
class Model
{
Queue<Integer> myQueue;
public Model()
{
myQueue = new LinkedList<Integer>();
myQueue.add(43);
myQueue.add(92);
myQueue.add(41);
myQueue.add(39);
myQueue.add(10);
myQueue.add(32);
myQueue.add(62);
myQueue.add(17);
myQueue.add(29);
myQueue.add(51);
myQueue.add(35);
myQueue.add(44);
myQueue.add(24);
myQueue.add(15);
myQueue.add(72);
myQueue.add(66);
out.println(myQueue);
for (int i = 0; i < 7; i++)
{
myQueue.poll();
}
out.println(myQueue);
}
}
|
Java | UTF-8 | 796 | 2.890625 | 3 | [] | no_license | package com.core;
public class Main {
private static int previousHash;
public static void main(String[] args) {
BlockChain blockchain = new BlockChain();
String[] SecondTransactions = new String[]{"First transaction: Kishore sent 100 dimecoins to Alice","Alice sent 150 dimecoins to Bob"};
String[] ThirdTransactions = new String[]{"Second transaction: Bob sent 100 dimecoin to kishore","Alice sent 50 dimecoins to Eve"};
blockchain.addBlock(SecondTransactions);
blockchain.addBlock(ThirdTransactions);
System.out.println();
System.out.println("***********************************************************");
System.out.println("List of Hashes in blockchain: ");
for (long i: blockchain.getBlockChainInstance().getBlockChain()){
System.out.println(i);
}
}
}
|
Java | UTF-8 | 2,007 | 4.125 | 4 | [] | no_license | /***********************************************************************************
(Suma elementos columna por columna) Escribe un mรฉtodo que devuelva la suma de todos *
* elementos en una columna especificada en una matriz usando el siguiente encabezado: *
* public static double sumColumnas (double [] [] m, int columnasIndex) *
* Escriba un programa de prueba que lea una matriz de 3 por 4 y muestre la suma de cada *
* columna. *
************************************************************************************/
package ejercicio08_01;
import java.util.Scanner;
/**
*
* @author sesion
*/
public class Ejercicio08_01 {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// Lea una matriz de 3 por 4
double[][] matrix = getMatrix();
// Muestra la suma de cada columna
for (int col = 0; col < matrix[0].length; col++) {
System.out.println(
"Suma de los elementos en la columna " + col +
" es " + sumColumnas(matrix, col));
}
}
/** etMatrix inicializa una matriz con valores de entrada del usuario
* @return */
public static double[][] getMatrix() {
// Crear el Scanner
Scanner input = new Scanner(System.in);
final int FILAS = 3;
final int COLUMNAS = 4;
double[][] m = new double[FILAS][COLUMNAS];
// Pedir al usuario que ingrese una matriz de 3 por 4
System.out.println("Enter a " + FILAS + "-by-" +
COLUMNAS + " matrix row by row:");
for (int fila = 0; fila < m.length; fila++)
for (int col = 0; col < m[fila].length; col++)
m[fila][col] = input.nextDouble();
return m;
}
/** sum devuelve la suma de los elementos en columnasIndex*/
public static double sumColumnas(double[][] m, int columnasIndex) {
double sum = 0;
for (int row = 0; row < m.length; row++) {
sum += m[row][columnasIndex];
}
return sum;
}
}
|
Python | UTF-8 | 434 | 2.59375 | 3 | [] | no_license | import sys
import os
#import shutil
import subprocess
#shutil.copy(source,dest)
#os.path.exists('/var')
def List(dirName):
cmd = 'ls l ' + dirName
(status,output) = subprocess.getstatusoutput(cmd)
if status:
sys.stderr.write('there was an error: ' + output)
sys.exit(1)
print('This is not running\n')
print(output)
def main():
List(sys.argv[1])
if __name__ == '__main__':
main()
|
Ruby | UTF-8 | 2,508 | 3.28125 | 3 | [
"MIT"
] | permissive | require 'optparse'
module CompareFiles
class Cli
def self.parse!
args = Struct.new(:left, :right, :remember).new
opt_parser = OptionParser.new do |opts|
opts.banner = <<~BANNER
Usage: compare_files --left=SRC --right=DEST [--remember=file]
compare_files will output items in LEFT that are not in RIGHT"
Example:
Remember files from SRC, and output new files since command was
last run.
compare_files --left=SRC --right=seen.txt --remember=seen.txt
BANNER
opts.summary_width = 20
opts.on("--left=LEFT", "Required. Source side to compare against. May be a folder, or text file.") do |op|
args.left = op
end
opts.on("--right=RIGHT", "Required. Destination side to compare against. May be a folder, or text file.") do |op|
args.right = op
end
opts.on("--remember=FILE", "Save value of LEFT option to FILE. Useful for comparing SRC to itself through time.") do |op|
pn = Pathname.new(op)
valid_file_name = (pn.exist? && pn.file?) || !pn.exist?
raise Error, "Invalid file name #{op}" unless valid_file_name
args.remember = op
end
opts.on("-h", "--help", "Prints this help") do
puts opts
exit
end
opts.on("-v", "--version", "Prints the version (#{VERSION})") do
puts VERSION
exit
end
end
opt_parser.parse!
# verify we got the right combos
valid_args = false
valid_args = true if args.left && args.left
unless valid_args
puts "Missing required options.\n\n"
puts opt_parser
exit 1
end
return args
end
def self.standardize_input(input)
case
when Pathname.new(input).directory?
DirectoryList.list_of_files(input)
when Pathname.new(input).file?
file_as_str = File.open(input) do |file|
file.read
end
Helpers.split_lines(file_as_str)
when input.is_a?(String)
pn = Pathname.new(input)
file_as_str = if pn.exist?
File.open(input) do |file|
file.read
end
else
FileUtils.touch(input)
''
end
Helpers.split_lines(file_as_str)
when input.is_a?(Array)
input
else
raise CompareFiles::Error, "unknown input type: #{input.class} "
end
end
end
end
|
Python | UTF-8 | 1,563 | 3.265625 | 3 | [] | no_license | class Solution:
def maximalRectangle(self, matrix: List[List[str]]) -> int:
if not matrix or len(matrix) == 0 or len(matrix[0]) == 0:
return 0
maxarea = 0
rows = len(matrix)
cols = len(matrix[0])
heights = [0] * cols
for i in range(rows):
for j in range(cols):
if matrix[i][j] == "1":
heights[j] += 1
else:
heights[j] = 0
result = self.largestRectangleArea(heights)
maxarea = max(maxarea, result)
return maxarea
def largestRectangleArea(self, heights: List[int]) -> int:
if not heights or len(heights) == 0:
return 0
lessfromleft = [0] * (len(heights) + 1)
lessfromright = [0] * (len(heights) + 1)
lessfromleft[0] = -1
lessfromright[len(heights) - 1] = len(heights)
for i in range(1, len(heights)):
p = i - 1
while p >= 0 and heights[p] >= heights[i]:
p = lessfromleft[p]
lessfromleft[i] = p
for i in range(len(heights) - 2, -1, -1):
p = i + 1
while p < len(heights) and heights[i] <= heights[p]:
p = lessfromright[p]
lessfromright[i] = p
maxarea = 0
for i in range(len(heights)):
maxarea = max(maxarea, heights[i] * (lessfromright[i] - lessfromleft[i] - 1))
return maxarea |
Java | UTF-8 | 27,798 | 2.125 | 2 | [] | no_license | package com.example.rrcasino;
import android.annotation.SuppressLint;
import android.app.Dialog;
import android.content.res.Resources;
import android.graphics.Color;
import android.graphics.drawable.ColorDrawable;
import android.media.Image;
import android.os.Build;
import android.os.Bundle;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
import com.google.android.material.snackbar.Snackbar;
import androidx.annotation.RequiresApi;
import androidx.appcompat.app.AppCompatActivity;
import androidx.appcompat.widget.Toolbar;
import androidx.constraintlayout.widget.ConstraintLayout;
import android.view.Gravity;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.SeekBar;
import android.widget.TextView;
import android.widget.Toast;
public class activityGamePoker extends AppCompatActivity {
//Custom popup for help button
Dialog myDialog;
//Seek Bar
private SeekBar playerBet;
//Text
private TextView betAmount;
private TextView pot;
private TextView playerBalance;
//Buttons
// private Button check;
//private Button call;
private Button bet;
private Button fold;
private Button deal;
//Image Views for community cards and player cards
private ImageView theflop;
private ImageView theflopone;
private ImageView thefloptwo;
private ImageView theturn;
private ImageView theriver;
private ImageView pcard;
private ImageView pcardone;
private ImageView compCard;
private ImageView compCardOne;
private float transparent = 0;
private float opaque = 1;
//Array of Images for player and the table cards
private ImageView[] playerCardImages;
private ImageView[] computerCardImages;
private ImageView[] communityCardImages;
//Game Variables
private DeckHandler.Deck deck;
private PokerDealer dealer;
private Player player;
private Player computer;
private int currentBet;
private int buyIn = 10;
private int minBet = buyIn;
private int computerBet;
private int potAmount;
private int round = 0;
private int startingFunds = 500;
private String cardFaceDown = "b2fv";
private int playerBetAmount = 0;
private boolean playerInitialBuyin = false;
private boolean playerBetted = false;
private boolean computerBetted = false;
private boolean computerFolds = false;
private boolean playerFold = false;
private boolean cardsDealt = false;
private Hand hand;
private Hand temp;
private enum gameResult { WIN, LOSE, TIE }
@SuppressLint("WrongViewCast")
@RequiresApi(api = Build.VERSION_CODES.O)
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_game_poker);
//Initialize dialog
this.myDialog = new Dialog(this);
//Initialize Seekbar
this.playerBet = findViewById(R.id.playerBet);
playerBet.setMin(buyIn);
playerBet.setMax(100);
playerBet.setProgress(buyIn);
//Text initialized
this.betAmount = findViewById(R.id.betAmount);
this.pot = findViewById(R.id.pot);
this.playerBalance = findViewById(R.id.playerBalance);
//Image views initialized
this.theflop = findViewById(R.id.theflop);
this.theflopone = findViewById(R.id.theflopone);
this.thefloptwo = findViewById(R.id.thefloptwo);
this.theturn = findViewById(R.id.theturn);
this.theriver = findViewById(R.id.theriver);
this.pcard = findViewById(R.id.pcard);
this.pcardone = findViewById(R.id.pcardone);
this.compCard = findViewById(R.id.ccard);
this.compCardOne = findViewById(R.id.ccard1);
playerCardImages = new ImageView[] {pcard, pcardone};
computerCardImages = new ImageView[] {compCard, compCardOne};
communityCardImages = new ImageView[] {theflop, theflopone, thefloptwo, theturn, theriver};
//Initialize buttons
this.fold = findViewById(R.id.fold);
//this.check = findViewById(R.id.check);
//this.call = findViewById(R.id.call);
this.bet = findViewById(R.id.bet);
this.deal = findViewById(R.id.deal);
fold.setEnabled(false);
// check.setEnabled(false);
//call.setEnabled(false);
bet.setEnabled(false);
betAmount.setEnabled(false);
//Set button click handlers
fold.setOnClickListener(clicked);
//check.setOnClickListener(clicked);
//call.setOnClickListener(clicked);
bet.setOnClickListener(clicked);
deal.setOnClickListener(clicked);
//Initialize New Game
this.deck = new DeckHandler.Deck();
this.dealer = new PokerDealer("dealer", 0);
this.player = new Player("player", startingFunds);
this.computer = new Player("computer", 1000);
playerBalance.setText("Balance: $" + player.getBalance());
playerBet.setMax(player.getBalance());
//Handle All Listeners
playerBet.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
int progressChangedValue = 0;
@Override
public void onProgressChanged(SeekBar seekBar, int progress, boolean fromUser) {
progressChangedValue = progress;
betAmount.setText("Current Bet: $"+progressChangedValue);
bet.setText("BET");
if(progressChangedValue == player.getBalance()){
bet.setText("ALL IN");
}
//System.out.println(progressChangedValue);
}
@Override
public void onStartTrackingTouch(SeekBar seekBar) {
}
@Override
public void onStopTrackingTouch(SeekBar seekBar) {
currentBet = progressChangedValue;
playerBetAmount += currentBet;
}
});
}
private View.OnClickListener clicked = new View.OnClickListener() {
/*
* Onclick listener for buttons
*
*/
@Override
public void onClick(View view) {
switch (view.getId()){
case R.id.deal:
//Disable the deal cards button
deal.setEnabled(false);
cardsDealt = true;
playerBet.setVisibility(View.VISIBLE);
betAmount.setVisibility(View.VISIBLE);
pot.setText("POT");
startGame();
//System.out.println(Check_win());
System.out.println("DEAL was pressed");
break;
case R.id.bet:
playerInitialBuyin = true;
playerBetted = true;
potAmount += currentBet;
pot.setText("$"+potAmount);
System.out.println("BET was pressed");
System.out.println("In BET player buy in: "+playerInitialBuyin);
checkRounds();
break;
case R.id.fold:
playerFold = true;
System.out.println("FOLD was pressed");
endRound();
break;
//end the round and update player balance if folded anywhere
//after the first buy in
}
}
};
//Show Help Popup
public void ShowPopup(View v) {
FloatingActionButton closepopup;
myDialog.setContentView(R.layout.custompopup);
closepopup = myDialog.findViewById(R.id.closepopup);
closepopup.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
myDialog.dismiss();
}
});
myDialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
myDialog.show();
}
private void setImageResource (char participant, int cardNum, String imageSource) {
/*
* First parameter takes in a 'p' or 'd' character specifying whether a player or dealer card is
* being updated. Essentially this specifies the ImageView ID affix pCard or dCard.
* Second parameter specifies the ImageView ID suffix by card number, eg 1 or 2 for pCard1 or pCard2
* respectively.
* Third parameter takes in a Card object (usually the last dealt card) that holds the image source
* as a string
*/
Resources resources = getResources();
final int resourceId = resources.getIdentifier(imageSource,"drawable",getPackageName());
switch (participant) {
case 'p': {
switch (cardNum) {
case 1:
playerCardImages[cardNum-1].setAlpha(opaque);
pcard.setImageResource(resourceId);
break;
case 2:
playerCardImages[cardNum-1].setAlpha(opaque);
pcardone.setImageResource(resourceId);
break;
}
break;
}
case 'c': {
switch (cardNum) {
case 1:
computerCardImages[cardNum-1].setAlpha(opaque);
compCard.setImageResource(resourceId);
break;
case 2:
computerCardImages[cardNum-1].setAlpha(opaque);
compCardOne.setImageResource(resourceId);
break;
}
break;
}
case 'd': {
switch (cardNum) {
case 1:
communityCardImages[cardNum-1].setAlpha(opaque);
theflop.setImageResource(resourceId);
break;
case 2:
communityCardImages[cardNum-1].setAlpha(opaque);
theflopone.setImageResource(resourceId);
break;
case 3:
communityCardImages[cardNum-1].setAlpha(opaque);
thefloptwo.setImageResource(resourceId);
break;
case 4:
communityCardImages[cardNum-1].setAlpha(opaque);
theturn.setImageResource(resourceId);
break;
case 5:
communityCardImages[cardNum-1].setAlpha(opaque);
theriver.setImageResource(resourceId);
break;
}
break;
}
}
}
//Start the game
private void startGame() {
/* Create clean round
* 1. Disable/Enable buttons
* 2. Check that players hands are empty
* 3. Update card images to face down, and make non-dealt cards transparent
* 4. Enable SeekBar to set new bet amount
* 5. Deal cards, and check for natural win
*/
// Update usable buttons
bet.setEnabled(true);
fold.setEnabled(true);
//check.setEnabled(true);
round++;
//call.setEnabled(true);
pot.setVisibility(View.VISIBLE);
// Loop through participant hands and set to all cards to null card
for (int i = 1; i <= 2; i++) {
setImageResource('p', i, cardFaceDown);
playerCardImages[i-1].setAlpha(transparent);
setImageResource('c', i, cardFaceDown);
computerCardImages[i-1].setAlpha(transparent);
}
//Loop through community table cards and set to NUll
for(int i = 1; i <= 5; i++) {
setImageResource('d', i, cardFaceDown);
communityCardImages[i-1].setAlpha(transparent);
}
// Check that hands are empty
if (player.getHand().getHandValue()>0)
player.returnCards();
if (dealer.getHand().getHandValue()>0)
dealer.returnCards();
if (computer.getHand().getHandValue()>0)
computer.returnCards();
dealPlayerCards();
}
//Deal initial player cards
private void dealPlayerCards() {
// Deal First Player Card
dealer.dealCard(player, deck);
setImageResource('p',player.getHand().getNumOfCardsInHand(), dealer.getLastDealtCard().getImageSource());
// Deal Computer First card
dealer.dealCard(computer,deck);
setImageResource('c', computer.getHand().getNumOfCardsInHand(), cardFaceDown);
compCard.setRotation(270);
//Deal Second player card
dealer.dealCard(player,deck);
setImageResource('p', player.getHand().getNumOfCardsInHand(), dealer.getLastDealtCard().getImageSource());
//Deal Second computer card
dealer.dealCard(computer, deck);
setImageResource('c', computer.getHand().getNumOfCardsInHand(), cardFaceDown);
compCardOne.setRotation(270);
//Dealing all community cards to test CheckWin() function
/*
dealer.dealCard(dealer,deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(), dealer.getLastDealtCard().getImageSource());
dealer.dealCard(dealer,deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(), dealer.getLastDealtCard().getImageSource());
dealer.dealCard(dealer,deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(), dealer.getLastDealtCard().getImageSource());
dealer.dealCard(dealer,deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(), dealer.getLastDealtCard().getImageSource());
dealer.dealCard(dealer,deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(), dealer.getLastDealtCard().getImageSource());
*/
}
//Functions to deal out cards. The flop initial deal of three cards, the turn deals one card, and the river deals the last card
//Total of 5 cards laid out on the table
private void dealTheFlop() {
//First Flop Card
dealer.dealCard(dealer, deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(),dealer.getLastDealtCard().getImageSource());
//Second Flop Card
dealer.dealCard(dealer, deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(),dealer.getLastDealtCard().getImageSource());
//Third Flop Card
dealer.dealCard(dealer, deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(),dealer.getLastDealtCard().getImageSource());
}
private void dealTheTurn() {
//Deal turn card
dealer.dealCard(dealer, deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(), dealer.getLastDealtCard().getImageSource());
}
private void dealTheRiver() {
//Deal the river card
dealer.dealCard(dealer,deck);
setImageResource('d', dealer.getHand().getNumOfCardsInHand(), dealer.getLastDealtCard().getImageSource());
}
private void checkRounds() {
System.out.println("Entering 'checkRounds'..........");
System.out.println("Start Game player initial: " + playerInitialBuyin);
System.out.println("Start Game player bet: " + playerBetted);
System.out.println("Round: " +round);
//Check the bettings for the initial round the deal the first three cards
if(playerBetted && round == 1) {
System.out.println("About to deal the Flop");
auto(computer);
System.out.println("Computer Betted");
dealTheFlop();
System.out.println("Flop was dealt");
}
//Check the bettings for the flop then deal a card
else if (playerBetted && round == 2) {
System.out.println("About to deal the Turn");
auto(computer);
dealTheTurn();
}
//Check the bettings for the turn then deal a card
else if (playerBetted && round == 3) {
System.out.println("About to deal the River");
auto(computer);
dealTheRiver();
}
//Check the Final bettings
else if (playerBetted && round == 4)
auto(computer);
System.out.println("Current round: "+round);
System.out.println("Start Game end player bet: " + playerBetted);
System.out.println("Start Game player buy in: " + playerInitialBuyin);
//endRound();
round++;
playerBetted = false;
System.out.println("Round amount: "+round);
if(round == 5) {
System.out.println("About to call end round");
endRound();
round = 0;
}
}
private void endRound () {
System.out.println("In endRound function");
bet.setEnabled(false);
fold.setEnabled(false);
//call.setEnabled(false);
//check.setEnabled(false);
deal.setEnabled(true);
float cash = 0;
Toast gameMesage;
if(round == 5) {
System.out.println("Revealing computer cards");
setImageResource('c',1 ,computer.getHand().getCard(0).getImageSource());
setImageResource('c', 2,computer.getHand().getCard(1).getImageSource());
round = 0;
}
if(playerFold && !playerInitialBuyin) {
//Player doesnt lose cash
player.addToBalance(cash);
round = 0;
//
} else {
switch (Check_win()) {
case WIN:
cash += potAmount;
player.addToBalance(cash);
gameMesage = Toast.makeText(activityGamePoker.this, "Player Wins", Toast.LENGTH_SHORT);
//gameMesage.setGravity(Gravity.CENTER,0,0);
gameMesage.show();
break;
case TIE:
gameMesage = Toast.makeText(activityGamePoker.this, "TIE", Toast.LENGTH_SHORT);
//gameMesage.setGravity(Gravity.CENTER,0,0);
gameMesage.show();
break;
case LOSE:
cash -= playerBetAmount;
player.addToBalance(cash);
gameMesage = Toast.makeText(activityGamePoker.this, "Computer Wins", Toast.LENGTH_SHORT);
//gameMesage.setGravity(Gravity.CENTER,0,0);
gameMesage.show();
break;
}
}
// Set mew maximum bet; Player cannot bet more than available funds
//reset booleans
playerInitialBuyin = false;
playerBetted = false;
computerFolds = false;
playerFold = false;
potAmount = 0;
round = 0;
System.out.println("end round player buy: " + playerInitialBuyin);
playerBet.setMax(player.getBalance());
playerBalance.setText("Balance: $"+player.getBalance());
System.out.println(Check_win());
// Update player balance TextView
}
/**Daniel's addition**/
public void Check_Hand (Player player) {
// load hand combining hand
this.hand = new Hand();
// load hand for unique value for straight check
this.temp = new Hand();
// Flush flag
int suit [] = {0, 0, 0, 0};
// pairs flag
int pairs [] = {0,0,0,0,0,0,0,0,0,0,0,0,0};
// add players hand to temp hand
for (int i = 0; i < player.getHand().getNumOfCardsInHand(); i++) {
hand.addCard(player.getHand().getCard(i));
}
// add dealer hand to temp hand
for (int i = 0; i < dealer.getHand().getNumOfCardsInHand(); i++) {
hand.addCard(dealer.getHand().getCard(i));
}
//sort temp array use quick sort array is small
insertion_sort(hand);
//check for hand Flush
for(int i=0 ;i<7 ;i++) {
if (hand.getSuit(i) == 1 ) {
suit[0]+=1;
}
else if (hand.getSuit(i) == 1 ) {
suit[1]+=1;
}
else if (hand.getSuit(i) == 1 ) {
suit[2]+=1;
}
else if (hand.getSuit(i) == 1 ) {
suit[3]+=1;
}
}
//flag for Flush
for (int i=0;i<4;i++)
{
if (suit[i] >= 5) {
player.setcondition(4);
}
}
int count = 0;
temp.addCard(hand.getCard(count));
for(int i=1;i<7;i++) {
//if match update array
if (hand.getCard(i).getRank() == temp.getCard(count).getRank()) {
//check 3 of a king
//if pair and not three of a kind
if(player.getcondition(8) == 1 && (temp.getCard(count-1).getValue() != temp.getCard(count-2).getValue()))
{
player.setcondition(7);
}
//Flag pairs
player.setcondition(8);
}
//track how many of each card ar ein the hand
pairs[hand.getCard(i).getRank()-1] += 1;
//if card value != temp value +1 replace temp
//don't increase hand unless next part of rank
if(hand.getCard(i).getValue() != temp.getCard(count).getValue() + 1) {
temp.getHand().set(count, hand.getCard(i));
}else{
temp.addCard(hand.getCard(i));
count++;
}
}
//if temp hand has 5 cards then hand is straight
// flag straight
if (temp.getNumOfCardsInHand() >= 5) {
player.setcondition(5);
}
// if (royal flush)
// search highest possible straight manually
// and is Flush
if (temp.getAcesInHand() == 1 && temp.getCard(1).getRank() == 10 && temp.getCard(2).getRank() == 11 && temp.getCard(3).getRank() == 12 && temp.getCard(4).getRank() == 13 )
{
if (player.getcondition(4) == 1) {
player.setcondition(0);
}
}
// if (straight Flush )
if (player.getcondition(4) == 1 && player.getcondition(5) == 1)
{
player.setcondition(1);
}
//if (four of a kind)
// flags for pairs in hands
this.check_pairs(pairs);
//else if (Flush)
if(player.getcondition(4) == 1 && player.getcondition(5) != 1)
{
player.setcondition(4);
}
// else if (straight)
if(player.getcondition(4) != 1 && player.getcondition(5) == 1)
{
player.setcondition(5);
}
}
private void check_pairs(int[] pairs) {
for(int i=12;i>0;i--)
{
//flag 4 of a kind
if (pairs[i] == 3) {
player.setcondition(2);
//flag three of a kind
} else if (pairs[i] == 2) {
player.setcondition(6);
// flag pair
} else if (pairs[i] == 1) {
player.setcondition(8);
}
}
//if 3ofakind and pair are Flagged then flag fullhouse
if (player.getcondition(6) == 1 && player.getcondition(8) == 1 ) {
player.setcondition(3);
}
}
//Quick sort for small array
private void insertion_sort(Hand hand)
{
int n = player.getHand().getNumOfCardsInHand();
for(int i=1;i<n-1;i++)
{
DeckHandler.Card v = hand.getCard(i);
int j = i - 1;
while (j>=0 & hand.getCard(j).getValue() > v.getValue())
{
hand.getHand().set(j+1, hand.getHand().get(j));
j = j -1;
hand.getHand().set(j+1, v);
}
}
}
private void auto (Player player) {
// this.Check_Hand(player);
/*
if (player.highestHand() >= 5) {
// raise
//just bet the min amount
computerBet = minBet;
potAmount += computerBet;
computerBetted = true;
} else if (player.highestHand() < 5 && player.highestHand() > 8) {
//call
//if player betted
//set the bet to that amount
if(playerBetted) {
computerBet = currentBet;
potAmount += computerBet;
computerBetted = true;
}
} else {
//fold
//Just end the round
//endround() as player wins
computerFolds = true;
endRound();
}
*/
Toast computerMessage;
// System.out.println("Player bet boolean: "+playerBetted);
if(playerInitialBuyin && round == 1) {
computerBet = currentBet;
potAmount += computerBet;
computerBetted = true;
computerMessage = Toast.makeText(activityGamePoker.this, "Computer Called", Toast.LENGTH_SHORT);
//computerMessage.setGravity(Gravity.CENTER,0,0);
computerMessage.show();
}
else {
computerBet = currentBet;
potAmount += computerBet;
computerBetted = true;
computerMessage = Toast.makeText(activityGamePoker.this, "Computer Called", Toast.LENGTH_SHORT);
//computerMessage.setGravity(Gravity.CENTER,0,0);
computerMessage.show();
}
}
private gameResult Check_win () {
gameResult result = activityGamePoker.gameResult.TIE;
//2. compare highest win condition
//win by hand
if (player.highestHand() < computer.highestHand()) {
result = activityGamePoker.gameResult.WIN;
return result;
} else if (player.highestHand() > computer.highestHand()) {
result = activityGamePoker.gameResult.LOSE;
return result;
} else if (player.highestHand() == computer.highestHand()) {
//check strength of hand if tie
}else if (player.getHand().getHandValue() > computer.getHand().getHandValue()) {
result = activityGamePoker.gameResult.WIN;
return result;
} else if (player.getHand().getHandValue() < computer.getHand().getHandValue()) {
result = activityGamePoker.gameResult.LOSE;
return result;
} else if (player.getHand().getHandValue() == computer.getHand().getHandValue()) {
//check kicker
//check if the first card in player hand is the kicker
}else if (player.getHand().getCard(0).getValue() > (computer.getHand().getCard(0).getValue() | computer.getHand().getCard(1).getValue())) {
result = activityGamePoker.gameResult.WIN;
return result;
//check if the second card in player hand is the kicker
} else if (player.getHand().getCard(1).getValue() > (computer.getHand().getCard(0).getValue() | computer.getHand().getCard(1).getValue())) {
result = activityGamePoker.gameResult.WIN;
return result;
// player ties
} else if (player.getHand().getHandValue() == computer.getHand().getHandValue()) {
result = activityGamePoker.gameResult.TIE;
return result;
} else {
result = activityGamePoker.gameResult.LOSE;
}
return result;
}
}
|
Java | UTF-8 | 2,451 | 3.59375 | 4 | [] | no_license | package com.yang.sh.juc;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
class MyCache{
private volatile Map<String,Object> map = new HashMap<>();
private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
public void put (String k,String v){
readWriteLock.writeLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"\t ๅๅ
ฅๆฐๆฎ"+k);
try {
TimeUnit.MICROSECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
map.put(k,v);
System.out.println(Thread.currentThread().getName()+"\t ๅๅ
ฅๅฎๆ");
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.writeLock().unlock();
}
}
public void get (String k){
readWriteLock.readLock().lock();
try {
System.out.println(Thread.currentThread().getName()+"\t ่ฏปๅๆฐๆฎ");
try {
TimeUnit.MICROSECONDS.sleep(300);
} catch (InterruptedException e) {
e.printStackTrace();
}
Object o = map.get(k);
System.out.println(Thread.currentThread().getName()+"\t ่ฏปๅๅฎๆ"+o);
} catch (Exception e) {
e.printStackTrace();
} finally {
readWriteLock.readLock().unlock();
}
}
}
/*
* ๅค็บฟ็จๅๆถ่ฏปไธไธช่ตๆบ็ฑปๆฒกๆไปปไฝ้ฎ้ข๏ผๆไปฅไธบไบๆปก่ถณๅนถๅ้๏ผ่ฏปๅๅ
ฑไบซ่ตๆบๅบ่ฏฅๅๆถ่ฟ่ก
* ไฝๆฏๅฆๆๆไธไธช่ตๆบๆณๅปๅๅ
ฑไบซ่ตๆบ
* ๅฐฑไธๅบ่ฏฅๆๅ
ถไป็็บฟ็จๅฏไปฅๅฏน่ฏฅ่ตๆบ่ฟ่ก่ฏปๅๅ
* ๅฐๆป็ป
* ่ฏป-่ฏป ๅฏๅ
ฑๅญ
* ่ฏป-ๅ ไธ่ฝๅ
ฑๅญ
* ๅ-ๅ ไธ่ฝๅ
ฑๅญ
*
* */
public class ReadWriteLockDemo {
public static void main(String[] args) {
MyCache myCache = new MyCache();
for (int i = 1; i <= 5; i++) {
int finalI = i;
new Thread(()->{
myCache.put(finalI+"",finalI+"");
},String.valueOf(i)).start();
}
for (int i = 1; i <= 5; i++) {
int finalI = i;
new Thread(()->{
myCache.get(finalI+"");
},String.valueOf(i)).start();
}
}
}
|
C++ | UTF-8 | 2,837 | 3.15625 | 3 | [] | no_license | // xml.h
// Leitor XML baseado em eventos. Semi-completo.
// Estruturas de Dados - T1
// 2911524 - Yuri Kunde Schlesner
#ifndef YURIKS_T1_XML_H
#define YURIKS_T1_XML_H
#include <iostream>
#include <stdexcept>
namespace yuriks
{
namespace xml
{
/** Interface a ser implementada por classes que desejarem receber eventos do parser. */
class EventConsumer
{
public:
// Abertura de tag
virtual void tag_open(const char* tag_name) = 0;
// Fechamento de tag
virtual void tag_close(const char* tag_name) = 0;
// Atributo de tag
virtual void tag_prop(const char* prop_name, const char* prop_val) = 0;
// Trecho textual
virtual void tag_text_node(const char* value) = 0;
};
/** Excecao lancada quando forem encontrados erros na leitura do xml. */
struct ReadingException : std::runtime_error
{
ReadingException(const std::string& str)
: std::runtime_error(str)
{
}
};
/** Leitor XML. Acredito suportar um sub-conjunto do formato adequado a este trabalho.
*
* A medida que a leitura do arquivo for sendo realizada, o leitor ira
* chamar as funcoes do EventConsumer passado para read_xml.
*/
class Reader
{
public:
Reader(std::istream& f);
// Executa a leitura do arquivo, chamando os eventos em `consumer`.
void read_xml(EventConsumer& consumer);
// Numero da ultima linha lida. Util para mensagens de erro.
unsigned int line_num() const;
private:
static const unsigned int max_tag_depth = 8;
static const unsigned int max_tag_len = 16;
static const unsigned int max_prop_name_len = 16;
static const unsigned int max_prop_value_len = 64;
static const unsigned int max_tag_content_len = 64;
bool used;
std::istream& f;
int cur_line;
std::istream& getch(char& c);
// Le ate encontrar caractere nao-espaco.
void skip_whitespace();
bool read_next_tag(char* tag, unsigned int tag_len);
bool read_next_prop(char* prop, unsigned int prop_len, char* val, unsigned int val_len);
void read_to_tag_end();
bool read_tag_content(char* content, unsigned int content_len);
// Retorna true se c for [A-Za-z_]
bool read_identifier(char* id, unsigned int id_len);
// Le um valor entre aspas.
void read_quoted(char* val, unsigned int val_len);
// Le uma entity (& etc) e retorna o caractere que representa.
char read_entity();
// Le ate encontrar determinado caractere.
void read_to_char(char ch, char* str, unsigned int str_len);
// Le ate caractere, decodificando entities.
void read_to_char_entdec(char ch, char* str, unsigned int str_len);
// Nao assignable
Reader& operator=(const Reader&);
};
// Escreve uma string codificando entities XML
std::ostream& write_string_entenc(std::ostream& s, const char* str);
} // namespace xml
} // namespace yuriks
#endif // YURIKS_T1_XML_H
|
Markdown | UTF-8 | 1,705 | 3.046875 | 3 | [
"MIT"
] | permissive | ---
Title: Using build counters in Azure DevOps
Tags:
- Azure DevOps
---
We recently migrated some builds from TeamCity to Azure DevOps at my client, and couldn't
find a feature analog to TeamCity's `%build.counter%` which we've been using
to get automatically incremented version numbers for artifacts.
<!--excerpt-->
Since we couldn't find the corresponding feature in Azure DevOps we settled on using the
`$(Build.BuildId)` variable which is the canonical ID for a build. Not exactly ideal
but it solved the immediate issue.
Today I found a way of accomplishing the same thing in Azure DevOps, but sadly it's not
properly documented even if it's [briefly mentioned][1] in the official documentation.
The following lines in your `azure-devops.yml` will set the build number to an
incrementing number that's scoped to the build definition.
```yml
name: 1.0.$(myBuildCounter)
variables:
myBuildCounter: $[counter('buildCounter',1)]
```
The example above will create a build definition counter called `buildCounter` that
will be initialized to the value `1`. This value will be incremented for
each new build. If you ever want to reset or reseed this value you'll have to use the
[Azure DevOps HTTP API][2].
If you have an option, consider using something like [GitVersion][3]
or [MinVer][4] to dynamically calculate a version number from a git repository.
[1]:https://docs.microsoft.com/en-us/azure/devops/pipelines/process/variables?view=azure-devops&tabs=yaml%2Cbatch#set-variables-using-expressions
[2]:https://docs.microsoft.com/en-us/rest/api/azure/devops/build/definitions?view=vsts-rest-tfs-4.1
[3]:https://gitversion.readthedocs.io/en/latest/
[4]:https://github.com/adamralph/minver |
C | UTF-8 | 1,169 | 3.703125 | 4 | [] | no_license | #include<stdio.h>
enum sex {boy,girl,Invalid};
enum season {spring,summer,autumn,winter,fail};
enum sex select1(void){
int temp;
do {
puts("่ฏท้ๆฉๆงๅซ ็ท----0 ๅฅณ----1");
scanf("%d",&temp);
if (temp<boy||temp>Invalid)
puts("่ฏทไธ่ฆๆฟๆจ็ๆงๅซๅผ็ฉ็ฌ");
}while(temp<boy||temp>Invalid);
return temp;
}
enum season select2(void){
int temp;
do {
puts("่ฏท้ๆฉๅบ็ๅญฃ่ ๆฅ---0 ๅค---1 ็ง---2 ๅฌ---3");
scanf("%d",&temp);
if(temp<spring||temp>fail)
puts("่ฏท้ๆฐ้ๆฉๆจ็ๅบ็ๅญฃ่");
}while(temp<spring||temp>fail);
return temp;
}
int main(){
enum sex selected1 = select1();
enum season selected2 = select2();
if(selected1==0){
switch(selected2){
case spring:
printf("ๆฅๅคฉ็ทๅญฉ\n"); break;
case summer:
printf("ๅคๅคฉ็ทๅญฉ\n"); break;
case autumn:
printf("็งๅคฉ็ทๅญฉ\n");break;
case winter:
printf("ๅฌๅคฉ็ทๅญฉ\n");break;
}
}else{
switch(selected2){
case spring:
puts("ๆฅๅคฉๅฅณๅญฉ\n");break;
case autumn:
puts("็งๅคฉๅฅณๅญฉ\n");break;
case winter:
puts("ๅฌๅคฉๅฅณๅญฉ\n");break;
case summer:
puts("ๅคๅคฉๅฅณๅญฉ\n");break;
}
}
return 0;
}
|
JavaScript | UTF-8 | 520 | 2.6875 | 3 | [
"Apache-2.0"
] | permissive | export function onOriginResponse (request, response) {
response.setHeader('Edge-Cache-Tag', getCacheTagsForPath(request.path));
}
function getCacheTagsForPath (path) {
const cacheTagPrefix = 'path--';
const cacheTagFolderSeparator = '|';
const folderNames = path.split('/');
const cacheTags = [];
for (let i = 1; i < folderNames.length; i++) {
cacheTags.push(cacheTagPrefix + cacheTagFolderSeparator + folderNames.slice(1, i + 1).join(cacheTagFolderSeparator));
}
return '' + cacheTags.join(',');
}
|
Shell | UTF-8 | 499 | 3.34375 | 3 | [] | no_license | #!/bin/bash
. ~/dotfiles/install-scripts/lib/platform.sh
if [[ $platform != "linux" ]]; then
if [[ $platform != "arch" ]]; then
echo "Backup for Linux only"
exit 1
fi
fi
HOSTNAME=`hostname`
echo "MONTHLY BACKUP"
function cleanup {
sudo umount /backup
echo "Unmounted /backup"
}
trap cleanup EXIT
cd ~/dotfiles/cron
sudo mount /backup
sudo mkdir -p /backup/$HOSTNAME/monthly
echo "MONTHLY BACKUP"
tar -cvjf /backup/$HOSTNAME/monthly/monthly_$(date +%Y%m%d).tar.bz2 /backup/daily
|
Markdown | UTF-8 | 1,295 | 3.984375 | 4 | [
"MIT"
] | permissive | ---
layout: post
title: My favorite way of telling if a number is odd or even
published: true
---
My uncle (a CS guy) once gave me an interesting puzzle: write a function to tell if a number is even or odd without using the modulus operator (e.g. "%").
At that time he had just given me ["Let's Talk Lisp"](https://images-na.ssl-images-amazon.com/images/I/31prZs8fkaL._SY298_BO1,204,203,200_.jpg), a book about the programming language [Lisp](https://en.wikipedia.org/wiki/Lisp_(programming_language)) and about recursive thinking in general.
Thus, my answer to his question was this:
```lisp
(defun odd (n)
(cond ((= n 1) t) ;; if n is 1
(t (even (- n 1))))) ;; otherwise call even(n-1)
(defun even (n)
(cond ((= n 1) nil) ;; if n is 1, it's NOT even
(t (odd (- n 1))))) ;; otherwise call odd(n-1)
```
Or, if TypeScript/JavaScript works better for you:
```typescript
function odd(n: number): boolean {
if (n == 1) return true;
return even(n - 1);
}
function even(n: number): boolean {
if (n == 1) return false;
return odd(n - 1);
}
```
Try it! If you call `odd(3)` it recursively bounces the function from one to the other and spits out `true`. Same with `even(4)` and `odd(9)` and `even(48938)`.
Kinda cool, thanks [Larry](http://larry.denenberg.com). |
C | UTF-8 | 1,033 | 2.625 | 3 | [
"Apache-2.0"
] | permissive | /*
** EPITECH PROJECT, 2018
** my_rpg
** File description:
** create_fight_container
*/
#include "fight.h"
chrono_t *create_chrono(void)
{
chrono_t *ptr = malloc(sizeof(*ptr));
if (!ptr)
return (NULL);
ptr->clock = sfClock_create();
ptr->my_sec = 0;
return (ptr);
}
bool verify_fight_container(fight_t *ptr)
{
if (!ptr)
return (false);
if (!ptr-> particles || !ptr->menus || \
!ptr->background || !ptr->inst || ptr->status < 0 || ptr->status > 2)
return (false);
return (true);
}
fight_t *create_fight_container(int status)
{
fight_t *ptr = malloc(sizeof(*ptr));
if (ptr == NULL)
return (NULL);
ptr->status = status;
ptr->particles = init_particles("./ressource/blood.png", 1150, 240);
ptr->menus = prepare_menus();
ptr->select = BASIC;
ptr->ennemy = create_ennemy(status);
ptr->background = set_background(status);
ptr->inst = malloc(sizeof(int) * 2);
if (verify_fight_container(ptr) == false) {
free_fight_container(ptr);
return (NULL);
}
ptr->inst[0] = 0;
ptr->inst[1] = 0;
return (ptr);
}
|
Ruby | UTF-8 | 3,803 | 2.828125 | 3 | [] | no_license | require 'open3'
module ADAdapters
module PBIS
extend self
def get_info(group)
LOG.debug "PBIS::get_info: Getting JSON data for group #{group}"
str = `/opt/pbis/bin/adtool -a lookup-object --dn="#{group}" --attr=info`.strip
LOG.debug "PBIS::get_info: Info attr data returned for group #{group}: #{str}"
str
end
def get_groups(objectName, objectType)
LOG.debug "gettings subgroups of #{objectName}, which is of type #{objectType}"
computerName = `scutil --get ComputerName`.strip
currentUser = `id -un`.strip
if objectType == "user"
raw_groups = `/opt/pbis/bin/list-groups-for-user #{currentUser}`.strip
raw_groups = raw_groups.split("\n")
raw_groups.shift # Remove first line: summary output
group_names = []
groups = []
raw_groups.each do |group|
group_names << /name = ([^\s]*)/.match(group)[1]
end
group_names.compact!
group_names.each do |group|
cmd = "/opt/pbis/bin/adtool -a search-group --name '#{group}'"
Open3.popen3(cmd) do |stdin, stdout, stderr|
err = stderr.read
out = stdout.read
dn = out.split("\n").first
groups << dn.strip unless dn.nil? || dn.empty?
end
end
puts groups.inspect
else
case objectType
when "computer"
action = "search-computer"
when "group"
action = "search-group"
else
LOG.error "Unknown object type: #{objectName}"
exit
end
groups = nil
dn = nil
# Why not pipe these two commands together? Great question.
# I can't reproduce it in any other environment, but when I pipe these together the second cmd
# can't read the keytab, as if it were not being run as root.
if currentUser == "root"
cmd = "/opt/pbis/bin/adtool -k /etc/krb5.keytab -n '#{computerName.upcase}$' -a #{action} --name '#{objectName}'"
else
cmd = "/opt/pbis/bin/adtool -a #{action} --name '#{objectName}'"
end
Open3.popen3(cmd) do |stdin, stdout, stderr|
err = stderr.read
out = stdout.read
dn = out.split("\n").first
dn.strip! if dn
end
unless dn.nil? || dn.empty?
if currentUser == "root"
cmd = "/opt/pbis/bin/adtool -k /etc/krb5.keytab -n '#{computerName.upcase}$' -a lookup-object --dn='#{dn}' --attr=memberOf'"
else
cmd = "/opt/pbis/bin/adtool -a lookup-object --dn='#{dn}' --attr=memberOf"
end
Open3.popen3(cmd) do |stdin, stdout, stderr|
err = stderr.read
out = stdout.read
groups = out
end
else
LOG.warn "Unable to determine DN for object: #{objectName}"
return nil
end
end
if groups.nil? || groups.empty?
LOG.debug "No more groups for #{objectName}\n\n"
return
else
groups = groups.split("\n") unless groups.is_a? Array # split into an array by line
# groups = ADAdapters.extract_cns(groups)
LOG.debug "Found #{groups.count} groups: #{groups.inspect}"
immu_groups = Array.new groups
immu_groups.each do |group|
LOG.debug "\nContinuing recursion from #{objectName} with group: #{group}"
new_groups = get_groups(group, "group")
new_groups.compact.map {|g| groups << g unless groups.include? g } unless new_groups.nil?
end
LOG.debug "End of recursion for #{objectName}\n\n"
end
groups
end
end
end |
C++ | UTF-8 | 665 | 2.5625 | 3 | [] | no_license | #pragma once
using namespace System;
using namespace System::Windows::Forms;
using namespace System::Drawing;
ref class Mybutton :Button
{
private:
public:
Mybutton(int x, int y, String ^name, String ^color);
};
Mybutton::Mybutton(int x, int y, String ^name, String ^color)
{
if (color == "num")
this->BackColor = SystemColors::ActiveCaption;
else
this->BackColor = Color::Silver;
this->Font = (gcnew System::Drawing::Font(L"Bahnschrift", 15, FontStyle::Bold, GraphicsUnit::Point,
static_cast<System::Byte>(0)));
this->Location = Point(x, y);
this->Name = name;
this->Size = System::Drawing::Size(60, 60);
this->Text = name;
this->TabIndex = 0;
}
|
JavaScript | UTF-8 | 208 | 2.90625 | 3 | [] | no_license |
let cambiarbtn=document.getElementById('cambiarbtn');
cambiarbtn.onclick=function () {
let titulo=document.getElementById('titulo');
titulo.innerHTML='holaaaaaa';
titulo.style.color='red';
}
|
Ruby | UTF-8 | 429 | 3.6875 | 4 | [
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-public-domain"
] | permissive | # prereqs: iterators, hashes, conditional logic
# Given a hash with numeric values, return the key for the smallest value
def key_for_min_value(name_hash)
new_array = []
name_hash.each do |key, value|
new_array << value if new_array.length == 0
new_array << value if value <= new_array[-1]
end
low_value = new_array[-1]
name_hash.each do |key, value|
return key if value == low_value
end
return nil if name_hash == {}
end
|
JavaScript | UTF-8 | 2,811 | 2.609375 | 3 | [] | no_license | #!/usr/bin/env node
import * as fs from 'fs';
import * as commander from "commander";
import Forker from './forker';
import Constants from './constants';
let API = require('./api');
let CONFIG_PATH = Constants.CONFIG_PATH;
class CLI {
private commander: commander.CommanderStatic;
private api: any;
private config: any;
constructor() {
this.commander = commander;
this.api = new API();
this._setVersion();
this._setOptions();
this._loadConfig();
}
public _setVersion() {
let pinfo = require('../package.json');
this.commander.version(pinfo.version);
}
public _setOptions() {
this.commander
.usage('[options] <uris ...>')
.arguments('<uris...>')
.action((uris: string) => {
this.commander.uris = uris;
})
.option('-a, --access-token <token>', 'Spotify Web API access token')
.option('-p, --public', 'Create all forks as public')
.parse(process.argv)
}
public _loadConfig() {
try {
let data = fs.readFileSync(CONFIG_PATH, 'utf8')
this.config = JSON.parse(data);
} catch (error) {
fs.writeFileSync(CONFIG_PATH, '');
this.config = {};
}
if(this.commander.accessToken) {
this.config.accessToken = this.commander.accessToken;
}
}
public async _validateAPI() {
return this.api.getMe();
}
public async _loadAPI() {
// Verify that the access token that we have works
try {
this.api.setAccessToken(this.config.access_token);
await this._validateAPI();
}
// The access token doesn't work, regenerate it.
catch(e) {
console.log("Missing or invalid access token. Regenerating...");
try {
let token = await this.api.generateAccessToken()
this.config.access_token = token;
} catch(e) {
console.error("Could not generate/obtain access token. Exiting...");
throw e;
}
}
// Save config for future use
fs.writeFile(CONFIG_PATH, JSON.stringify(this.config), (error?: Error) => {
if(error) { console.log("Could not write access token to file") }
})
}
public async execute() {
if(!this.commander.uris) {
console.error('Please specify uris as arguments');
return;
}
try {
await this._loadAPI();
} catch(e) {
console.error(e.toString());
return;
}
let forker = new Forker({
visible: this.commander.public,
accessToken: this.config.access_token
});
console.log("\nForking...");
for (let uri of this.commander.uris) {
try {
console.log(`\n+ URI: ${uri}`);
await forker.fork(uri)
console.log(" done!")
} catch(err) {
console.error(" " + err.toString())
}
}
}
}
export default CLI;
new CLI().execute();
|
Markdown | UTF-8 | 1,043 | 2.65625 | 3 | [
"MIT",
"Apache-2.0"
] | permissive | ---
layout: post
data: 2018-04-22
title: "gdbๅๆฑ็ผ่ฐ่ฏ"
subtitle: "Debugging with GDB disas!"
author: "Zxy"
tags:
- Linux
---
**ๅจๅฉ็จgdb่ฐ่ฏ็ๆถๅ๏ผๆไปฌๅ็ฐ๏ผๆๆถๅฏไปฅ้่ฟๆฅ็ๅฎ็ๆฑ็ผไปฃ็ ่ฟ่กๆฑ็ผ็บงๅซ็่ฐ่ฏ๏ผๅนถ้่ฟ่งๅฏๅฏๅญๅจๅ
ๅผ็ๅๅๆฅๆจๆตๆบๅจๅ
้จๅฑๆฌก็ๆไฝ๏ผๆดๅฅฝ็็่งฃ็จๅบๅจๆบๅจๅ
้จ็่ฟ่ก๏ผ่ฟ้ๅฐฑ็ปๅบgdbไธๆฅ็ๆฑ็ผไปฃ็ ็ๆๆฎตใ**
`(gdb) disas main`็จๆฅๆฅ็mainๅฝๆฐ็ๆฑ็ผไปฃ็ ๏ผ่ฟไธชๆถๅๆฒกๆๅ ไปปไฝ็ๅๆฐ๏ผๆพ็คบๅบๆฅๅฐฑๆฏๅ็บฏ็mainๅฝๆฐๅ
จ้จ็ๆฑ็ผไปฃ็ ใ
`(gdb) disas /m main`ไพๆง็จๆฅๆฅ็mainๅฝๆฐ็ๆฑ็ผไปฃ็ ๏ผไฝๆฏ่ฟไธชๆถๅไผๅฐๆๆ็ไปฃ็ ไนไธ่ตทๆ ็
งๅฐไธๅฑ๏ผๆจ่่ฟ็งๅๆณใ
้่ฟb่ฎพ็ฝฎๅฎๆญ็นไปฅๅ๏ผ้่ฟrๅผๅง่ฟ่ก๏ผๅฝ่ฟ่กๅฐ็ฌฌไธไธชๆญ็นๅๆญข็ๆถๅ๏ผๅฉ็จ`display /i $pc`ๆไปค่ฟ่ก่ฎพ็ฝฎ
`(gdb) si`้่ฟsiๆไปคๅๆญฅ่ท่ธชไธๆกๆบๅจๆไปค
`(gdb) i r`ไฝฟ็จi rๆไปคๆฅ็ๆๆๅฏๅญๅจ็ๅผ
ไฝฟ็จx/na %espๆฅ็ๅ ๆ ็ๅๅใ |
C | UTF-8 | 1,837 | 4.46875 | 4 | [] | no_license | /*
* Name : Kuldeep Singh Bhandari
* Roll No. : 111601009
* Aim : To search an element in a circular linked
* Date : 08-08-2017
*/
#include<stdio.h>
#include<stdlib.h>
//structure to store data, previous pointer and next pointer
typedef struct node {
int data;
struct node *next;
struct node *prev;
} node;
//creating the node
node * createNode (int N) {
node *head = (node *) malloc(sizeof(node));
int value;
printf("Enter data : ");
scanf("%d", &value);
head->data = value;
head->prev = NULL;
head->next = NULL;
node *t = head;
int i;
for (i = 1; i < N; i++) {
scanf("%d", &value);
node *p = (node *) malloc(sizeof(node));
p->data = value;
if (i != 1) {
p->prev = t;
}
t->next = p;
t = p;
}
head->prev = t;
t->next = head;
return head; //returning head pointer
}
//display the data
void display (node *head) {
node *p = head;
do {
printf("Data : %d\n", p->data);
p = p->next;
} while (p != head);
}
//checking if the element is there or not in the list
int IsElementThere (node *head, int ele) {
node *p = head;
int success = 0;
do {
if (p->data == ele) {
success = 1;
break;
}
p = p->next;
} while (p != head);
return success; //return 1 if elements exists, 0 otherwise
}
int main () {
int N;
printf("Enter the number of elements : \n");
scanf("%d", &N);
node *head = createNode(N); //creating the Node
display (head);
int searchElement;
printf("ENTER THE SEARCH ELEMENT : \n");
scanf("%d", &searchElement); //entering the search Element
printf("SEARCHING THE ELEMENT %d IN THE LIST : \n", searchElement);
if (IsElementThere (head, searchElement)) {
printf("BINGO !! The element %d exists.\n", searchElement);
}
else {
printf("SORRY !! The element %d doesn't exist.\n", searchElement);
}
return 0;
}
|
Java | UTF-8 | 2,068 | 2.109375 | 2 | [] | no_license | package com.android.poinku.viewmodel;
import android.app.Application;
import androidx.annotation.NonNull;
import androidx.lifecycle.AndroidViewModel;
import androidx.lifecycle.MutableLiveData;
import com.android.poinku.api.response.BaseResponse;
import com.android.poinku.api.response.DataPoinResponse;
import com.android.poinku.api.response.KriteriaResponse;
import com.android.poinku.api.response.KriteriaTugasKhususResponse;
import com.android.poinku.api.response.MahasiswaResponse;
import com.android.poinku.api.response.NilaiResponse;
import com.android.poinku.api.response.TotalPoinResponse;
import com.android.poinku.repository.OnlineRepository;
public class MainViewModel extends AndroidViewModel {
private OnlineRepository onlineRepository;
public MainViewModel(@NonNull Application application) {
super(application);
onlineRepository = new OnlineRepository();
}
public MutableLiveData<MahasiswaResponse> getMahasiswa(String nrp) {
return onlineRepository.getMahasiswa(
nrp
);
}
public MutableLiveData<TotalPoinResponse> getTotalPoin(String nrp) {
return onlineRepository.getTotalPoin(
nrp
);
}
public MutableLiveData<BaseResponse> getIsValidasi(String nrp) {
return onlineRepository.getIsValidasi(
nrp
);
}
public MutableLiveData<NilaiResponse> getNilai(String id) {
return onlineRepository.getNilai(
id
);
}
public MutableLiveData<KriteriaResponse> getKriteria(String id) {
return onlineRepository.getKriteria(
id
);
}
public MutableLiveData<KriteriaTugasKhususResponse> getKriteriaTugasKhusus(String nrp) {
return onlineRepository.getKriteriaTugasKhusus(
nrp
);
}
public MutableLiveData<BaseResponse> putPengajuanTugasKhusus(String nrp, String nilai) {
return onlineRepository.putPengajuanTugasKhusus(
nrp,
nilai
);
}
}
|
PHP | UTF-8 | 8,596 | 3.03125 | 3 | [] | no_license | <?php
<<<<<<< HEAD
require_once "conexion.php";
class ModeloUsuarios{
=======
namespace Modelos;
require_once "conexion.php";
use \Modelos\Conexion;
use \Exception, \PDOException;
use PDO;
use Libs\Helper;
class ModeloUsuarios extends Conexion{
>>>>>>> fernando
/*=============================================
MOSTRAR USUARIOS
=============================================*/
static public function mdlMostrarUsuarios($tabla, $item, $valor){
if($item != null){
$stmt = Conexion::conectar()->prepare("SELECT * FROM $tabla WHERE $item = :$item");
$stmt -> bindParam(":".$item, $valor, PDO::PARAM_STR);
$stmt -> execute();
return $stmt -> fetch();
}else{
$stmt = Conexion::conectar()->prepare("SELECT * FROM $tabla");
$stmt -> execute();
return $stmt -> fetchAll();
}
$stmt -> close();
$stmt = null;
}
/*=============================================
REGISTRO DE USUARIO
=============================================*/
static public function mdlIngresarUsuario($tabla, $datos){
<<<<<<< HEAD
$stmt = Conexion::conectar()->prepare("INSERT INTO $tabla(nombre, usuario, password, perfil, foto, correo) VALUES (:nombre, :usuario, :password, :perfil, :foto, :correo)");
=======
$stmt = Conexion::conectar()->prepare("INSERT INTO $tabla(nombre, usuario, password, perfil, foto) VALUES (:nombre, :usuario, :password, :perfil, :foto)");
>>>>>>> fernando
$stmt->bindParam(":nombre", $datos["nombre"], PDO::PARAM_STR);
$stmt->bindParam(":usuario", $datos["usuario"], PDO::PARAM_STR);
$stmt->bindParam(":password", $datos["password"], PDO::PARAM_STR);
$stmt->bindParam(":perfil", $datos["perfil"], PDO::PARAM_STR);
$stmt->bindParam(":foto", $datos["foto"], PDO::PARAM_STR);
<<<<<<< HEAD
$stmt->bindParam(":correo", $datos["correo"], PDO::PARAM_STR);
=======
>>>>>>> fernando
if($stmt->execute()){
return "ok";
}else{
return "error";
}
$stmt->close();
$stmt = null;
}
/*=============================================
EDITAR USUARIO
=============================================*/
static public function mdlEditarUsuario($tabla, $datos){
<<<<<<< HEAD
$stmt = Conexion::conectar()->prepare("UPDATE $tabla SET nombre = :nombre, password = :password, perfil = :perfil, foto = :foto, correo = :correo WHERE usuario = :usuario");
=======
$stmt = Conexion::conectar()->prepare("UPDATE $tabla SET nombre = :nombre, password = :password, perfil = :perfil, foto = :foto WHERE usuario = :usuario");
>>>>>>> fernando
$stmt -> bindParam(":nombre", $datos["nombre"], PDO::PARAM_STR);
$stmt -> bindParam(":password", $datos["password"], PDO::PARAM_STR);
$stmt -> bindParam(":perfil", $datos["perfil"], PDO::PARAM_STR);
$stmt -> bindParam(":foto", $datos["foto"], PDO::PARAM_STR);
<<<<<<< HEAD
$stmt -> bindParam(":correo", $datos["correo"], PDO::PARAM_STR);
$stmt -> bindParam(":usuario", $datos["usuario"], PDO::PARAM_STR);
=======
$stmt -> bindParam(":usuario", $datos["usuario"], PDO::PARAM_STR);
>>>>>>> fernando
if($stmt -> execute()){
return "ok";
}else{
return "error";
}
$stmt -> close();
$stmt = null;
}
/*=============================================
ACTUALIZAR USUARIO
=============================================*/
static public function mdlActualizarUsuario($tabla, $item1, $valor1, $item2, $valor2){
$stmt = Conexion::conectar()->prepare("UPDATE $tabla SET $item1 = :$item1 WHERE $item2 = :$item2");
$stmt -> bindParam(":".$item1, $valor1, PDO::PARAM_STR);
$stmt -> bindParam(":".$item2, $valor2, PDO::PARAM_STR);
if($stmt -> execute()){
return "ok";
}else{
return "error";
}
$stmt -> close();
$stmt = null;
}
/*=============================================
BORRAR USUARIO
=============================================*/
static public function mdlBorrarUsuario($tabla, $datos){
$stmt = Conexion::conectar()->prepare("DELETE FROM $tabla WHERE id = :id");
$stmt -> bindParam(":id", $datos, PDO::PARAM_INT);
if($stmt -> execute()){
return "ok";
}else{
return "error";
}
$stmt -> close();
$stmt = null;
}
<<<<<<< HEAD
=======
/*=============================================
VERIFICACION DE CORREO
=============================================*/
static public function getUserWithEmail($p_correo)
{
$stmt = Conexion::conectar()->prepare("SELECT id, nombre, usuario,correo, password , perfil,foto, estado,ultimo_login, Ordenes, fecha, codigo, fechaRecuperacion FROM usuarios WHERE correo= :p_correo LIMIT 1");
$parameters = array(':p_correo' => $p_correo);
try {
$query = $stmt;
$query->execute($parameters);
return ($query->rowcount() ? $query->fetch() : false);
} catch (PDOException $e) {
$logModel = new Log();
$sql = Helper::debugPDO($stmt, $parameters);
$logModel->addLog($sql, 'User', $e->getCode(), $e->getMessage());
return false;
} catch (Exception $e) {
$logModel = new Log();
$sql = Helper::debugPDO($sql, $parameters);
$logModel->addLog($sql, 'User', $e->getCode(), $e->getMessage());
return false;
}
}
/**
* Obtener una persona por el cรณdigo generado para el cambio de contraseรฑa
* @param string $p_codigo
*/
public function getUserWithCode($p_codigo)
{
$sql = "SELECT id, nombre, usuario,correo, password , perfil,foto, estado,ultimo_login, Ordenes, fecha, codigo, fechaRecuperacion FROM usuario WHERE codigo = :p_codigo LIMIT 1";
$parameters = array(':p_codigo' => $p_codigo);
try {
$query = $this->db->prepare($sql);
$query->execute($parameters);
return ($query->rowcount() ? $query->fetch() : false);
} catch (PDOException $e) {
$logModel = new Log();
$sql = Helper::debugPDO($sql, $parameters);
$logModel->addLog($sql, 'User', $e->getCode(), $e->getMessage());
return false;
} catch (Exception $e) {
$logModel = new Log();
$sql = Helper::debugPDO($sql, $parameters);
$logModel->addLog($sql, 'User', $e->getCode(), $e->getMessage());
return false;
}
}
/*=============================================
ACTUALIACION DE CODIGO Y FECHA DE RECUPERACION
=============================================*/
public function recoverPassword($p_correo, $p_codigo, $p_fechaRecuperacion)
{
$stmt = Conexion::conectar()->prepare( "UPDATE usuarios SET codigo = :p_codigo, fechaRecuperacion = :p_fechaRecuperacion WHERE correo = :p_correo");
$parameters = array(
':p_correo' => $p_correo,
':p_codigo' => $p_codigo,
':p_fechaRecuperacion' => $p_fechaRecuperacion
);
try {
$query = $stmt;
return $query->execute($parameters);
} catch (PDOException $e) {
$logModel = new Log();
$sql = Helper::debugPDO($stmt, $parameters);
$logModel->addLog($sql, 'User', $e->getCode(), $e->getMessage());
return false;
} catch (Exception $e) {
$logModel = new Log();
$sql = Helper::debugPDO($sql, $parameters);
$logModel->addLog($sql, 'User', $e->getCode(), $e->getMessage());
return false;
}
}
/**
* Cambiar la contraseรฑa desde la recuperaciรณn de la cuenta
* @param string $p_idUsuario Id Usuario
* @param string $p_contrasena Contraseรฑa
*/
public function updatePasswordFromRecover($p_id, $p_password)
{
$stmt = Conexion::conectar()->prepare("UPDATE usuarios SET password = :p_password, codigo = NULL, fechaRecuperacion = NULL WHERE id = :p_id");
$parameters = array(
':p_password' => $p_password,
':p_id' => $p_id
);
try {
$query = $stmt;
return $query->execute($parameters);
} catch (PDOException $e) {
$logModel = new Log();
$sql = Helper::debugPDO($stmt, $parameters);
$logModel->addLog($sql, 'User', $e->getCode(), $e->getMessage());
return false;
} catch (Exception $e) {
$logModel = new Log();
$sql = Helper::debugPDO($sql, $parameters);
$logModel->addLog($sql, 'User', $e->getCode(), $e->getMessage());
return false;
}
}
>>>>>>> fernando
} |
Go | UTF-8 | 1,628 | 3.3125 | 3 | [
"MIT"
] | permissive | package repository
import (
"github.com/jinzhu/gorm"
"log"
)
type ExchangeRate struct {
ID int64 `json:"id"`
CurrencyFrom string `json:"currency_from"`
CurrencyTo string `json:"currency_to"`
}
type RateRepositoryItf interface {
GetExchangeRateList() ([]ExchangeRate)
InsertExchangeRate(*ExchangeRate) error
DeleteExchangeRateByID(*ExchangeRate) error
GetExchangeRateIDByCurrencyPair(*ExchangeRate) (int64, error)
}
type RateRepository struct {
DB *gorm.DB
}
func (r RateRepository) GetExchangeRateList() []ExchangeRate {
var rateList []ExchangeRate
result := r.DB.Find(&rateList)
if result.Error != nil {
log.Printf("[RateRepository - GetExchangeRateList] : %s", result.Error)
return nil
}
return rateList
}
func (r RateRepository) InsertExchangeRate(rate *ExchangeRate) error {
result := r.DB.Create(rate)
if result.Error != nil {
log.Printf("[RateRepository - InsertExchangeRate] : %s", result.Error)
return result.Error
}
return nil
}
func (r RateRepository) DeleteExchangeRateByID(rate *ExchangeRate) error {
result := r.DB.Delete(rate)
if result.Error != nil {
log.Printf("[RateRepository - DeleteExchangeRateByID] : %s", result.Error)
return result.Error
}
return nil
}
func (r RateRepository) GetExchangeRateIDByCurrencyPair(rate *ExchangeRate) (id int64, err error) {
err = r.DB.Raw("SELECT id "+
"FROM exchange_rates "+
"WHERE currency_from = ? AND currency_to = ?", rate.CurrencyFrom, rate.CurrencyTo).Row().Scan(&id)
if err != nil {
log.Printf("[RateRepository - GetExchangeRateIDByCurrencyPair] : %s", err)
return 0, err
}
return id, nil
}
|
C++ | UTF-8 | 1,067 | 2.734375 | 3 | [
"MIT"
] | permissive | #ifndef NIL_SRC_META_INC_META_NONESUCH_HPP_
#define NIL_SRC_META_INC_META_NONESUCH_HPP_
#include <type_traits>
namespace nil {
struct none_such {
none_such() = delete;
none_such(const none_such&) = delete;
none_such(none_such&&) = delete;
none_such& operator=(const none_such&) = delete;
none_such& operator=(none_such&&) = delete;
};
struct MoveOnly {
MoveOnly() = default;
MoveOnly(const MoveOnly&) = delete;
MoveOnly& operator=(const MoveOnly&) = delete;
MoveOnly(MoveOnly&&) noexcept = default;
MoveOnly& operator=(MoveOnly&&) noexcept = default;
};
struct NonDefaultConstructible {
NonDefaultConstructible() = delete;
NonDefaultConstructible(int ii_) : ii{ii_} {}
NonDefaultConstructible(const NonDefaultConstructible&) = default;
NonDefaultConstructible& operator=(const NonDefaultConstructible&) = default;
NonDefaultConstructible(NonDefaultConstructible&&) = default;
NonDefaultConstructible& operator=(NonDefaultConstructible&&) = default;
int ii;
};
} // namespace nil
#endif // NIL_SRC_META_INC_META_NONESUCH_HPP_ |
C++ | UTF-8 | 694 | 3.046875 | 3 | [] | no_license | #include <iostream>
#include <windows.h>
#include "Song.h"
using namespace std;
void main() {
Song s1;
Song s2;
Song s3("Ne sum siguren", 1,90);
Song s4;
cout << s3.getName() << " " << s3.getMinutes() << " " << s3.getSeconds() << endl;
//expect Ne sum siguren 1 30
cout << (s1 != s2) << endl;
// expect 0
s2.setName("Uber guiar solo");
s2.setMinutes(2);
s2.setSeconds(-1);
cout << s2.getName() << " " << s2.getMinutes() << " "<< s2.getSeconds() << endl;
// expect: Uber guitar solo 2 0
cout << (s1 > s2) << endl;
// expect 0
s3 = "Smells like teen spirit 04:23";
cout << s3.getName() << " " << s3.getMinutes() << " " << s3.getSeconds() << endl;
system("pause");
} |
C++ | WINDOWS-1252 | 610 | 2.859375 | 3 | [] | no_license | /*
* @Author: your name
* @Date: 2020-04-02 16:56:10
* @LastEditTime: 2020-04-02 19:27:49
* @LastEditors: Please set LastEditors
* @Description: Stack
* @FilePath: \Stack\Src\main.cpp
*/
#include <iostream>
#include "Stack.h"
#include <vector>
int main( ){
// std::vector<int> v;
// v.push_back( 1 );
// v.push_back( 2 );
// v.push_back( 3 );
// v.pop_back( );
Stack<int> s;
s.push( 1 );
s.push( 2 );
s.push( 3 );
s.print( );
s.pop( );
int num = s.top( );
Stack<int> s1( s );
Stack<int> s2;
s2 = s1;
s2.clear( );
return 0;
} |
Python | UTF-8 | 17,139 | 2.515625 | 3 | [] | no_license | import numpy as np
import itertools
import DIRECT
from scipy.optimize import fsolve, minimize
from scipy.stats import norm, lognorm
from sympy import *
from sklearn.metrics.pairwise import euclidean_distances
import copy
import os
Theta1 = 0.35 #hyperparameter of kernel
Theta2 = 0.005 #hyperparameter of kernel
N_Iteration = 10 #number of iteration of bending path
Gamma = 10 #hyperparameter of optimization
Gran = 10 #hyperparameter of optimization
class Interactive_BO():
def __init__(self, bound, filepath, mode="linewise", sgm=1, theta_fixed=True):
self._theta_fixed = theta_fixed
self._bound = np.array(bound)
assert len(self._bound.shape) == 2
assert sgm > 0
self._ndim = self._bound.shape[0]
self._x = [] #already presented parameters
self._u = [] #where is selected parameter in x
self._v = [] #where is not selected parameter in x
self._sgm = sgm #hyperparameter
self._theta = np.ones(self._ndim+2)*Theta1 #hyperparameter
self._theta[self._ndim:] = Theta2 #hyperparameter
self._kernel = RBF(self._ndim)
self._filepath = filepath
self._mode = mode
def query(self, last_selected=[], N=5):
self._x = []
self._u = []
self._v = []
pll = []
qll = []
#get data from a history file
if not os.path.exists(self._filepath):
print("No history file")
if self._mode == "setwise":
candidates = self._init_candidates_setwise(N)
elif self._mode == "linewise":
candidates = self._init_candidates_linewise()
elif self._mode == "pathwise":
candidates = self._init_candidates_pathwise(N)
else:
print("mode"+ self._mode +" is not implemented!")
raise
else:
try:
with open(self._filepath) as f:
lines=f.readlines()
for line in lines:
line = line.split('>')
pl = line[0].split(' ')
ql = line[1].split(' ')
pl = [np.array([float(i) for i in p.strip('[]').split(',')]) for p in pl]
ql = [np.array([float(i) for i in q.strip('[]\n').split(',')]) for q in ql]
for p in pl:
if self._x == [] or not np.any(np.all(self._x == p,axis=1)):
self._x.append(p)
for q in ql:
if self._x == [] or not np.any(np.all(self._x == q,axis=1)):
self._x.append(q)
self._x = list(map(np.array, set(map(tuple, self._x))))
pll.append(pl)
qll.append(ql)
except:
print("Invalid history file")
raise
else:
for i in range(len(pll)):
pl = pll[i]
ql = qll[i]
for p in pl:
self._u.append(np.where(np.all(self._x==p,axis=1))[0][0])
self._v.append([np.where(np.all(self._x==q,axis=1))[0][0] for q in ql])
self._klu =np.linalg.cholesky(self._kernel(self._x))
self._klu_t =np.linalg.cholesky(self._kernel(self._x).T)
#estimate hyperparameter and latent utility function
self._kernel._X = self._x
self._maximize_posterior()
print("self._fMAP",self._fMAP)
print("self._theta",self._theta)
self._kfmap = np.linalg.solve(self._kernel(self._x),self._fMAP)
if self._mode == "setwise":
candidates = self._candidates_setwise(N, last_selected)
elif self._mode == "linewise":
candidates = self._candidates_linewise(last_selected)
elif self._mode == "pathwise":
candidates = self._candidates_pathwise(N, last_selected)
else:
print("mode"+ self._mode +" is not implemented!")
raise
return candidates
def _init_candidates_setwise(self, N):
candidates = np.array(self._bound[:,0]) + (np.array(self._bound[:,1]) - np.array(self._bound[:,0])) * np.random.rand(N,self._ndim)
return candidates
def _init_candidates_linewise(self):
init_rand = np.array([np.zeros(self._ndim),np.ones(self._ndim)])
init = np.array(self._bound[:,0]) + (np.array(self._bound[:,1]) - np.array(self._bound[:,0])) * init_rand
candidates = [init[0],init[1]]
return candidates
def _init_candidates_pathwise(self, N):
init_rand = np.array([np.zeros(self._ndim),np.ones(self._ndim)])
init = np.array(self._bound[:,0]) + (np.array(self._bound[:,1]) - np.array(self._bound[:,0])) * init_rand
candidates = np.array([np.linspace(i[0],i[1],N) for i in init.T]).T
return candidates
def _candidates_setwise(self, N, last_selected):
""" Return set of candidates. """
candidates = last_selected
x_swap = copy.deepcopy(self._x)
f_swap = copy.copy(self._fMAP)
for i in range(N-len(last_selected)):
self._kfmap = np.linalg.solve(self._kernel(self._x),self._fMAP)
self._klu =np.linalg.cholesky(self._kernel(self._x))
self._klu_t =np.linalg.cholesky(self._kernel(self._x).T)
x_ie = self._argmax_expected_improvement() + 0.001*np.random.rand()
self._fMAP = np.append(self._fMAP,self._mean([x_ie]))
self._x.append(x_ie)
candidates = np.vstack((candidates,np.array([x_ie])))
self._x = copy.deepcopy(x_swap)
self._fMAP = copy.copy(f_swap)
self._klu =np.linalg.cholesky(self._kernel(self._x))
self._klu_t =np.linalg.cholesky(self._kernel(self._x).T)
self._kfmap = np.linalg.solve(self._kernel(self._x),self._fMAP)
return candidates
def _candidates_linewise(self, last_selected):
x_ei = self._argmax_expected_improvement()
"""if np.any(np.sum((x_ie-np.array(self._x))**2,axis=1) < 1e-5):
raise Exception("Maximum expected improvement is duplicated") """
if last_selected == []:
#set one end as last_selected input
x_max = self._x[np.argmax(self._fMAP)]
else:
x_max = last_selected[0]
candidates = [x_max,x_ei]
return candidates
def _candidates_pathwise(self, N, last_selected):
def obj_sd(x,data):
return (-self._sd([x]),0)
if last_selected == []:
#set one end as last_selected input
x_max = self._x[np.argmax(self._fMAP)]
else:
x_max = last_selected[0]
# use DIRECT algorithm
x_argmax_sd, _, _ = DIRECT.solve(obj_sd, self._bound[:,0], self._bound[:,1],
maxf=1000, algmethod=1)
pivots = np.array([np.linspace(x_max[i],x_argmax_sd[i],N) for i in range(len(x_max))]).T
pivots = self._bend(pivots)
return list(pivots)
def _log_likelihood(self, f=None):
if f is None: f = self._fMAP
frac = np.exp(f[np.array(self._u)]/self._sgm)
denomi = np.zeros(len(self._v))
for i in range(len(self._v)):
denomi[i] += np.sum(np.exp(f[np.array(self._v)[i]]/self._sgm))
denomi += np.exp(f[np.array(self._u)]/self._sgm)
return np.sum(np.log(frac/denomi))
def _d_log_likelihood(self, f=None):
d_ll = np.zeros(len(f)+self._ndim+2)
for i, fi in enumerate(f):
for j in range(len(self._u)):
pat2 = -np.exp(fi/(self._sgm)) / (self._sgm * (np.sum(np.exp(f[np.array(self._v[j])]))+np.exp(f[self._u[j]])))
pat1 = 1 / self._sgm + pat2
if i == self._u[j]:
d_ll[i] += pat1
elif np.any(i==np.array(self._v[j])):
d_ll[i] += pat2
return d_ll
def _log_prior_theta(self, theta):
if theta is None: theta = self._theta
lnd1 = lognorm.pdf(theta[0:self._ndim],0.1,loc=np.log(0.5))
lnd2 = lognorm.pdf(theta[self._ndim:],0.1,loc=np.log(0.005))
return np.sum(np.log(lnd1)) + np.sum(np.log(lnd2))
def _d_log_prior_theta(self, theta):
if theta is None: theta = self._theta
d_lpt = np.zeros(len(self._x)+len(theta))
loc = np.append(np.ones(self._ndim)*np.log(0.5),np.ones(2)*np.log(0.005))
d_lpt[len(self._x):] = -1/theta + (-1/theta) * (np.log(theta)-loc)/((0.1)**2)
return d_lpt
def _log_prior(self, f, theta):
if f is None: f = self._fMAP
if self._theta_fixed == True:
alpha = np.linalg.solve(self._klu,f)
return -0.5*np.sum(alpha**2)
else:
alpha = np.linalg.solve(np.linalg.cholesky(self._kernel(X=self._x,theta=theta)),f)
return -0.5*np.sum(alpha**2) + self._log_prior_theta(theta)
def _d_log_prior_fix(self, f, theta):
alpha = np.linalg.solve(self._klu,f)
return -alpha
def _d_log_prior(self, f, theta):
if f is None: f = self._fMAP
d_lp = np.zeros(len(f)+len(theta))
alpha = np.linalg.solve(np.linalg.cholesky(self._kernel(X=self._x,theta=theta)),f)
d_lp[0:len(f)] = -alpha
for k in range(len(theta)):
kernel = self._kernel(X=self._x,theta=theta)
if k < self._ndim:
d_kernel = np.array([[theta[self._ndim] * np.exp(-np.sum((np.array(i)-np.array(j))**2/(2*theta[0:self._ndim]**2))) * (np.array(i)[k]-np.array(j)[k])**2/(theta[k]**3) for i in self._x] for j in self._x])
elif k == self._ndim:
d_kernel = np.array([[np.exp(-np.sum((np.array(i)-np.array(j))**2/(2*theta[0:self._ndim]**2))) for i in self._x] for j in self._x])
else:
d_kernel = np.eye(len(f))
d_lp[len(f)+k] = 0.5 * np.matmul(f, np.linalg.solve(kernel, np.matmul(d_kernel, np.linalg.solve(kernel,f))) )
d_lp[len(f)+k] += -0.5 * np.trace(np.matmul(np.linalg.inv(kernel),d_kernel))
if self._theta_fixed == True:
return d_lp
else:
return d_lp + self._d_log_prior_theta(theta)
def _unnorm_log_posterior_fix(self, f):
if f is None: f = self._fMAP
return -self._log_likelihood(f) - self._log_prior(f,self._theta)
def _unnorm_log_posterior(self, f, theta):
if f is None: f = self._fMAP
return -self._log_likelihood(f) - self._log_prior(f,theta)
def _d_unnorm_log_posterior_fix(self, f):
if f is None: f = self._fMAP
return -self._d_log_likelihood(f)[:len(f)] - self._d_log_prior_fix(f,self._theta)
def _d_unnorm_log_posterior(self, f, theta):
if f is None: f = self._fMAP
return -self._d_log_likelihood(f) - self._d_log_prior(f,theta)
def _unnorm_log_posterior_sub_fix(self, X=None):
return self._unnorm_log_posterior_fix(X[0:len(self._x)])
def _unnorm_log_posterior_sub(self, X=None):
return self._unnorm_log_posterior(X[0:len(self._x)],X[len(self._x):])
def _d_unnorm_log_posterior_sub_fix(self, X=None):
return self._d_unnorm_log_posterior_fix(X[0:len(self._x)])
def _d_unnorm_log_posterior_sub(self, X=None):
return self._d_unnorm_log_posterior(X[0:len(self._x)],X[len(self._x):])
def _argmax_posterior_fix(self):
init = np.zeros(len(self._x))
bns = [(-5,5)]*(len(self._x))
self._klu = np.linalg.cholesky(self._kernel(X=self._x,theta=self._theta))
opt = minimize(self._unnorm_log_posterior_sub_fix,init,method='L-BFGS-B', bounds=bns, jac=self._d_unnorm_log_posterior_sub_fix, options={'maxiter':100})
return opt.x
def _argmax_posterior(self):
init = np.zeros(len(self._x)+self._ndim+2)
init[len(self._x):] = np.ones(self._ndim+2)*0.1
bns = [(-5,5)]*(len(self._x)+self._ndim+2)
bns[len(self._x):] = [(0.000001,None)]*(self._ndim+2)
opt = minimize(self._unnorm_log_posterior_sub,init,method='L-BFGS-B', bounds=bns, jac=self._d_unnorm_log_posterior_sub, options={'maxiter':100})
return opt.x
def _maximize_posterior(self):
if self._theta_fixed == True:
opt = self._argmax_posterior_fix()
self._fMAP = opt
self._kernel._theta = self._theta
else:
opt = self._argmax_posterior() #predicted value at observed points
self._fMAP = opt[0:len(self._x)]
self._theta = opt[len(self._x):]
self._kernel._theta = self._theta
def _mean(self, x):
ks = self._kernel(x,self._x)
return np.matmul(ks.T, self._kfmap)
def _d_mean(self,x):
ks = self._kernel(x,self._x)
ks_d = np.array([[[0 if np.all(i==j) else self._theta[self._ndim] * (-(i[k]-j[k])/self._theta[k]**2) * np.exp(-np.sum((np.array(i)-np.array(j))**2/(2*self._theta[0:self._ndim]**2))) for k in range(self._ndim)] for i in x] for j in self._x])
ks_d = ks_d.transpose()
return np.matmul(ks_d, self._kfmap).transpose()
def _sd(self, x):
kss = self._kernel(x,x)
ks = self._kernel(x,self._x)
sd = np.diag(kss) - np.sum(np.linalg.solve(self._klu,ks)**2,axis=0)
return sd
def _co_sd(self, x):
""" standard co-deviation """
kss = self._kernel(x,x)
ks = self._kernel(x,self._x)
sol = np.linalg.solve(self._klu,ks)
sd = kss - np.matmul(sol.T,sol)
return sd
def _d_sd(self, x):
ks = self._kernel(x,self._x)
ks_d = np.array([[[0 if np.all(i==j) else self._theta[self._ndim] * (-(i[k]-j[k])/self._theta[k]**2) * np.exp(-np.sum((np.array(i)-np.array(j))**2/(2*self._theta[0:self._ndim]**2))) for k in range(self._ndim)] for i in x] for j in self._x])
ks_d = ks_d.transpose()
sd_d = - np.matmul(ks_d, (np.linalg.solve(self._klu.T,np.linalg.solve(self._klu,ks))+np.linalg.solve(self._klu_t.T,np.linalg.solve(self._klu_t,ks)))).transpose()
return sd_d
def expected_improvement(self,x):
mean_max = np.max(self._fMAP)
mean = self._mean(x)
sd = self._sd(x)
ind = sd > 0
cdf = np.zeros(mean.shape)
cdf[ind] = norm.cdf((mean_max-mean[ind])/sd[ind])
x_ei = (mean-mean_max)*cdf+sd*cdf
return x_ei
def _d_expected_improvement(self,x):
mean_max = np.max(self._fMAP)
mean = self._mean(x)
d_mean = self._d_mean(x)
sd = self._sd(x)
d_sd = self._d_sd(x)
ind = sd > 0
cdf = np.zeros(mean.shape)
pdf = np.zeros(mean.shape)
cdf[ind] = norm.cdf((mean_max-mean[ind])/sd[ind])
pdf[ind] = norm.pdf((mean_max-mean[ind])/sd[ind])
d_x_ei = d_mean*cdf + (mean-mean_max)*pdf + d_sd*cdf + sd*pdf
return d_x_ei
def _argmax_expected_improvement(self):
def obj(x,data):
return (-self.expected_improvement([x]),0)
# use DIRECT algorithm
x, _, _ = DIRECT.solve(obj, self._bound[:,0], self._bound[:,1],
maxf=1000, algmethod=1)
return x
def _bend(self, pivots):
""" bend a path by moving pivots """
for i in range(N_Iteration):
for j in range(len(pivots)-2):
j = j + 1
F = self._d_expected_improvement([pivots[j]]).reshape(self._ndim)
pivots[j] = pivots[j] + Gamma * F
d = np.linalg.norm(pivots[j] - pivots[j-1])
if d < 0.01:
pivots[j] = pivots[j-1] + 0.01 * (pivots[j] - pivots[j-1])
if d > 0.4:
pivots[j] = pivots[j-1] + 0.4 * (pivots[j] - pivots[j-1])
for k in range(self._ndim):
if pivots[j][k] < self._bound[k,0]:
pivots[j][k] = self._bound[k,0]
if pivots[j][k] > self._bound[k,1]:
pivots[j][k] = self._bound[k,1]
return pivots
class RBF():
""" ARD squered exponential kernel """
def __init__(self, dim, X=None, Y=None, theta=None):
self._ndim = dim
if X is None: self._X = None
else: self._X = np.array(X)
if Y is None: self._Y = None
else: self._Y = np.array(Y)
if theta is None: self._theta = np.ones(self._ndim+2) * 0.1
else: self._theta = theta
def __call__(self, X=None, Y=None, theta=None):
if X is None and Y is None and theta is None: return self._K
if X is None: X = self._X
if Y is None: Y = self._Y
if Y is None: Y = X
if theta is None: theta = self._theta
self._ssd = np.array([[theta[self._ndim] + theta[self._ndim+1] if np.all(i==j) else theta[self._ndim] * np.exp(-np.sum((np.array(i)-np.array(j))**2/(2*theta[0:self._ndim]**2))) for i in X] for j in Y])
return self._ssd
|
Swift | UTF-8 | 3,475 | 2.78125 | 3 | [] | no_license | //
// PostPinViewController.swift
// On The Map
//
// Created by Jason Yu on 6/15/20.
// Copyright ยฉ 2020 Jason Yu. All rights reserved.
//
import UIKit
import MapKit
class PostPinViewController: UIViewController, MKMapViewDelegate {
@IBOutlet weak var activityIndicator: UIActivityIndicatorView!
var locationManger: CLLocationManager?
var firstName: String?
var lastName: String?
var mediaUrl: String?
var location: String?
var lat: Double?
var long: Double?
@IBOutlet weak var mapView: MKMapView!
override func viewDidLoad() {
super.viewDidLoad()
// activityIndicator.hidesWhenStopped = true
activityIndicator.startAnimating()
// Do any additional setup after loading the view.
print("POSTPIN: \(String(describing: lat))")
zoomToLatestLocation()
}
@IBAction func finishTapped(_ sender: Any) {
guard let firstName = firstName, let lastName = lastName, let mediaUrl = mediaUrl, let location = location, let lat = lat, let long = long else {
let alert = UIAlertController(title: "Error getting User Data", message: "", preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "Ok", style: .cancel, handler: nil))
self.present(alert, animated: true)
return
}
UserAPI.shared.postUserRequest(firstName: firstName, lastName: lastName, mediaUrl: mediaUrl, location: location, lat: lat, long: long) { result in
switch result {
case .success(_):
print("Success POSTING::")
DispatchQueue.main.async {
if let nav = self.navigationController {
nav.popViewController(animated: false)
nav.popViewController(animated: true)
} else {
self.dismiss(animated: true, completion: nil)
}
}
case .failure(let error):
print("Failure POSTING:: \(error)")
DispatchQueue.main.async {
let alert = UIAlertController(title: "Failed Post - Please try again", message: "\(error)", preferredStyle: .alert)
alert.addAction(UIAlertAction(title: "Ok", style: .cancel, handler: nil))
self.present(alert, animated: true)
}
}
}
}
func zoomToLatestLocation() {
guard let lat = lat, let long = long, let firstName = firstName, let lastName = lastName, let mediaUrl = mediaUrl else { return }
let postLocation = CLLocation(latitude: lat, longitude: long)
let regionRadius: CLLocationDistance = 2000000.0
let region = MKCoordinateRegion(center: postLocation.coordinate, latitudinalMeters: regionRadius, longitudinalMeters: regionRadius)
mapView.setRegion(region, animated: true)
addAnnotations(title: "\(String(describing: firstName)) \(String(describing: lastName))", subTitle: "\(String(describing: mediaUrl))", coordinate: CLLocationCoordinate2DMake(lat, long))
mapView.delegate = self
activityIndicator.stopAnimating()
}
func addAnnotations(title: String, subTitle: String, coordinate: CLLocationCoordinate2D) {
let userAnnotation = UserMarker(title: title, subtitle: subTitle, coordinate: coordinate)
mapView.addAnnotation(userAnnotation)
}
}
|
Python | UTF-8 | 1,237 | 2.5625 | 3 | [
"MIT"
] | permissive | #!/usr/bin/env python
import pickle
import sys
import getopt
import numpy as np
def main(argv, N_POINTS=100):
# parsing parameters
def usage():
print("""
usage:
-h: help
-n(--n_points): number of real space grid
-f: input files, seperated by ':'
""")
return 100
try:
opt_vals, _ = getopt.getopt(argv, 'hn:f:', ['help', 'file=', 'n_points='])
except getopt.GetoptError as err:
print(err)
return usage()
for (opt, vals) in opt_vals:
if opt in ['-h', '--help']: return usage()
elif opt in ['-f', '--file']: file_list = vals.split(':')
elif opt in ['-n', '--n_points']: N_POINTS = int(vals)
# read and transform files
for fname in file_list:
with open(fname, 'rb') as f:
data = pickle.load(f)
scaler, vec_q = data[:, 0].real, data[:, 1:]
vec_x = np.fft.irfft(vec_q, axis=1, n=N_POINTS)*N_POINTS
vec_x = vec_x.real
data_t = np.c_[scaler.reshape((-1, 1)), vec_x]
with open('_'.join([fname, '2x']), 'wb') as f2:
pickle.dump(file=f2, obj=data_t)
if __name__ == '__main__':
sys.exit(main(sys.argv[1:])) |
Shell | UTF-8 | 1,687 | 3.375 | 3 | [] | no_license | #!/bin/bash
# Copyright (C) 2014 Julien Bonjean <julien@bonjean.info>
# Copyright (C) 2014 Alexander Keller <github@nycroth.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/>.
# The first parameter sets the step to change the volume by (and units to display)
# This may be in in % or dB (eg. 5% or 3dB)
STEP="${1:-5%}"
# http://unix.stackexchange.com/a/251920/41707
getdefaultsinkname() {
pacmd stat | awk -F": " '/^Default sink name: /{print $2}'
}
volume() {
pacmd list-sinks |
awk '/^\s+name: /{indefault = $2 == "<'$(getdefaultsinkname)'>"}
/^\s+volume: / && indefault {print $5; exit}'
}
ismuted() {
pacmd list-sinks |
awk '/^\s+name: /{indefault = $2 == "<'$(getdefaultsinkname)'>"}
/^\s+muted: / && indefault {print $2; exit}'
}
case $BLOCK_BUTTON in
3) pactl set-sink-mute $(getdefaultsinkname) toggle ;; # right click, mute/unmute
4) pactl set-sink-volume $(getdefaultsinkname) +${STEP} ;; # scroll up, increase
5) pactl set-sink-volume $(getdefaultsinkname) -${STEP} ;; # scroll down, decrease
esac
#volume
ismuted | grep "yes" > /dev/null && echo "Muted" || volume |
Java | UTF-8 | 777 | 2.578125 | 3 | [] | no_license | /**
* Gets article count of the specified day.
* @param day the specified day
* @return article count
*/
public int getArticleCntInDay(final Date day){
final long time=day.getTime();
final long start=Times.getDayStartTime(time);
final long end=Times.getDayEndTime(time);
final Query query=new Query().setFilter(CompositeFilterOperator.and(new PropertyFilter(Keys.OBJECT_ID,FilterOperator.GREATER_THAN_OR_EQUAL,start),new PropertyFilter(Keys.OBJECT_ID,FilterOperator.LESS_THAN,end),new PropertyFilter(Article.ARTICLE_STATUS,FilterOperator.NOT_EQUAL,Article.ARTICLE_STATUS_C_INVALID)));
try {
return (int)articleRepository.count(query);
}
catch ( final RepositoryException e) {
LOGGER.log(Level.ERROR,"Count day article failed",e);
return 1;
}
}
|
Go | UTF-8 | 1,157 | 2.65625 | 3 | [] | no_license | package cli
import (
"fmt"
"os"
"github.com/bernos/ecso/pkg/ecso"
"github.com/bernos/ecso/pkg/ecso/dispatcher"
"gopkg.in/urfave/cli.v1"
)
func NewEnvironmentCliCommand(project *ecso.Project, dispatcher dispatcher.Dispatcher) cli.Command {
return cli.Command{
Name: "environment",
Usage: "Manage ecso environments",
Subcommands: []cli.Command{
NewEnvironmentAddCliCommand(project, dispatcher),
NewEnvironmentPsCliCommand(project, dispatcher),
NewEnvironmentUpCliCommand(project, dispatcher),
NewEnvironmentRmCliCommand(project, dispatcher),
NewEnvironmentDescribeCliCommand(project, dispatcher),
NewEnvironmentDownCliCommand(project, dispatcher),
},
}
}
func makeEnvironmentCommand(c *cli.Context, project *ecso.Project, fn func(*ecso.Environment) ecso.Command) (ecso.Command, error) {
name := c.Args().First()
if name == "" {
name = os.Getenv("ECSO_ENVIRONMENT")
}
if name == "" {
return nil, ecso.NewArgumentRequiredError("environment")
}
if !project.HasEnvironment(name) {
return nil, fmt.Errorf("Environment '%s' does not exist in the project", name)
}
return fn(project.Environments[name]), nil
}
|
Markdown | UTF-8 | 1,047 | 2.8125 | 3 | [
"MIT"
] | permissive | # ์คํฌ๋ฆฝํธ ๊ฐ ์ฐธ์กฐ
[์ ์ญ ๋ณ์](/AdvancedFunctions/Global_Static_Variables/)๋ [์ฌ์ฉ์ ์ ์ ํจ์](/AdvancedFunctions/Custom_Functions/)๋ฅผ ๊ฐ์ง๋ ๋ชจ๋ ์คํฌ๋ฆฝํธ๋ ์คํฌ๋ฆฝํธ ๊ฐ ์ฐธ์กฐ ๋ชฉ๋ก์ ๋ฑ๋ก๋ฉ๋๋ค.</2> dot-notaion์ ์ฌ์ฉํ์ฌ ์ด ํ๋๋ ํจ์๋ฅผ ์ก์ธ์ค ํ ์ ์์ต๋๋ค.
## ์ค๋ช
- ์คํฌ๋ฆฝํธ ๊ฐ ์ฐธ์กฐ๋ `scripts` ๊ฒฝ๋ก์๋ถํฐ ์์๋ฉ๋๋ค.
- `scripts.mySubfolder.a.zs`์ ๊ฐ์ด ์คํฌ๋ฆฝํธ ๋๋ ํ ๋ฆฌ๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ฒฝ๋ก๋ฅผ ์ง์นญํ ์ ์์ต๋๋ค.
- [import ์ ์ธ](/AdvancedFunctions/Import/)๊ณผ ๊ฐ์ ํ๊ธฐ๋ฒ์ ์ฌ์ฉํ์ฌ ์ฐธ์กฐํ ์คํฌ๋ฆฝํธ๋ฅผ ๊ณ ๋ฅผ ์ ์์ต๋๋ค.
- ZenScript์์ ๋จผ์ ๋งค์นญ๋๋ ๋๋ ํ ๋ฆฌ๋ฅผ ๋จผ์ ํ์ธํ ํ ํ์ผ์ด๋ ๊ฐ์ ํ์ธํฉ๋๋ค.
## ์์
`a.zs`์ `b.zs` ๋ ์คํฌ๋ฆฝํธ ํ์ผ์ด ์๋ค๊ณ ๊ฐ์ ํด๋ด
์๋ค.
a.zs:
```zenscript
static myVal as string = "myVal";
function makeLine() {
print("---------------");
}
```
b.zs
```zenscript
print(scripts.a.myVal);
scripts.a.makeLine();
``` |
Java | UTF-8 | 818 | 2.71875 | 3 | [] | no_license | package commands.authenicationCommands.login;
import commands.authenicationCommands.AuthenticationCommand;
/**
* The type Login command.
*/
public class LoginCommand extends AuthenticationCommand {
private final String username;
private final String password;
/**
* Instantiates a new Login command.
*
* @param username the email
* @param password the password
*/
public LoginCommand(String username, String password) {
this.username = username;
this.password = password;
}
/**
* Gets email.
*
* @return the email
*/
public String getUsername() {
return username;
}
/**
* Gets password.
*
* @return the password
*/
public String getPassword() {
return password;
}
}
|
Markdown | UTF-8 | 1,473 | 3.109375 | 3 | [] | no_license | # twiggyrj-kshatriya-jquery-slider
This is a basic carousel slider that was built in a day as a learning exercise to get better at JavaScript, jQuery and learn a bit of ES6.
This slider takes the following items when initialised:
| Option | Expected Value | What it is used for | Does it a default fallback |
| ------ | -------------- | ------------------- | -------------------------- |
| el | Carousel as an jQuery Object | Used to select the carousel item | No, this needs to be filled |
| sliderTrack | Carousel slider track as an jQuery Object | Used to select the carousel track | No, this needs to be filled |
| next | The element that will act as the next button | Will have an event bound to it | No, this needs to be filled |
| prev | The element that will act as the back button | Will have an event bound to it | No, this needs to be filledE |
| autoplay | Boolean TRUE/FALSE | Will decide if the carousel should autoplay | This set to FALSE if it is empty |
| autoplayCancel | Boolean TRUE/FALSE | Will decide if autoplay should stop once the controls have been interacted with | This set to TRUE if it is empty |
| autoplaySpeed | Time in MS e.g. 350ms is 0.35s | Will set how long a slide will show for before the carousel autoplays | This is set to 3000 if it is empty |
| speed | Time in MS e.g. 750ms is 0.75s | Will set the transition speed between each slide | This is set to 350 if it is empty |
This carousel includes a basic example in index.html
|
JavaScript | UTF-8 | 1,030 | 4.40625 | 4 | [] | no_license | /*
// Create datatypes.js file and use the JavaScript typeof operator to
// check different data types. Check the data type of each variable
*/
let alineName = 'Aline'
let strong = true
let undefinedVar
let nullVar = null
// Declare four variables without assigning values
let var1
let var2
let var3
let var4
// Declare four variables with assigned values
let var5 = 5
let var6 = 6
let var7 = 7
let var8 = 8
// Declare variables to store your first name, last name, marital status, country and age in multiple lines
let firstName = 'Aline'
let lastName = 'Fukuhara'
let maritalStatus = 'Single'
let country = 'Brazil'
let age = 28
// Declare variables to store your first name, last name, marital status, country and age in a single line
let firstName1 = 'Aline',
lastName1 = 'Fukuhara',
maritalStatus1 = 'Single',
country1 = 'Brazil',
age1 = 28
// Declare two variables myAge and yourAge and assign them initial values and log to the browser console.
let myAge = 28
let yourAge = 30
console.log(myAge, yourAge) |
C | UTF-8 | 2,456 | 2.71875 | 3 | [] | no_license | #define NULL ((void*)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t; typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1
/* Forward declarations */
typedef struct TYPE_6__ TYPE_2__ ;
typedef struct TYPE_5__ TYPE_1__ ;
/* Type definitions */
struct TYPE_5__ {int /*<<< orphan*/ * uuid128; int /*<<< orphan*/ uuid32; int /*<<< orphan*/ uuid16; } ;
struct TYPE_6__ {scalar_t__ len; TYPE_1__ uu; } ;
typedef TYPE_2__ tBT_UUID ;
typedef int /*<<< orphan*/ UINT8 ;
typedef int BOOLEAN ;
/* Variables and functions */
int LEN_UUID_128 ;
scalar_t__ LEN_UUID_16 ;
scalar_t__ LEN_UUID_32 ;
int TRUE ;
int /*<<< orphan*/ gatt_convert_uuid16_to_uuid128 (int /*<<< orphan*/ *,int /*<<< orphan*/ ) ;
int /*<<< orphan*/ gatt_convert_uuid32_to_uuid128 (int /*<<< orphan*/ *,int /*<<< orphan*/ ) ;
scalar_t__ memcmp (int /*<<< orphan*/ *,int /*<<< orphan*/ *,int) ;
BOOLEAN gatt_uuid_compare (tBT_UUID src, tBT_UUID tar)
{
UINT8 su[LEN_UUID_128], tu[LEN_UUID_128];
UINT8 *ps, *pt;
/* any of the UUID is unspecified */
if (src.len == 0 || tar.len == 0) {
return TRUE;
}
/* If both are 16-bit, we can do a simple compare */
if (src.len == LEN_UUID_16 && tar.len == LEN_UUID_16) {
return src.uu.uuid16 == tar.uu.uuid16;
}
/* If both are 32-bit, we can do a simple compare */
if (src.len == LEN_UUID_32 && tar.len == LEN_UUID_32) {
return src.uu.uuid32 == tar.uu.uuid32;
}
/* One or both of the UUIDs is 128-bit */
if (src.len == LEN_UUID_16) {
/* convert a 16 bits UUID to 128 bits value */
gatt_convert_uuid16_to_uuid128(su, src.uu.uuid16);
ps = su;
} else if (src.len == LEN_UUID_32) {
gatt_convert_uuid32_to_uuid128(su, src.uu.uuid32);
ps = su;
} else {
ps = src.uu.uuid128;
}
if (tar.len == LEN_UUID_16) {
/* convert a 16 bits UUID to 128 bits value */
gatt_convert_uuid16_to_uuid128(tu, tar.uu.uuid16);
pt = tu;
} else if (tar.len == LEN_UUID_32) {
/* convert a 32 bits UUID to 128 bits value */
gatt_convert_uuid32_to_uuid128(tu, tar.uu.uuid32);
pt = tu;
} else {
pt = tar.uu.uuid128;
}
return (memcmp(ps, pt, LEN_UUID_128) == 0);
} |
Java | UTF-8 | 4,563 | 2.203125 | 2 | [] | no_license | package cn.onlineexam.exam.servlet;
import java.io.IOException;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import cn.itcast.servlet.BaseServlet;
import cn.onlineexam.manager.domain.Json;
import cn.onlineexam.question.domain.Cloze;
import cn.onlineexam.question.domain.Judge;
import cn.onlineexam.question.domain.Program;
import cn.onlineexam.question.domain.QuestionSelect;
import cn.onlineexam.student.domain.Student;
import cn.onlineexam.exam.domain.Score;
import cn.onlineexam.exam.service.ExamService;
@SuppressWarnings("serial")
public class ExamServlet extends BaseServlet {
ExamService examService=new ExamService();
public String selectExam(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException, SQLException {
String selectString=examService.getSelect();
List<QuestionSelect> questionSelects=examService.selectExam(selectString);
String judgeString=examService.getJudge();
List<Judge> judges=examService.judgeExam(judgeString);
String clozeString=examService.getCloze();
List<Cloze> clozes=examService.clozeExam(clozeString);
String programString=examService.getProgram();
List<Program> programs=examService.programExam(programString);
request.setAttribute("selectList",questionSelects);
request.setAttribute("judgeList", judges);
request.setAttribute("clozeList", clozes);
request.setAttribute("programList", programs);
return "f:/examCenter.jsp";
}
public void count(HttpServletRequest request,
HttpServletResponse response) throws ServletException, IOException,
SQLException {
List<String> selects=new ArrayList<String>();
List<String> judges=new ArrayList<String>();
List<String> clozes=new ArrayList<String>();
for(int i=1;i<=10;i++){
String selectOption=request.getParameter("selectOption"+i);
if(selectOption==null){
selects.add("no answer");
}else{
selects.add(selectOption);
}
String judgeOption=request.getParameter("judgeOption"+i);
if(judgeOption==null){
judges.add("no answer");
}else{
judges.add(judgeOption);
}
String cloze=request.getParameter("cloze"+i);
if(cloze==null){
clozes.add("no answer");
}else{
clozes.add(cloze);
}
}
String programString=examService.getProgram();
List<Program> programs=examService.programExam(programString);
String question=programs.get(0).getQuestion();
String program="";
program=request.getParameter("program1");
if(program==null||program.trim().isEmpty()){
program="no answer";
}
//System.out.println(program);
HttpSession session=request.getSession();
Student student=(Student) session.getAttribute("sessionStudent");
if(student==null){
//response.sendRedirect("/online/loginStudent.jsp");
/*RequestDispatcher rd = request.getRequestDispatcher("/loginStudent.jsp");
rd.forward(request, response);*/
Json json=new Json();
String msg="ไฝ ่ฟๆฒกๆ็ปๅฝ๏ผ่ฏท้ๆฐ็ปๅฝ๏ผ๏ผ๏ผ";
json.setSuccess(false);
json.setMsg(msg);
response.getWriter().print(json);
response.getWriter().close();
}else{
String loginname=student.getLoginname();
examService.addProgramSubmit(loginname,question,program);
String selectString=examService.getSelect();
String judgeString=examService.getJudge();
String clozeString=examService.getCloze();
int selectCount=examService.selectCount(selects,selectString);
int judgeCount=examService.judgeCount(judges,judgeString);
int clozeCount=examService.clozeCount(clozes,clozeString);
int score=selectCount+judgeCount+clozeCount;
examService.addScore(loginname,score,selectCount,judgeCount,clozeCount);
double selectPercent=selectCount/10.0;
double judgePercent=judgeCount/10.0;
double clozePercent=clozeCount/8.0;
String msg="ไฝ ็ๅฎข่ง้ขๅๆฐๆฏ"+score+" "+"้ๆฉ้ขๆญฃ็กฎ็:"+selectPercent+" "+"ๅคๆญ้ขๆญฃ็กฎ็:"+judgePercent+" "
+"ๅกซ็ฉบ้ขๆญฃ็กฎ็:"+clozePercent+" "+"็จๅบ้ขๅๆฐๅพ
่ๅธๆฅ้
๏ผ๏ผ";
//System.out.println(msg);
Score scoreNew=examService.findStudent(loginname);
HttpSession sessionNew = request.getSession();
sessionNew.setAttribute("sessionScore",scoreNew);
Json json=new Json();
json.setSuccess(true);
json.setMsg(msg);
response.getWriter().print(json);
response.getWriter().close();
}
}
}
|
JavaScript | UTF-8 | 1,188 | 2.953125 | 3 | [] | no_license | import { ratingsTemplate } from "./templates";
const ratings = [
{ stars: 1, people: 20 },
{ stars: 2, people: 25 },
{ stars: 3, people: 66 },
{ stars: 4, people: 52 },
{ stars: 5, people: 93 }
];
let prevIdx;
function allPeople(arr) {
return arr.map(item => item.people).reduce((accumulator, currentValue) => accumulator + currentValue);
}
export function renderRatingsList() {
removeRatingList();
const idx = document.querySelectorAll('.rating__star-item--clicked').length;
if ((idx > 0) && (idx !== prevIdx)) {
if (prevIdx) ratings[prevIdx - 1].people = ratings[prevIdx - 1].people - 1;
prevIdx = idx;
ratings[idx - 1].people = ratings[idx - 1].people + 1;
document.querySelector('.rating').insertAdjacentHTML('beforeend', ratingsTemplate(ratings, allPeople(ratings)));
document.querySelector('.remove-btn').addEventListener('click', removeRatingList);
}
};
function removeRatingList() {
if (document.querySelector('.rating__list')) {
document.querySelector('.rating__list').remove();
document.querySelector('.remove-btn').removeEventListener('click', removeRatingList);
document.querySelector('.remove-btn').remove();
}
}; |
Python | UTF-8 | 75 | 3.734375 | 4 | [] | no_license | n=int(input("enter a number:"))
for i in range(2,n):
if n%i==0:
print(i) |
Python | UTF-8 | 2,786 | 3.03125 | 3 | [] | no_license | import numpy as np
class LMKNN:
def __init__(self, k):
self.__dataTrain = {}
self.__predict = {}
self.__k = k
@property
def dataTrain(self):
return self.__dataTrain
@property
def predict(self):
return self.__predict
@property
def k(self):
return self.__k
@dataTrain.setter
def dataTrain(self, input):
self.__dataTrain = input
@predict.setter
def predict(self, input):
self.__predict = input
@k.setter
def k(self, input):
self.__k = input
def euclidean(self, features, predict):
return np.linalg.norm(np.array(features)-np.array(predict))
def calc_distances_data(self, dataTrain, predict):
distancesDict = {}
for group in dataTrain:
distancesList = []
for index in range(len(dataTrain[group])):
features = dataTrain[group][index]
euclideanDistance = self.euclidean(features, predict)
distancesList.append([euclideanDistance, index])
distancesDict[group] = distancesList
return distancesDict
def calc_local_mean(self, distancesData, dataTrain, k):
local_mean = {}
for x in distancesData:
prev = 0
for y in sorted(distancesData[x])[:k]:
for label, features in dataTrain.items():
if x == label:
summation = np.add(np.array(features[y[1]]), prev)
prev = summation
result = np.true_divide(summation, k)
local_mean[x] = list(result)
summation = 0
return local_mean
def calc_closestDist_localMean(self, localMean, predict):
closestDist = []
for label in localMean:
localMeanVector = localMean[label]
euclideanDistance = self.euclidean(localMeanVector, predict)
closestDist.append((euclideanDistance, label))
minimum = np.argmin(closestDist, axis=0)
result = closestDist[minimum[0]][1]
return result
def local_mean_based_knn(self, dataTrain, predict, k):
distancesData = self.calc_distances_data(dataTrain, predict)
localMean = self.calc_local_mean(distancesData, dataTrain, k)
lmknn = self.calc_closestDist_localMean(localMean, predict)
return lmknn
def pred(self, trainSet, testSet, k):
correct = 0
total = 0
for label in testSet:
for testData in testSet[label]:
result = self.local_mean_based_knn(trainSet, testData, k)
if label == result:
correct += 1
total += 1
return float(correct / total) |
Python | UTF-8 | 219 | 2.625 | 3 | [] | no_license | n=int(input())
if n<1000:
print(1000-n)
else:
str1=""
k=n//1000
l=len(str(n))-len(str(k))
str1=str(k)+'0'*l
if str1==str(n):
print(0)
else:
p=int(str1)+1000
print(p-n) |
Java | UTF-8 | 667 | 2.15625 | 2 | [] | no_license | package com.psl.test;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.psl.business.StudentBo;
import com.psl.model.Student;
public class Client {
public static void main(String[] args) {
ConfigurableApplicationContext ap = new ClassPathXmlApplicationContext("com/psl/resources/test.xml");
StudentBo sbo = (StudentBo)ap.getBean("bo");
try {
int i = sbo.createStudent(new Student(101, "aaa", "aas@gmail.com", "knp"));
System.out.println(i);
ap.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
|
Java | UTF-8 | 1,787 | 2.875 | 3 | [] | no_license | package mc;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
public class ChanceCardSewagePlant extends ChanceCard {
GameMaster gameMaster;
GamePane gamePane;
Player currentPlayer;
JButton sewagePlantButton;
private boolean failed;
public ChanceCardSewagePlant(){
failed = false;
}
public void performCard(){
gameMaster = GameMaster.getInstance();
gamePane = GamePane.getInstance();
sewagePlantButton = new JButton("Build Sewage Plant");
sewagePlantButton.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent evt){
sewagePlantButtonPerformed();
}
});
gamePane.clearSelectedDistrict();
gamePane.setMessagePanelText("You drew the Sewage Plant Card! Select " +
"a District to build a Sewage Plant on!");
if(failed)gamePane.addMessagePanelText("District cannot have a Bonus on it!");
gamePane.addMessagePanelButton(sewagePlantButton);
}
protected void sewagePlantButtonPerformed() {
int selectedDistrictIndex = gamePane.getSelectedDistrict();
Board board = gameMaster.getBoard();
if(selectedDistrictIndex != -1){
Square selectedSquare = board.getSquare(selectedDistrictIndex);
District district;
if(selectedSquare.getType() == SQUARETYPE.DISTRICT){
district = (District)selectedSquare;
if(district.bonus == null){
gamePane.clearSelectedDistrict();
district.hazard = STRUCTURE.SEWAGEPLANT;
gamePane.setMessagePanelText(district.getName() +" now has a Sewage Plant!");
failed = false;
GameMaster.getInstance().setPerformed(true);
sewagePlantButton.setVisible(false);
gamePane.update();
}else{
failed = true;
performCard();
}}
}
else{
failed = true;
performCard();
}
}
}
|
JavaScript | UTF-8 | 1,700 | 2.515625 | 3 | [] | no_license | /** @jsx jsx */
import React, { useState } from 'react';
import { css, jsx } from '@emotion/core'
import ProjectsContent from './ProjectsContent';
import ProjectSlide from './ProjectSlide';
import Arrow from "./Arrow"
import Dots from './Dots'
/**
* @function Projects
*/
const Projects = props => {
const getWidth = () => window.innerWidth
console.log(getWidth())
const [state, setState] = useState({
activeIndex: 0,
translate: 0,
transition: 0.45
})
const { translate, transition, activeIndex } = state
const nextSlide = () => {
if (activeIndex === props.slides.length - 1) {
return setState({
...state,
translate: 0,
activeIndex: 0
})
}
setState({
...state,
activeIndex: activeIndex + 1,
translate: (activeIndex + 1) * getWidth()
})
}
const prevSlide = () => {
if (activeIndex === 0) {
return setState({
...state,
translate: (props.slides.length - 1) * getWidth(),
activeIndex: props.slides.length - 1
})
}
setState({
...state,
activeIndex: activeIndex - 1,
translate: (activeIndex - 1) * getWidth()
})
}
return (
<div css={SliderCSS}>
<ProjectsContent
translate={translate}
transition={transition}
width={getWidth() * props.slides.length}
>
{props.slides.map((slide, i) => (
<ProjectSlide key={slide + i} content={slide} />
))}
</ProjectsContent>
<Arrow direction="left" handleClick={prevSlide} />
<Arrow direction="right" handleClick={nextSlide} />
<Dots slides={props.slides} activeIndex={activeIndex} />
</div>
)
}
const SliderCSS = css`
position: relative;
height: 60vh;
width: 80vw;
margin: 0 auto;
overflow: hidden;
`
export default Projects |
Markdown | UTF-8 | 3,759 | 3.71875 | 4 | [] | no_license | #####1ใๅ่ฑๆฌๅท
่ฏญๆณ๏ผ
<any>{{่กจ่พพๅผ}}</any>
ไฝ็จ๏ผ
ๅฐ่กจ่พพๅผๆง่ก็็ปๆ ่พๅบๅฝ่ฐ็จๅ
็ด ็innerHTMLไธญ๏ผ่ฟๅฏไปฅๅฐๆฐๆฎ็ปๅฎๅฐ่งๅพ
#####2ใๆไปค-ๅพช็ฏๆไปค
ๅบๆฌ่ฏญๆณ1๏ผ
<any v-for="tmp in array"></any>
ๅบๆฌ่ฏญๆณ2๏ผ
<any :key='value.id' v-for="(value,index) in array"></any>
ไฝ็จ๏ผ
ๅจ้ๅarray่ฟไธช้ๅๆถ๏ผๅฐไธดๆถๅ้ไฟๅญๅจtmpไธญ๏ผๅๅปบๅคไธชanyๆ ็ญพ
v-show:ๆงๅถๅ
็ด ๆพ็คบ้่
v-if๏ผๆฐๅขๆๅ ้ค่็น
#####3ใๆไปค-้ๆฉๆไปค
่ฏญๆณ๏ผ
<any v-if="่กจ่พพๅผ"></any>
<any v-else-if="่กจ่พพๅผ"></any>
<any v-else="่กจ่พพๅผ"></any>
ไฝ็จ๏ผ
ๆ นๆฎ่กจ่พพๅผๆง่ก็ปๆ็็ๅ๏ผๆฅๅณๅฎๆฏๅฆ่ฆๅฐๅฝๅ็่ฟไธชๅ
็ด ๆ่ฝฝๅฐDOMๆ
#####4ใๆไปค-ไบไปถ็ปๅฎ
่ฏญๆณ๏ผ
<any v-on:click="handleEvent"></any>
<any @click="handleEvent(arg1,arg2)"></any>
ไฝ็จ๏ผ
็ปๆๅฎ็ๅ
็ด ๅฐhandleEvent็ๆนๆณ็ปๅฎ็ปๆๅฎclickไบไปถ
1.ไบไปถไฟฎ้ฅฐ็ฌฆ
.stop้ปๆญขๅๆณก
<a v-on:click.stop="handle">่ทณ่ฝฌ</a>
.prevent้ปๆญข้ป่ฎค่กไธบ
<a v-on:click.prevent="handle">่ทณ่ฝฌ</a>
@click.self:ๅชๅค็่ชๅทฑๆฌ่บซ็ไบไปถ๏ผไธๅค็ๅญฉๅญๅๆณกไธๆฅ่งฆๅ็ไบไปถ
@click.once:ๅช่งฆๅไธๆฌก
2.ๆ้ฎไฟฎ้ฅฐ็ฌฆ
.enterๅ่ฝฆ้ฎ
<input v-on:keyup.enter='submit'>
.deleteๅ ้ค้ฎ
<input v-on:keyup.delete='handle'>
@input="handleInput" ๆๆฌๆกๅ
ๅฎนๆนๅๆถ่งฆๅ
@change="handleInput" ๆๆฌๆกๆนๅๅนถๅคฑๅป็ฆ็นๆถ่งฆๅ
3.่กจๅๅไฟฎ้ฅฐ็ฌฆ
number:่ฝฌๅไธบๆฐๅผ
trim:ๅปๆๅผๅงๅ็ปๅฐพ็็ฉบๆ ผ
lazy:ๅฐinputไบไปถๅๆขไธบchangeไบไปถ
<input v-model.number="age" type="number">
#####5ใๆไปค-ๅฑๆง็ปๅฎ
ๅบๆฌ่ฏญๆณ๏ผ
<any v-bind:myProp="่กจ่พพๅผ"></any>
่กฅๅ
๏ผๆฏๆ็ฎๅ๏ผ
<any :myProp="่กจ่พพๅผ"></any>
ไฝ็จ๏ผ
ๅฐ่กจ่พพๅผๆง่ก็็ปๆ ็ปๅฎ ๅฐๅฝๅๅ
็ด ็myPropๅฑๆง
<img v-bind:src="'img/'+myImg" alt="">
ๅจๆๆ ทๅผ็ปๅฎ
<p :style="{backgroundColor:myBGColor}">ๅจๆๆ ทๅผ็ปๅฎ</p>
classๆ ทๅผๅจๆ็ปๅฎ
<div v-bind:class="{isActive? "red":"yellow"}"></div>
<h1 :class="{myRed:true,myBule:true}">ๅจๆๆ ทๅผ็ฑป็็ปๅฎ</h1>
<div v-bind:class="[active1,active2]"></div>
styleๆ ทๅผๅจๆ็ปๅฎ๏ผๅclassๅทฎไธๅค๏ผ
<div v-bind:style="{color:#fff}"></div>
<h1 :class="{myRed:false}">ๅจๆๆ ทๅผ็ฑป็็ปๅฎ</h1>
<div v-bind:style="[baseStyle1,style2]"></div>
็ปๅฎๅ้ๅๅค้๏ผ
<input type="checkbox" v-model="isChecked"/>
<input type="checkbox" v-model="checkgroup" value="้ฟ่ท"/>
<input type="checkbox" v-model="checkgroup" value="ๆธธๆณณ"/>
{{checkgroup}}
new Vue({
el:"#box"
data:{
isChecked:true,
checkgroup:[],
}
})
ๆๆฌ๏ผ
<input type="text" v-mode.lazy="mytext"/>
<input type="text" v-mode.number="mytext"/>
<input type="text" v-mode.trim="mytext"/>
v-mode.lazy:ๆๅๅ็ปๅฎ๏ผๅ่ฝฆไนๅๅ็ปๅฎ
v-mode.number:่พๅ
ฅๅ
ๅฎนไธบๆฐๅญ
v-mode.trim๏ผๅปๆ่พๅ
ฅๅญ็ฌฆไธค็ซฏ็ฉบๆ ผ
#####6.ๆฐๆฎ็ปๅฎๆไปค
v-textๅกซๅ
็บฏๆๆฌ(ๆฏๆๅผ่กจ่พพๅผ็ฎๆด)
v-htmlๅกซๅ
HTML็ๆฎต(ๅญๅจๅฎๅ
จ้ฎ้ข๏ผๆฌ็ฝ็ซๅ
้จๆฐๆฎๅฏไปฅไฝฟ็จ๏ผๆฅ่ช็ฌฌไธๆนๆฐๆฎไธๅฏไปฅ็จ)
v-preๅกซๅ
ๅๅงไฟกๆฏ
v-onceๆพ็คบ็ๅ
ๅฎนๅ็ปญไธๅไฟฎๆน
#####7ใๆไปค-ๅๅๆฐๆฎ็ปๅฎ
ๆนๅ1๏ผๆฐๆฎ็ปๅฎๅฐ่งๅพ
ๆนๅ2๏ผๅฐ่งๅพไธญ๏ผ่กจๅๅ
็ด ๏ผ็จๆทๆไฝ็็ปๆ็ปๅฎๅฐๆฐๆฎ
ๅบๆฌ่ฏญๆณ:
<่กจๅๅ
็ด v-model="ๅ้">
</่กจๅๅ
็ด > |
JavaScript | UTF-8 | 1,766 | 2.984375 | 3 | [] | no_license | const chai = require('chai');
const expect = chai.expect;
const Turn = require('../src/Turn')
const Card = require('../src/Card');
describe('Turn', function() {
it('should be a function', function() {
const turn = new Turn();
expect(Turn).to.be.a('function');
});
it('Turn should be instantiated with a Guess and a Card', function() {
const turn = new Turn();
expect(turn).to.be.an.instanceof(Turn);
});
it('should be a function with a guess and a Card', function() {
const turn = new Turn();
const card = new Card();
});
it('should return the players guess', function() {
const card = new Card(1, "What allows you to define a set of related information using key-value pairs?", ["object", "array", "function"], "object")
const turn = new Turn('array', card);
expect(turn.returnGuess()).to.equal('array');
});
it('should return the card', function() {
const card = new Card(1, "What allows you to define a set of related information using key-value pairs?", ["object", "array", "function"], "object")
const turn = new Turn('array', card);
expect(turn.returnCard()).to.equal(card);
});
it('should evaluate the guess', function() {
const card = new Card(1, "What allows you to define a set of related information using key-value pairs?", ["object", "array", "function"], "object")
const turn = new Turn('array', card);
expect(turn.evaluateGuess()).to.equal(false);
});
it('should give feedback', function() {
const card = new Card(1, "What allows you to define a set of related information using key-value pairs?", ["object", "array", "function"], "object")
const turn = new Turn('array', card);
expect(turn.giveFeedback()).to.equal('โ Incorrect')
});
});
|
Java | UTF-8 | 1,385 | 2.125 | 2 | [
"MIT"
] | permissive | package de.tudresden.inf.st.mquat.solving;
import de.tudresden.inf.st.mquat.generator.ScenarioDescription;
import de.tudresden.inf.st.mquat.generator.ScenarioGenerator;
import de.tudresden.inf.st.mquat.jastadd.model.Root;
import de.tudresden.inf.st.mquat.jastadd.model.Solution;
import de.tudresden.inf.st.mquat.solving.ilp.ILPExternalSolver;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.Assert;
import org.junit.BeforeClass;
import org.junit.Test;
public class ILPObjectiveTest {
private static Logger logger;
@BeforeClass
public static void initLogger() {
logger = LogManager.getLogger(ILPObjectiveTest.class);
}
@Test
public void test_config_01() throws SolvingException {
int tlc = 1;
int iac = 1;
int isd = 0;
int cac = 0;
int csd = 0;
int dep = 2;
int imp = 2;
int res = 10;
int req = 1;
int cpu = 1;
int seed = 0;
ScenarioGenerator generator = new ScenarioGenerator(new ScenarioDescription(tlc, iac, isd, cac, csd, dep, imp, res, req, cpu, seed));
Root model = generator.generate();
ILPExternalSolver solver = new ILPExternalSolver().setDeleteFilesOnExit(false);
Solution solution = solver.solve(model);
Assert.assertTrue(solution.isValid());
logger.info("Solution (objective={}): {}", solution.computeObjective(), solution);
}
}
|
PHP | UTF-8 | 724 | 2.765625 | 3 | [] | no_license | <?php
namespace App;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Foundation\Auth\User as Authenticatable;
class User extends Authenticatable
{
/**
* Atributos asignables en masa.
*/
protected $fillable = [
'name', 'email', 'password', 'type',
];
/**
* Atributos que deben ocultarse para las matrices.
*/
protected $hidden = [
'password', 'remember_token',
];
public static function checkEmail($email){
$userList = User::all();
$found = false;
foreach ($userList as $u):
if ($u->email == $email):
$found = true;
endif;
endforeach;
return $found;
}
}
|
C++ | UTF-8 | 1,259 | 2.625 | 3 | [] | no_license | #include <stdio.h>
#include <stdlib.h>
#include <limits.h>
int main() {
char mappings[26];
mappings[0] = 'y'; // a
mappings[1] = 'h'; // b
mappings[2] = 'e'; // c
mappings[3] = 's'; // d
mappings[4] = 'o';
mappings[5] = 'c';
mappings[6] = 'v';
mappings[7] = 'x';
mappings[8] = 'd';
mappings[9] = 'u';
mappings[10] = 'i';
mappings[11] = 'g';
mappings[12] = 'l';
mappings[13] = 'b';
mappings[14] = 'k';
mappings[15] = 'r';
mappings[16] = 'z';
mappings[17] = 't';
mappings[18] = 'n';
mappings[19] = 'w';
mappings[20] = 'j';
mappings[21] = 'p';
mappings[22] = 'f';
mappings[23] = 'm';
mappings[24] = 'a';
mappings[25] = 'q';
int dobreak = 0;
int N;
scanf("%d *[^\n]", &N);
int i;
for (i = 0; i < N; i++) {
char line[LINE_MAX];
// Check fgets succeeds
if (fgets(line, LINE_MAX, stdin) != NULL) {
printf("Case #%d: ", i+1);
int j;
for (j = 0; j < LINE_MAX; j++) {
if (line[j] == ' ') {
printf(" ");
}
else if (line[j] == '\n') {
break;
}
else {
int x = line[j];
x -= 97;
printf("%c", mappings[x]);
}
}
}
printf("\n");
}
return 0;
}
|
C++ | UTF-8 | 397 | 2.640625 | 3 | [] | no_license | #include <bits/stdc++.h>
struct Node{
char character;
int value;
struct Node* esq;
struct Node* dir;
};
struct binary_tree{
struct Node* first_node;
};
struct binary_tree* criarArvoreBinaria (){
struct binary_tree* bt = (binary_tree*)malloc(sizeof(binary_tree));
bt->first_node = NULL;
return bt;
}
void binaryTreeAddElement (char c, int v){
}
int main(){
}
|
Java | UTF-8 | 812 | 2.859375 | 3 | [
"Apache-2.0"
] | permissive | package dea.monitor.tools;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexTester {
public static void main(String[] args) {
String[] response = {
"Station reported <span id=\"update_time\">11 seconds ago</span></span></h2>",
"Station reported <span id=\"update_time\">1 minute ago</span></span></h2>",
"Station reported <span id=\"update_time\">2 minutes ago</span></span></h2>" };
Pattern pattern = null;
String regexString = "seconds ago</span></span>|>[1-9] minute[s]{0,1} ago</span></span>";
if (regexString != null) {
pattern = Pattern.compile(regexString);
}
for (int i = 0; i < response.length; i++) {
Matcher matcher = pattern.matcher(response[i]);
System.out.println("found:" + matcher.find());
}
}
}
|
Swift | UTF-8 | 2,012 | 2.59375 | 3 | [
"MIT"
] | permissive | //
// STPPaymentResult.swift
// StripeiOS
//
// Created by Jack Flintermann on 1/15/16.
// Copyright ยฉ 2016 Stripe, Inc. All rights reserved.
//
import Foundation
/// When you're using `STPPaymentContext` to request your user's payment details, this is the object that will be returned to your application when they've successfully made a payment.
/// See https://stripe.com/docs/mobile/ios/basic#submit-payment-intents
public class STPPaymentResult: NSObject {
/// The payment method that the user has selected. This may come from a variety of different payment methods, such as an Apple Pay payment or a stored credit card. - seealso: STPPaymentMethod.h
/// If paymentMethod is nil, paymentMethodParams will be populated instead.
@objc public private(set) var paymentMethod: STPPaymentMethod?
/// The parameters for a payment method that the user has selected. This is
/// populated for non-reusable payment methods, such as FPX and iDEAL. - seealso: STPPaymentMethodParams.h
/// If paymentMethodParams is nil, paymentMethod will be populated instead.
@objc public private(set) var paymentMethodParams: STPPaymentMethodParams?
/// The STPPaymentOption that was used to initialize this STPPaymentResult, either an STPPaymentMethod or an STPPaymentMethodParams.
@objc public weak var paymentOption: STPPaymentOption? {
if paymentMethod != nil {
return paymentMethod
} else {
return paymentMethodParams
}
}
/// Initializes the payment result with a given payment option. This is invoked by `STPPaymentContext` internally; you shouldn't have to call it directly.
@objc
public init(
paymentOption: STPPaymentOption?
) {
super.init()
if paymentOption is STPPaymentMethod {
paymentMethod = paymentOption as? STPPaymentMethod
} else if paymentOption is STPPaymentMethodParams {
paymentMethodParams = paymentOption as? STPPaymentMethodParams
}
}
}
|
Java | UTF-8 | 4,859 | 1.882813 | 2 | [] | no_license | /*
* Copyright(C) 2011-2012 Alibaba Group Holding Limited
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* Authors:
* wentong <wentong@taobao.com>
*/
package com.taobao.tdhs.client.request;
import com.taobao.tdhs.client.common.TDHSCommon;
import com.taobao.tdhs.client.exception.TDHSEncodeException;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* @author <a href="mailto:wentong@taobao.com">ๆ้</a>
* @since 11-11-1 ไธๅ4:10
*/
public class Get extends RequestWithCharset implements Request {
private TableInfo tableInfo;
private List<String[]> _key = new ArrayList<String[]>();
private int ____find_flag = TDHSCommon.FindFlag.TDHS_EQ.getValue();
private int _start;
private int _limit;
private Filters filters = new Filters();
public Get(TableInfo tableInfo, String keys[][], TDHSCommon.FindFlag findFlag,
int start,
int limit) {
this.tableInfo = tableInfo;
if (keys != null) {
Collections.addAll(this._key, keys);
}
this.____find_flag = findFlag.getValue();
this._start = start;
this._limit = limit;
}
public Get(TableInfo tableInfo, String keys[][], TDHSCommon.FindFlag findFlag,
int start,
int limit, @Nullable Filter filters[]) {
this(tableInfo, keys, findFlag, start, limit);
if (filters != null && filters.length > 0) {
for (Filter f : filters) {
this.addFilter(f);
}
}
}
public Get(TableInfo tableInfo) {
this.tableInfo = tableInfo;
}
public TableInfo getTableInfo() {
return tableInfo;
}
public void setTableInfo(TableInfo tableInfo) {
this.tableInfo = tableInfo;
}
public List<String[]> getKey() {
return _key;
}
public void setKey(String[] key) {
_key.clear();
_key.add(key);
}
public void setKey(String[][] keys) {
_key.clear();
if (keys != null) {
Collections.addAll(this._key, keys);
}
}
public void setKey(List<String>[] keys) {
_key.clear();
for (List<String> k : keys) {
_key.add(k.toArray(new String[k.size()]));
}
}
public int getFindFlag() {
return ____find_flag;
}
public void setFindFlag(TDHSCommon.FindFlag findFlag) {
this.____find_flag = findFlag.getValue();
}
public int getStart() {
return _start;
}
public void setStart(int start) {
this._start = start;
}
public int getLimit() {
return _limit;
}
public void setLimit(int limit) {
this._limit = limit;
}
public void addFilter(Filter filter) {
filters.addFilter(filter);
}
public void addFilter(String field, TDHSCommon.FilterFlag flag, String value) {
filters.addFilter(field, flag, value);
}
public void isValid(TDHSCommon.ProtocolVersion version) throws TDHSEncodeException {
if (tableInfo == null) {
throw new TDHSEncodeException("tableInfo can't be empty!");
}
tableInfo.isValid(version);
if (_key == null || _key.size() == 0) {
throw new TDHSEncodeException("key can't be missing!");
}
if (version.equals(TDHSCommon.ProtocolVersion.V1)) {
if (_key.size() > TDHSCommon.REQUEST_MAX_KEY_NUM) {
throw new TDHSEncodeException("too many keys(in) ,larger than 10!");
}
}
for (String[] k : _key) {
if (k == null || k.length == 0) {
throw new TDHSEncodeException("key can't be empty!");
}
if (k.length > TDHSCommon.REQUEST_MAX_KEY_NUM) {
throw new TDHSEncodeException("too many keys ,larger than 10!");
}
}
if (filters != null) {
filters.isValid(version);
}
if (____find_flag == TDHSCommon.FindFlag.TDHS_BETWEEN.getValue() && _key.size() < 2) {
throw new TDHSEncodeException("between need at least 2 keys");
}
}
@Override
public String toString() {
return "Get{" +
"tableInfo=" + tableInfo +
",key=" + _key +
", find_flag=" + ____find_flag +
", start=" + _start +
", limit=" + _limit +
", filters=" + filters +
'}';
}
}
|
Java | UTF-8 | 856 | 2.296875 | 2 | [] | no_license | package com.shana.elasticsearch;
public class Command {
private String index;
private String type;
private String queryString;
private Method method;
private Object httpBody;
public enum Method{
POST,DELETE,GET,PUT,PATCH
}
public String getIndex() {
return index;
}
public void setIndex(String index) {
this.index = index;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getQueryString() {
return queryString;
}
public void setQueryString(String queryString) {
this.queryString = queryString;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}
public Object getHttpBody() {
return httpBody;
}
public void setHttpBody(Object httpBody) {
this.httpBody = httpBody;
}
}
|
Shell | UTF-8 | 174 | 2.765625 | 3 | [
"WTFPL"
] | permissive | #!/bin/bash
#
# grm - short command to search through Minimy python files
#
cd $HOME/minimy
grep -n "$@" *py */*py */*/*py */*/*/*py 2>/dev/null | sed "s:^:$HOME/minimy/:g"
|
Python | UTF-8 | 101,809 | 3.75 | 4 | [] | no_license | """ Cities. version 1.2 with graphs. Life simulation. """
from re import split as slt # for parsing values while creating a new city
# random is everywhere
from random import weibullvariate as wb, gammavariate as gm, randrange as rdr, \
random as rdm, choice as chc
from json import load, dump # loading and saving data for running a script
from time import time as tm # how long does it take to make 1 year
from math import sqrt # counting root of something
from prettytable import PrettyTable # printing information by using tables
class World:
""" This is a place, where everything exists. The __str__ representation is
a general information about each city. The __len__ representation is a number
of alive people in each city, which exist in this world
(Environment.__len__() must exist).
1 World() -> few Environment() -> more ResourceFacility()
and more House() -> a lot of Human() """
world = [] # [Environment(), ...]
year = 0 # world time
data = {"years": 0, "seconds per year": []} # general data for building graphs
def __init__(self, name):
self.name = name # str : name of an object of the class World
def __len__(self):
""" for 1 000 000 iterations :::
sum of an lengths array >>> ~ 3.4 - 3.5 s
looping >>> ~ 3.85 - 3.9 s
functools.reduce() >>> ~ 4.9 - 5 s """
return sum([len(city) for city in self.world])
def __str__(self):
return "-" * 22 + f" Object: '{self.name}' (class " \
f"'{self.__class__.__name__}'), Residents: {len(self)}. " \
f"Year: {self.year} " + "-" * 22
def cities_creator(self, number):
print("\nDefault settings for city creation:\nname=input(), people=250, "
"water~1500, food~1500, wood~1000, ore=0, metal=0, stone=0\nYou can "
"print a name with any register.\n\nIf you want to create a city with "
"a default settings, just print: \nname=input()\n\nFor creating a city "
"with a unique settings, print:\nparameter (people, food, wood, etc.) "
"and value.\nFor example: name=input(), people=100, metal=1000, ore=500")
iteration = 0
while iteration != number:
name, people, water, food = None, 250, None, None
wood, ore, metal, stone = None, None, None, None
city_data = input(f"City : {iteration + 1} / {number}\nData : ")
reorganized_data = [data for data in slt(r"[=|, |~]", city_data) if data]
if len(reorganized_data) % 2 != 0:
print(f"{reorganized_data}\nProbably, you made a mistake. "
f"Please, try again.")
else:
for index in range(0, len(reorganized_data), 2):
parameter = reorganized_data[index].lower()
value = reorganized_data[index + 1]
if parameter == "name":
name = self.city_name_parser(name=value, message="Name")
elif parameter == "people":
people = integer_checker(value=value, message="People")
elif parameter == "water":
water = integer_checker(value=value, message="Water")
elif parameter == "food":
food = integer_checker(value=value, message="Food")
elif parameter == "wood":
wood = integer_checker(value=value, message="Wood")
elif parameter == "ore":
ore = integer_checker(value=value, message="Ore")
elif parameter == "metal":
metal = integer_checker(value=value, message="Metal")
elif parameter == "stone":
stone = integer_checker(value=value, message="Stone")
city = Environment(name, water, food, wood, ore, metal, stone)
for _ in range(people + 1):
city.adults.append(
Human(age=int(wb(25, 50)), wish_attr=round(wb(2.5, 7.5), 2)))
self.world.append(city)
iteration += 1
def city_name_parser(self, name=None, message=None):
name = name or input()
while True:
if name == "":
if message:
print(f"{message} >>> you can't pass a space blanked name. "
"Please, try again.")
else:
print("You can't pass a space blanked name. Please, try again.")
elif name.title() in [city.name for city in self.world]:
if message:
print(f"{message} >>> this city is already exist. "
"Please, try again.")
else:
print("This city is already exist. Please, try again.")
else:
return name.title()
name = input("name=")
def year_maker(self):
for city in self.world:
h_c, p_s, c_s = city.first_block_functions()
# a first block of functions counting all resources and make dictionaries
# for other blocks ::: h_c = human costs, p_s = products, c_s = costs.
f_l = city.second_block_functions(p_s, c_s)
# a second block of functions, using the city.requests dictionary,
# checking if a request is true, than appending it to the city.queue.
# returning f_l = maximum forge level of the city for other blocks.
city.third_block_functions(h_c, p_s, c_s, f_l)
# a third block of functions takes all requests from city.queue and
# placing them into two different arrays => city.alert or city.non_urgent.
# After it, it makes a plan (city.plan) of deeds people should do.
city.fourth_block_functions(f_l)
# a fourth block of functions making all requests from city.plan and
# try to make all of it. After, finishing the hole building cycle.
city.fifth_block_functions()
# a fifth block of functions managing all people changes.
class Environment:
""" Environment, basically, is a city or a village, depends on the environment
population. All cities have a unique name. The __str__ representation is
a general information about quantity of people overall, kids, adults, elders,
dead people, information about each resource and building with its level.
(ResourceFacility.__str__() must exist). The __len__ representation is a number
of alive people in the environment ([kids], [adults] and [elders] must exist).
All adults can make a new family and append themselves into the
family dictionary with a unique family index.
Each city has resources. People can use resources for building or
upgrading facilities, eating, drinking and etc.
{requests} dictionary used for sending codes for the life management. """
requests = {
"water is out": 1, "food is out": 2, "wood is out": 3, "ore is out": 4,
"water is out next year": 11, "water trend is strong": 13,
"water is up too slow": 14, "water is too much": 15,
"food is out next year": 21, "food trend is strong": 23,
"food is up too slow": 24, "food is too much": 25,
"wood is out next year": 31, "wood trend is strong": 33,
"wood is up too slow": 34, "wood is too much": 35,
"ore is out next year": 41, "ore trend is strong": 43,
"ore is up too slow": 44, "ore is too much": 45,
"metal is out next year": 51, "metal trend is strong": 53,
"metal is up too slow": 54, "metal is too much": 55,
"stone is out next year": 61, "stone trend is strong": 63,
"stone is up too slow": 64, "stone is too much": 65,
"build the family house": 91, "upgrade the family house": 92,
"build a house for a human": 93, "no well": 111, "no farm": 121,
"no hunting house": 122, "no port": 123, "no sawmill": 131, "no mine": 141,
"no forge": 151, "no quarry": 161, "build well": 211, "upgrade well": 212,
"build farm": 221, "upgrade farm": 222, "build hunting house": 223,
"upgrade hunting house": 224, "build port": 225, "upgrade port": 226,
"build sawmill": 231, "upgrade sawmill": 232, "build mine": 241,
"upgrade mine": 242, "build forge": 251, "upgrade forge": 252,
"build quarry": 261, "upgrade quarry": 262, "water need forge": 311,
"food need forge": 321, "wood need forge": 331, "ore need forge": 341,
"stone need forge": 361, "stop farm": 421, "stop forge": 451
}
def __init__(self, name, water, food, wood, ore, metal, stone):
self.name = name # str : name of an object of the class Environment
# attributes for people ::: class - Human()
self.kids, self.adults, self.elders = [], [], [] # alive people are here
self.family_index = 1 # int : a unique family number-key in {families}
self.families = {} # {family_index: {"house": house_index,
# "parents": [], "children": []}}
self.grave = [] # dead people are here
# attributes for resources
self.water = water or gm(1500, 1) # user input or ~ 1500 units
self.food = food or gm(1500, 1) # user input or ~ 1500 units
self.wood = wood or gm(1000, 1) # user input or ~ 1000 units
self.ore = ore or 0 # user input or 0
self.metal = metal or 0 # user input or 0
self.stone = stone or 0 # user input or 0
self.resources = {"water": self.water, "food": self.food, "wood": self.wood,
"ore": self.ore, "metal": self.metal, "stone": self.stone}
# attributes for buildings and houses
self.building_index = 1 # int : a unique building number-key in {buildings}
self.buildings = {} # {building_index: ResourceFacility()}
self.house_index = 1 # int : a unique house number-key in {houses}
self.houses = {} # {house_index: House()}
self.brigades = [] # people, that build any facility in a current year
# resource_trend, requests and management
self.queue = [] # an array of requests for making alert and non_urgent
self.alert = [] # an array of the most important problems to solve
self.non_urgent = [] # an array of problems that are non-urgent
self.plan = [] # step by step maker
# general data for building graphs
self.data = {
"kids": [], "adults": [], "elders": [], "people in the city": [],
"families": [], "grave": [], "average life": None, "water": [],
"food": [], "wood": [], "ore": [], "metal": [], "stone": [],
"buildings": [], "houses": []}
def __len__(self):
return len(self.kids) + len(self.adults) + len(self.elders)
def __str__(self):
return f"{self.name} of the class '{self.__class__.__name__}' with " \
f"{len(self)} alive people:\n[People -> families = " \
f"{len(self.families)}; kids = {len(self.kids)}; adults = " \
f"{len(self.adults)}; elders = {len(self.elders)}; grave = " \
f"{len(self.grave)}]\n[Resources -> water = {round(self.water, 2)}" \
f"; food = {round(self.food, 2)}; wood = {round(self.wood, 2)}; " \
f"ore = {round(self.ore, 2)}; metal = {round(self.metal, 2)}" \
f"; stone = {round(self.stone, 2)}]\n[Buildings -> houses = " \
f"{len(self.houses)}, facilities = {len(self.buildings)}]\n" + \
"\n".join(f"{hs}" for hs in self.houses.values()) + "\n\n" + \
"\n".join(f"{bg}" for bg in self.buildings.values()) + "\n"
def first_block_functions(self):
self.queue = []
self.alert, self.non_urgent = [], []
self.plan = []
h_c = self.costs_of_human_life_counter()
p_s, c_s, result, account_flag = self.production_counter()
if account_flag:
self.finishing_first_block(result)
return h_c, p_s, c_s
else:
self.accounting_function(p_s, c_s, result)
self.finishing_first_block(result)
return h_c, p_s, c_s
def costs_of_human_life_counter(self):
h_costs = {"water": len(self), "food": len(self), "wood": 0}
for array in (self.kids, self.adults, self.elders):
for human in array:
if not human.house_index:
h_costs["wood"] += 1
for house in self.houses.values():
h_costs["wood"] += house.info[house.level]["cost: wood"]
for res, value in h_costs.items():
self.resources[res] -= value
return h_costs
def production_counter(self):
p_s = {"water": 0, "food": 0, "wood": 0, "ore": 0, "metal": 0, "stone": 0}
c_s = {"water": 0, "food": 0, "wood": 0, "ore": 0}
for building in self.buildings.values():
building.assets_and_liabilities_counter(p_s, c_s)
building.more_experience_workers()
result = {"water": 0, "food": 0, "wood": 0, "ore": 0, "metal": 0, "stone": 0}
for res in result:
result[res] = self.resources[res] + p_s[res] - c_s.get(res, 0)
if all(x >= 0 for x in result.values()):
return p_s, c_s, result, True
return p_s, c_s, result, False
def finishing_first_block(self, result):
for res, value in result.items():
self.resources[res] = value
self.water, self.food = self.resources["water"], self.resources["food"]
self.wood, self.ore = self.resources["wood"], self.resources["ore"]
self.metal, self.stone = self.resources["metal"], self.resources["stone"]
def accounting_function(self, p_s, c_s, result):
if result["water"] < 0:
self.queue.append(self.requests["water is out"])
result["water"] = 0
if result["food"] < 0:
self.queue.append(self.requests["food is out"])
result["food"] = 0
if result["wood"] < 0:
self.queue.append(self.requests["wood is out"])
result["wood"] = 0
if result["ore"] < 0:
self.queue.append(self.requests["ore is out"])
coefficient = c_s["ore"] / p_s["metal"]
while result["ore"] < 0:
p_s["metal"] -= 1
c_s["ore"] -= coefficient
result["metal"] -= 1
result["ore"] += coefficient
def second_block_functions(self, p_s, c_s):
self.slow_growing_up_resource_requests_parser(p_s)
self.most_of_resource_requests_parser(p_s, c_s)
self.people_requests_parser()
self.people_making_brigades_for_building_new_facilities()
f_l = self.forge_level_parser()
return f_l
def slow_growing_up_resource_requests_parser(self, p_s):
income = 0
for product in p_s.values():
income += product
if income != 0:
for res, value in p_s.items():
if value / income <= 0.05:
self.queue.append(self.requests[f"{res} is up too slow"])
elif value / income >= 0.5:
self.queue.append(self.requests[f"{res} is too much"])
def most_of_resource_requests_parser(self, p_s, c_s):
for res, value in self.resources.items():
if self.resources[res] + p_s[res] - c_s.get(res, 0) < 0:
self.queue.append(self.requests[f"{res} is out next year"])
else:
trend = self.resources[res] + 10 * (p_s[res] - c_s.get(res, 0))
if trend <= 0 or self.resources[res] > 10 * trend:
self.queue.append(self.requests[f"{res} trend is strong"])
for bld, class_ in {"well": Well, "farm": Farm, "hunting house": HuntingHouse,
"port": Port, "sawmill": Sawmill, "mine": Mine,
"quarry": Quarry, "forge": Forge}.items():
if class_ not in [type(clb) for clb in self.buildings.values()]:
self.queue.append(self.requests[f"no {bld}"])
def people_requests_parser(self):
for family in self.families.values():
if not family["house"]:
self.queue.append(self.requests["build the family house"])
else:
house = self.houses[family["house"]]
if len(house.tenants) >= House.info[house.level]["max p_l"]:
self.queue.append(self.requests["upgrade the family house"])
for array in (self.adults, self.elders):
for human in array:
if not human.house_index and not human.family_index:
self.queue.append(self.requests["build a house for a human"])
def people_making_brigades_for_building_new_facilities(self):
for array in (self.kids, self.adults, self.elders):
for human in array:
if 14 <= human.age <= 70 and not human.builder_status:
self.brigades.append(human)
human.builder_status = True
def forge_level_parser(self):
forge_level = 0
for building in self.buildings.values():
if "Forge" in building.name and forge_level < building.level:
forge_level = building.level
return forge_level
def third_block_functions(self, h_c, p_s, c_s, f_l):
ch_s = {"water": 0, "food": 0, "wood": 0, "ore": 0, "metal": 0, "stone": 0}
copy = {k: v for k, v in self.resources.items()}
self.alert_or_non_urgent_parser()
self.result_of_the_year_for_people()
self.the_most_important_alerts_parser(h_c, p_s, c_s, f_l, ch_s, copy)
self.all_other_alerts_parser(f_l, ch_s, copy)
self.all_non_urgent_parser(h_c, p_s, c_s, f_l, ch_s, copy)
def alert_or_non_urgent_parser(self):
for request in (1, 2, 3, 4, 11, 21, 31, 41):
if request in self.queue:
self.alert.append(request)
self.request_humans_houses_parser(self.alert, 5)
for request in (111, 121, 122, 123, 131, 141, 151, 161):
if request in self.queue:
self.alert.append(request)
for request in (14, 24, 34, 44, 54, 64):
if request in self.queue:
self.non_urgent.append(request)
self.request_humans_houses_parser(self.non_urgent, 3)
for request in (13, 23, 33, 43, 53, 63):
if request in self.queue:
self.non_urgent.append(request)
def request_humans_houses_parser(self, sending, number):
if len(self.families) > 0:
if self.requests["wood is too much"] in self.queue:
for _ in range(self.queue.count(91)):
sending.append(self.requests["build the family house"])
for _ in range(self.queue.count(92)):
sending.append(self.requests["upgrade the family house"])
else:
for _ in range(self.queue.count(91) // number):
sending.append(self.requests["build the family house"])
for _ in range(self.queue.count(92) // number):
sending.append(self.requests["upgrade the family house"])
if self.requests["wood is too much"] in self.queue:
for _ in range(self.queue.count(93)):
sending.append(self.requests["build a house for a human"])
else:
add = 1
if self.queue.count(91) >= 15:
add = 5
for _ in range(self.queue.count(93) // (number * add)):
sending.append(self.requests["build a house for a human"])
def result_of_the_year_for_people(self):
if 1 not in self.queue and 2 not in self.queue and 3 not in self.queue:
for array in (self.kids, self.adults, self.elders):
for human in array:
human.death = 0.75
for elem in (1, 2, 3):
if elem in self.queue:
for array in (self.kids, self.adults, self.elders):
for human in array:
human.death -= 0.000025
def the_most_important_alerts_parser(self, h_c, p_s, c_s, f_l, ch_s, copy):
""" 1, 2, 3, 4, 11, 21, 31, 41 """
self.sawmill_builder_template(ch_s, copy)
self.well_builder_template(ch_s, copy)
self.farm_builder_template(ch_s, copy)
self.hunting_house_builder_template(ch_s, copy)
self.port_builder_template(ch_s, copy)
if self.requests["water is out"] in self.alert:
self.plan.append(self.requests["stop farm"])
self.water_template(h_c, p_s, c_s, f_l, ch_s, copy, 50)
if self.requests["food is out"] in self.alert:
self.food_template(h_c, p_s, c_s, f_l, ch_s, copy, 50)
if self.requests["wood is out"] in self.alert:
self.wood_template(h_c, p_s, c_s, f_l, ch_s, copy, 50)
if self.requests["ore is out"] in self.alert:
self.plan.append(self.requests["stop forge"])
self.ore_template(h_c, p_s, c_s, f_l, ch_s, copy, 25)
if self.requests["water is out next year"] in self.alert:
self.plan.append(self.requests["stop farm"])
self.water_template(h_c, p_s, c_s, f_l, ch_s, copy, 25)
if self.requests["food is out next year"] in self.alert:
self.food_template(h_c, p_s, c_s, f_l, ch_s, copy, 25)
if self.requests["wood is out next year"] in self.alert:
self.wood_template(h_c, p_s, c_s, f_l, ch_s, copy, 25)
if self.requests["ore is out next year"] in self.alert:
self.plan.append(self.requests["stop forge"])
self.ore_template(h_c, p_s, c_s, f_l, ch_s, copy, 25)
self.people_are_soo_people()
def sawmill_builder_template(self, ch_s, copy):
if self.requests["no sawmill"] in self.alert:
self.building_planer("build sawmill", ch_s, "wood", Sawmill, copy,
else_status=True)
def building_planer(self, request, ch_s, res, obj, copy, else_status=False):
if copy["wood"] - obj.info[1]["build"]["wood"] >= 0:
copy["wood"] -= obj.info[1]["build"]["wood"]
ch_s[res] += (obj.info[1]["max w_s"] * obj.info[1]["jun"])
self.plan.append(self.requests[request])
elif else_status and copy["wood"] < 0:
copy["wood"] = 0
ch_s[res] += (obj.info[1]["max w_s"] * obj.info[1]["jun"])
self.plan.append(self.requests[request])
def well_builder_template(self, ch_s, copy):
if self.requests["no well"] in self.alert:
self.building_planer("build well", ch_s, "water", Well, copy,
else_status=True)
def farm_builder_template(self, ch_s, copy):
if self.requests["no farm"] in self.alert:
self.building_planer("build farm", ch_s, "food", Farm, copy,
else_status=True)
def hunting_house_builder_template(self, ch_s, copy):
if self.requests["no hunting house"] in self.alert:
self.building_planer("build hunting house", ch_s, "food",
HuntingHouse, copy, else_status=True)
def port_builder_template(self, ch_s, copy):
if self.requests["no port"] in self.alert:
self.building_planer("build port", ch_s, "food", Port, copy,
else_status=True)
def water_template(self, h_c, p_s, c_s, f_l, ch_s, copy, plus):
for index in self.an_array_of_indexes_for_upgrade(Well):
well = self.buildings[index]
if well.level != 15:
if self.upgrading_planer(well, f_l, ch_s, "upgrade well", copy, "water"):
if self.resource_checker(h_c, p_s, c_s, "water", ch_s, plus):
break
else:
if well.info[well.level + 1]["build"]["Forge"] > f_l:
self.plan.append(self.requests["water need forge"])
else:
if not self.resource_checker(h_c, p_s, c_s, "water", ch_s, plus):
if copy["wood"] >= Well.info[1]["build"]["wood"]:
self.building_planer("build well", ch_s, "water", Well, copy)
self.random_behaviour(10, "build well", "build well", "upgrade well",
"upgrade well", "upgrade well", "build sawmill",
"upgrade sawmill")
self.resource_navigation_template("water")
def an_array_of_indexes_for_upgrade(self, obj):
indexes = [i for i, b in self.buildings.items() if b is type(obj)]
return indexes[::-1]
def upgrading_planer(self, obj, forge_level, ch_s, request, copy, resource):
upgrade_flag = True
for res, value in obj.info[obj.level + 1]["build"].items():
if res == "Forge" and forge_level < value:
upgrade_flag = False
elif copy[res] - value < 0:
upgrade_flag = False
if upgrade_flag:
for res, value in obj.info[obj.level + 1]["build"].items():
if res != "Forge":
copy[res] -= value
ch_s[resource] -= \
(obj.info[obj.level]["max w_s"] * obj.info[obj.level]["jun"])
ch_s[resource] += \
(obj.info[obj.level + 1]["max w_s"] * obj.info[obj.level + 1]["jun"])
self.plan.append(self.requests[request])
return True
return False
@staticmethod
def resource_checker(h_c, p_s, c_s, res, ch_s, limit):
if (p_s[res] - c_s.get(res, 0) - h_c.get(res, 0) + ch_s[res]) >= limit:
return True
return False
def random_behaviour(self, limit, *args):
for _ in range(rdr(0, limit + 1)):
if rdm() >= 0.6:
self.plan.append(self.requests[chc([*args])])
def resource_navigation_template(self, res):
if self.requests[f"{res} is out next year"] in self.alert:
self.alert.remove(self.requests[f"{res} is out next year"])
for request in (f"{res} trend is strong", f"{res} is up too slow"):
if self.requests[request] in self.non_urgent:
self.non_urgent.remove(self.requests[request])
def food_template(self, h_c, p_s, c_s, f_l, ch_s, copy, plus):
if self.farm_parser_template(ch_s, copy, h_c, p_s, c_s, f_l, plus):
if self.hunting_house_parser_template(ch_s, copy, h_c, p_s, c_s, f_l, plus):
self.port_parser_template(ch_s, copy, h_c, p_s, c_s, f_l, plus)
self.random_behaviour(20, "build farm", "build hunting house", "build port",
"upgrade farm", "upgrade hunting house", "upgrade port",
"upgrade hunting house", "upgrade port", "build sawmill",
"upgrade sawmill")
self.resource_navigation_template("food")
def farm_parser_template(self, ch_s, copy, h_c, p_s, c_s, f_l, plus):
if self.requests["stop farm"] in self.plan:
return True
for index in self.an_array_of_indexes_for_upgrade(Farm):
farm = self.buildings[index]
if farm.level != 15:
if self.upgrading_planer(farm, f_l, ch_s, "upgrade farm", copy, "food"):
if self.resource_checker(h_c, p_s, c_s, "food", ch_s, plus):
return False
else:
if farm.info[farm.level + 1]["build"]["Forge"] > f_l:
self.plan.append(self.requests["food need forge"])
else:
if not self.resource_checker(h_c, p_s, c_s, "food", ch_s, plus):
if copy["wood"] >= Farm.info[1]["build"]["wood"]:
self.building_planer("build farm", ch_s, "food", Farm, copy)
if self.resource_checker(h_c, p_s, c_s, "food", ch_s, plus):
return False
return True
def hunting_house_parser_template(self, ch_s, copy, h_c, p_s, c_s, f_l, plus):
for index in self.an_array_of_indexes_for_upgrade(HuntingHouse):
hunt = self.buildings[index]
if hunt.level != 10:
if self.upgrading_planer(hunt, f_l, ch_s, "upgrade hunting house",
copy, "food"):
if self.resource_checker(h_c, p_s, c_s, "food", ch_s, plus):
return False
else:
if hunt.info[hunt.level + 1]["build"]["Forge"] > f_l:
self.plan.append(self.requests["food need forge"])
else:
if not self.resource_checker(h_c, p_s, c_s, "food", ch_s, plus):
if copy["wood"] >= HuntingHouse.info[1]["build"]["wood"]:
self.building_planer("build hunting house", ch_s,
"food", HuntingHouse, copy)
if self.resource_checker(h_c, p_s, c_s, "food", ch_s, plus):
return False
return True
def port_parser_template(self, ch_s, copy, h_c, p_s, c_s, f_l, plus):
for index in self.an_array_of_indexes_for_upgrade(Port):
port = self.buildings[index]
if port.level != 12:
if self.upgrading_planer(port, f_l, ch_s, "upgrade port", copy, "food"):
if self.resource_checker(h_c, p_s, c_s, "food", ch_s, plus):
break
else:
if port.info[port.level + 1]["build"]["Forge"] > f_l:
self.plan.append(self.requests["food need forge"])
else:
if not self.resource_checker(h_c, p_s, c_s, "food", ch_s, plus):
if copy["wood"] >= Port.info[1]["build"]["wood"]:
self.building_planer("build port", ch_s, "food", Port, copy)
def wood_template(self, h_c, p_s, c_s, f_l, ch_s, copy, plus):
for index in self.an_array_of_indexes_for_upgrade(Sawmill):
sawmill = self.buildings[index]
if sawmill.level != 15:
if self.upgrading_planer(sawmill, f_l, ch_s, "upgrade sawmill",
copy, "wood"):
if self.resource_checker(h_c, p_s, c_s, "wood", ch_s, plus):
break
else:
if sawmill.info[sawmill.level + 1]["build"]["Forge"] > f_l:
self.plan.append(self.requests["wood need forge"])
else:
if not self.resource_checker(h_c, p_s, c_s, "wood", ch_s, plus):
if copy["wood"] >= Sawmill.info[1]["build"]["wood"]:
self.building_planer("build sawmill", ch_s, "wood", Sawmill, copy)
self.random_behaviour(10, "build sawmill", "upgrade sawmill", "upgrade sawmill")
self.resource_navigation_template("wood")
def ore_template(self, h_c, p_s, c_s, f_l, ch_s, copy, plus):
for index in self.an_array_of_indexes_for_upgrade(Mine):
mine = self.buildings[index]
if mine.level != 10:
if self.upgrading_planer(mine, f_l, ch_s, "upgrade mine", copy, "ore"):
if self.resource_checker(h_c, p_s, c_s, "ore", ch_s, plus):
break
else:
if mine.info[mine.level + 1]["build"]["Forge"] > f_l:
self.plan.append(self.requests["ore need forge"])
else:
if not self.resource_checker(h_c, p_s, c_s, "ore", ch_s, plus):
if copy["wood"] >= Mine.info[1]["build"]["wood"]:
self.building_planer("build mine", ch_s, "ore", Mine, copy)
self.random_behaviour(10, "build mine", "upgrade mine", "upgrade mine",
"build sawmill", "upgrade sawmill")
self.resource_navigation_template("ore")
def people_are_soo_people(self):
for _ in range(10):
if rdm() >= 0.65:
self.plan.append(self.requests[chc([
"build well", "build well", "upgrade well", "upgrade well",
"upgrade well", "upgrade well", "build farm", "build farm",
"upgrade farm", "upgrade farm", "upgrade farm",
"build hunting house", "build hunting house",
"upgrade hunting house", "upgrade hunting house",
"upgrade hunting house", "upgrade hunting house", "build port",
"build port", "upgrade port", "upgrade port", "upgrade port",
"upgrade port", "build sawmill", "build sawmill",
"upgrade sawmill", "upgrade sawmill", "upgrade sawmill",
"upgrade sawmill", "upgrade sawmill", "build mine", "upgrade mine",
"upgrade mine", "build quarry", "upgrade quarry", "upgrade quarry",
"build forge", "upgrade forge", "upgrade forge"])])
def all_other_alerts_parser(self, f_l, ch_s, copy):
""" 91, 92, 93, 111, 121, 122, 123, 131, 141, 151, 161 """
if self.requests["build the family house"] in self.alert:
self.house_building_planer("build the family house", copy, self.alert)
if self.requests["upgrade the family house"] in self.alert:
self.house_upgrading_planer(self.alert, f_l, copy,
"upgrade the family house")
if self.requests["build a house for a human"] in self.alert:
self.house_building_planer("build a house for a human", copy, self.alert)
self.mine_builder_template(ch_s, copy)
self.quarry_builder_template(ch_s, copy)
self.forge_builder_template(ch_s, copy)
self.people_are_soo_people()
def house_building_planer(self, request, copy, place):
for _ in range(place.count(self.requests[request])):
if copy["wood"] - House.info[1]["build"]["wood"] >= 0:
self.plan.append(self.requests[request])
copy["wood"] -= House.info[1]["build"]["wood"]
def house_upgrading_planer(self, place, forge_level, copy, request):
for _ in range(place.count(self.requests[request])):
for house in self.houses.values():
if house.level != 5:
if len(house.tenants) >= house.info[house.level]["max p_l"]:
upgrade_flag = True
for res, val in house.info[house.level + 1]["build"].items():
if res == "Forge":
if forge_level < val:
upgrade_flag = False
elif copy[res] - val < 0:
upgrade_flag = False
if upgrade_flag:
for res, val in house.info[house.level + 1]["build"].items():
if res != "Forge":
copy[res] -= val
self.plan.append(self.requests[request])
def mine_builder_template(self, ch_s, copy):
if self.requests["no mine"] in self.alert:
self.building_planer("build mine", ch_s, "ore", Mine, copy)
def quarry_builder_template(self, ch_s, copy):
if self.requests["no quarry"] in self.alert:
self.building_planer("build quarry", ch_s, "stone", Quarry, copy)
def forge_builder_template(self, ch_s, copy):
if self.requests["no forge"] in self.alert:
self.building_planer("build forge", ch_s, "metal", Forge, copy)
def all_non_urgent_parser(self, h_c, p_s, c_s, f_l, ch_s, copy):
""" 14, 24, 34, 44, 54, 64, 91, 92, 93, 13, 23, 33, 43 """
self.people_are_soo_people()
if self.requests["water is up too slow"] in self.non_urgent:
self.water_template(h_c, p_s, c_s, f_l, ch_s, copy, 0)
if self.requests["food is up too slow"] in self.non_urgent:
self.food_template(h_c, p_s, c_s, f_l, ch_s, copy, 0)
if self.requests["wood is up too slow"] in self.non_urgent:
self.wood_template(h_c, p_s, c_s, f_l, ch_s, copy, 0)
if self.requests["ore is up too slow"] in self.non_urgent:
self.ore_template(h_c, p_s, c_s, f_l, ch_s, copy, 0)
if self.requests["metal is up too slow"] in self.non_urgent:
self.metal_template(h_c, p_s, c_s, f_l, ch_s, copy, 0)
if self.requests["stone is up too slow"] in self.non_urgent:
self.stone_template(h_c, p_s, c_s, f_l, ch_s, copy, 0)
if self.requests["build the family house"] in self.non_urgent:
self.house_building_planer("build the family house", copy, self.non_urgent)
if self.requests["upgrade the family house"] in self.non_urgent:
self.house_upgrading_planer(self.non_urgent, f_l, copy,
"upgrade the family house")
if self.requests["build a house for a human"] in self.non_urgent:
self.house_building_planer("build a house for a human",
copy, self.non_urgent)
if self.requests["water trend is strong"] in self.non_urgent:
self.water_template(h_c, p_s, c_s, f_l, ch_s, copy, -50)
if self.requests["food trend is strong"] in self.non_urgent:
self.food_template(h_c, p_s, c_s, f_l, ch_s, copy, -50)
if self.requests["wood trend is strong"] in self.non_urgent:
self.wood_template(h_c, p_s, c_s, f_l, ch_s, copy, -50)
if self.requests["ore trend is strong"] in self.non_urgent:
self.ore_template(h_c, p_s, c_s, f_l, ch_s, copy, -50)
self.people_are_soo_people()
def metal_template(self, h_c, p_s, c_s, f_l, ch_s, copy, plus):
for index in self.an_array_of_indexes_for_upgrade(Forge):
forge = self.buildings[index]
if forge.level != 15:
if self.upgrading_planer(forge, f_l, ch_s, "upgrade forge",
copy, "metal"):
if self.resource_checker(h_c, p_s, c_s, "metal", ch_s, plus):
break
else:
if not self.resource_checker(h_c, p_s, c_s, "metal", ch_s, plus):
if copy["wood"] >= Forge.info[1]["build"]["wood"]:
self.building_planer("build forge", ch_s, "metal", Forge, copy)
self.random_behaviour(10, "build forge", "upgrade forge", "upgrade forge",
"build mine", "upgrade mine")
self.resource_navigation_template("metal")
def stone_template(self, h_c, p_s, c_s, f_l, ch_s, copy, plus):
for index in self.an_array_of_indexes_for_upgrade(Quarry):
quarry = self.buildings[index]
if quarry.level != 10:
if self.upgrading_planer(quarry, f_l, ch_s, "upgrade quarry",
copy, "stone"):
if self.resource_checker(h_c, p_s, c_s, "stone", ch_s, plus):
break
else:
if quarry.info[quarry.level + 1]["build"]["Forge"] > f_l:
self.plan.append(self.requests["stone need forge"])
else:
if not self.resource_checker(h_c, p_s, c_s, "stone", ch_s, plus):
if copy["wood"] >= Quarry.info[1]["build"]["wood"]:
self.building_planer("build quarry", ch_s, "stone", Quarry, copy)
self.random_behaviour(5, "build quarry", "upgrade quarry", "upgrade quarry")
self.resource_navigation_template("stone")
def fourth_block_functions(self, f_l):
self.empty_facilities_parser()
ore_flag = self.ore_is_too_much()
self.plan_maker(f_l)
Human.people_did_not_build_any_buildings(self)
self.buildings_need_more_workers(ore_flag)
self.house_management()
def empty_facilities_parser(self):
if len(self.buildings) == 0:
return None
counter = \
[len(bg.workers) for bg in self.buildings.values() if len(bg.workers) == 0]
if len(counter) / len(self.buildings) >= 0.15:
commands = [15, 25, 35, 45, 55, 65, 91, 92, 93, 212, 222, 224, 226,
232, 242, 252, 262, 311, 321, 331, 341, 361, 421, 451]
self.plan = [cmd for cmd in self.plan if cmd in commands]
def ore_is_too_much(self):
if self.resources["ore"] >= 5000 and self.resources["metal"] <= 1000:
return True
return False
def plan_maker(self, f_l):
for element in self.plan:
if element == self.requests["build the family house"]:
if Human.people_want_to_build_new_facilities(self, 5):
house = House.a_house_builder(self)
if house:
self.houses[self.house_index] = house
self.house_index += 1
if element == self.requests["upgrade the family house"]:
for value in self.families.values():
if value["house"]:
house = self.houses[value["house"]]
if house.level != 5:
if len(house.tenants) >= house.info[house.level]["max p_l"]:
if Human.people_want_to_build_new_facilities(
self, house.level + 2):
house.upgrade_the_house(self, f_l)
break
if element == self.requests["build a house for a human"]:
if Human.people_want_to_build_new_facilities(self, 5):
house = House.a_house_builder(self, family_flag=False,
human_flag=True)
if house:
self.houses[self.house_index] = house
self.house_index += 1
if element == self.requests["build well"]:
if Human.people_want_to_build_new_facilities(self, 4):
well = Well.building_a_new_facility(self)
if well:
self.buildings[self.building_index] = well
self.building_index += 1
if element == self.requests["upgrade well"]:
for value in self.buildings.values():
if type(value) is Well:
if Human.people_want_to_build_new_facilities(
self, value.level):
if value.upgrade_the_facility(self, f_l):
break
if element == self.requests["build farm"]:
if self.requests["stop farm"] not in self.plan:
if Human.people_want_to_build_new_facilities(self, 4):
farm = Farm.building_a_new_facility(self)
if farm:
self.buildings[self.building_index] = farm
self.building_index += 1
if element == self.requests["upgrade farm"]:
for value in self.buildings.values():
if type(value) is Farm:
if Human.people_want_to_build_new_facilities(
self, value.level):
if value.upgrade_the_facility(self, f_l):
break
if element == self.requests["build hunting house"]:
if Human.people_want_to_build_new_facilities(self, 4):
hunting_house = HuntingHouse.building_a_new_facility(self)
if hunting_house:
self.buildings[self.building_index] = hunting_house
self.building_index += 1
if element == self.requests["upgrade hunting house"]:
for value in self.buildings.values():
if type(value) is HuntingHouse:
if Human.people_want_to_build_new_facilities(
self, value.level):
if value.upgrade_the_facility(self, f_l):
break
if element == self.requests["build port"]:
if Human.people_want_to_build_new_facilities(self, 4):
port = Port.building_a_new_facility(self)
if port:
self.buildings[self.building_index] = port
self.building_index += 1
if element == self.requests["upgrade port"]:
for value in self.buildings.values():
if type(value) is Port:
if Human.people_want_to_build_new_facilities(
self, value.level):
if value.upgrade_the_facility(self, f_l):
break
if element == self.requests["build sawmill"]:
if Human.people_want_to_build_new_facilities(self, 4):
sawmill = Sawmill.building_a_new_facility(self)
if sawmill:
self.buildings[self.building_index] = sawmill
self.building_index += 1
if element == self.requests["upgrade sawmill"]:
for value in self.buildings.values():
if type(value) is Sawmill:
if Human.people_want_to_build_new_facilities(
self, value.level):
if value.upgrade_the_facility(self, f_l):
break
if element == self.requests["build mine"]:
if Human.people_want_to_build_new_facilities(self, 4):
mine = Mine.building_a_new_facility(self)
if mine:
self.buildings[self.building_index] = mine
self.building_index += 1
if element == self.requests["upgrade mine"]:
for value in self.buildings.values():
if type(value) is Mine:
if Human.people_want_to_build_new_facilities(
self, value.level):
if value.upgrade_the_facility(self, f_l):
break
if element == self.requests["build quarry"]:
if Human.people_want_to_build_new_facilities(self, 4):
quarry = Quarry.building_a_new_facility(self)
if quarry:
self.buildings[self.building_index] = quarry
self.building_index += 1
if element == self.requests["upgrade quarry"]:
for value in self.buildings.values():
if type(value) is Quarry:
if Human.people_want_to_build_new_facilities(
self, value.level):
if value.upgrade_the_facility(self, f_l):
break
if element == self.requests["build forge"]:
if self.requests["stop forge"] not in self.plan:
if Human.people_want_to_build_new_facilities(self, 4):
forge = Forge.building_a_new_facility(self)
if forge:
self.buildings[self.building_index] = forge
self.building_index += 1
if element in (self.requests["upgrade forge"],
self.requests["water need forge"],
self.requests["food need forge"],
self.requests["wood need forge"],
self.requests["ore need forge"],
self.requests["stone need forge"]):
for value in self.buildings.values():
if type(value) is Forge:
if Human.people_want_to_build_new_facilities(
self, value.level):
if value.upgrade_the_facility(self, f_l):
break
def buildings_need_more_workers(self, ore_flag):
for index, building in self.buildings.items():
for worker in building.workers:
worker.job_status = None
building.workers = []
for index, building in self.buildings.items():
if type(building) is Mine and ore_flag:
continue
limit = self.resource_is_too_much_parser(building) or \
building.info[building.level]["max w_s"]
if len(building.workers) < limit:
for array in (self.adults, self.elders):
for human in array:
if not human.job_status:
if len(building.workers) < limit:
building.workers.append(human)
human.job_status = index
else:
break
def resource_is_too_much_parser(self, building):
for request, obj in {"water is too much": Well,
"food is too much": [Farm, HuntingHouse, Port],
"wood is too much": Sawmill, "ore is too much": Mine,
"metal is too much": Forge,
"stone is too much": Quarry}.items():
if request == "food is too much":
for oj in obj:
if building is type(oj) and self.requests[request] in self.plan:
return building.info[building.level]["max w_s"] // 2
else:
if building is type(obj) and self.requests[request] in self.plan:
return building.info[building.level]["max w_s"] // 2
def house_management(self):
for index, house in self.houses.items():
if len(house.tenants) == 0:
for family in self.families.values():
if not family["house"]:
family["house"] = index
for human in ([*family["parents"], *family["children"]]):
human.house_index = index
house.tenants.append(human)
break
def fifth_block_functions(self):
for array in (self.kids, self.adults, self.elders):
for human in array:
human.age += 1
human.attractiveness = human.attractiveness_parameter_changer()
human.wish_attr = human.wish_attractiveness_parameter_changer()
Human.moving_people_from_array_to_array(self)
Human.people_want_to_make_families(self)
Human.people_want_to_make_new_people(self)
Human.dead_function_by_age(self)
Human.removing_all_families_without_parents(self)
class ResourceFacility:
""" Core class for inheriting for other facilities that bring resources. Objects
of this class stored inside of [Environment.buildings]. The __str__
representation is a general information about level and quantity of workers.
Every object of class "ResourceFacility" has its own dictionary with all
necessary information inside of it. Dictionary consists of:
"max w_s" = int : maximum amount of workers on this level.
"jun" = float : how many resources will make 1 non-professional worker.
"pro" = float : how many resources will make 1 professional worker.
"build" = {} : {"resource" or "facility": (amount of resources or level) = int}.
All : [Farm, HuntingHouse, Port, Well, Sawmill, Mine, Quarry, Forge]. """
def __init__(self, name, index, level=1):
self.name = name # str : name of an object of the class ResourceFacility
self.index = index # int : is a Environment.building_index
self.level = level # int : level of the facility
self.workers = [] # amount of current workers
def __str__(self):
return f"{self.name} ({self.level}), amount of workers = {len(self.workers)}"
def assets_and_liabilities_counter(self, assets, liabilities, costs, profession,
years, place, minimum, maximum, resource):
""" random.randrange ~~~ random.choice ~~< random.randint """
for worker in self.workers:
if worker.employment_history[profession] >= years:
assets[resource] += place[self.level]["pro"] \
* rdr(minimum, maximum) / 100
assets[resource] = round(assets[resource], 2)
if profession in ("farmer", "blacksmith"):
for res, value in costs.items():
liabilities[res] += place[self.level]["pro"] * value \
* rdr(75, 126) / 100
liabilities[res] = round(liabilities[res], 2)
else:
assets[resource] += place[self.level]["jun"] * rdr(minimum, 101) / 100
assets[resource] = round(assets[resource], 2)
if profession in ("farmer", "blacksmith"):
for res, value in costs.items():
liabilities[res] += place[self.level]["jun"] * value \
* rdr(85, 136) / 100
liabilities[res] = round(liabilities[res], 2)
def more_experience_workers(self, profession):
for worker in self.workers:
worker.employment_history[profession] += 1
@staticmethod
def building_a_new_facility(place, i_n, obj, name):
if all(place.resources[res] - v >= 0 for res, v in i_n[1]["build"].items()):
for res, value in i_n[1]["build"].items():
place.resources[res] -= value
return obj(f"{name} {place.building_index}", place.building_index)
def upgrade_the_facility(self, place, forge_level, i_n):
upgrade_flag = True
for res, value in i_n[self.level + 1]["build"].items():
if res == "Forge":
if forge_level < value:
upgrade_flag = False
elif place.resources[res] - value < 0:
upgrade_flag = False
if upgrade_flag:
self.level += 1
for res, value in i_n[self.level]["build"].items():
if res != "Forge":
place.resources[res] -= value
return True
return False
class Well(ResourceFacility):
""" Making water by extraction. All information about wells are in the
{info} {level: {information}}.
def production_and_costs() ::: total production of water and
total costs of metal from 1 well.
Worker :: engineer, "pro" if worker.employment_history["engineer"] >= 10. """
info = {
1: {"max w_s": 1, "jun": 15, "pro": 15, "build": {"wood": 25}},
2: {"max w_s": 1, "jun": 25, "pro": 25, "build": {"wood": 35}},
3: {"max w_s": 1, "jun": 40, "pro": 40, "build": {"wood": 50}},
4: {"max w_s": 1, "jun": 65, "pro": 65, "build": {"wood": 75}},
5: {"max w_s": 2, "jun": 100, "pro": 100, "build": {"wood": 100, "stone": 500}},
6: {"max w_s": 2, "jun": 150, "pro": 150, "build": {"wood": 150, "stone": 300}},
7: {"max w_s": 2, "jun": 200, "pro": 200, "build": {"wood": 200, "stone": 400}},
8: {"max w_s": 2, "jun": 250, "pro": 250, "build": {"wood": 250, "stone": 500}},
9: {"max w_s": 2, "jun": 350, "pro": 350, "build": {"wood": 500, "stone": 500}},
10: {"max w_s": 3, "jun": 500, "pro": 550,
"build": {"wood": 2500, "metal": 2500, "stone": 5000, "Forge": 10}},
11: {"max w_s": 4, "jun": 500, "pro": 550,
"build": {"wood": 750, "metal": 250}},
12: {"max w_s": 5, "jun": 500, "pro": 550,
"build": {"wood": 850, "metal": 400}},
13: {"max w_s": 6, "jun": 500, "pro": 550,
"build": {"wood": 1000, "metal": 600}},
14: {"max w_s": 7, "jun": 500, "pro": 550,
"build": {"wood": 1500, "metal": 1000}},
15: {"max w_s": 10, "jun": 500, "pro": 600,
"build": {"wood": 7500, "metal": 5000, "stone": 10000, "Forge": 15}}
}
def __init__(self, *args):
super().__init__(*args)
def assets_and_liabilities_counter(self, assets, liabilities, costs=None,
profession="engineer", years=10, place=None,
minimum=85, maximum=106, resource="water"):
super().assets_and_liabilities_counter(assets, liabilities, costs,
profession, years, self.info,
minimum, maximum, resource)
def more_experience_workers(self, profession="engineer"):
super().more_experience_workers(profession)
@staticmethod
def building_a_new_facility(place, i_n=None, obj=None, name=None):
return ResourceFacility.building_a_new_facility(place, i_n=Well.info,
obj=Well, name="Well")
def upgrade_the_facility(self, place, forge_level, i_n=None):
return ResourceFacility.upgrade_the_facility(
self, place, forge_level, i_n=Well.info)
class Farm(ResourceFacility):
""" Making food by seeding and harvesting. All information about farms are in
the {info} {level: {information}}.
def production_and_costs() ::: total production of food and total costs of
water, wood and metal from 1 farm.
Worker :: farmer, "pro" if worker.employment_history["farmer"] >= 5. """
info = {
1: {"max w_s": 3, "jun": 6, "pro": 10, "build": {"wood": 25}},
2: {"max w_s": 4, "jun": 7, "pro": 11, "build": {"wood": 35}},
3: {"max w_s": 5, "jun": 8, "pro": 12, "build": {"wood": 50}},
4: {"max w_s": 7, "jun": 9, "pro": 13, "build": {"wood": 100}},
5: {"max w_s": 10, "jun": 11, "pro": 15,
"build": {"wood": 150, "metal": 150, "Forge": 3}},
6: {"max w_s": 15, "jun": 12, "pro": 16, "build": {"wood": 150, "metal": 100}},
7: {"max w_s": 20, "jun": 13, "pro": 17, "build": {"wood": 200, "metal": 150}},
8: {"max w_s": 25, "jun": 14, "pro": 18, "build": {"wood": 250, "metal": 200}},
9: {"max w_s": 30, "jun": 15, "pro": 19, "build": {"wood": 350, "metal": 250}},
10: {"max w_s": 50, "jun": 20, "pro": 30,
"build": {"wood": 2500, "metal": 1500, "stone": 2500, "Forge": 8}},
11: {"max w_s": 60, "jun": 20, "pro": 30,
"build": {"wood": 500, "metal": 750}},
12: {"max w_s": 70, "jun": 20, "pro": 30, "build": {"wood": 500, "metal": 800}},
13: {"max w_s": 85, "jun": 20, "pro": 30,
"build": {"wood": 550, "metal": 900}},
14: {"max w_s": 100, "jun": 20, "pro": 30,
"build": {"wood": 750, "metal": 1000}},
15: {"max w_s": 125, "jun": 25, "pro": 40,
"build": {"wood": 5000, "metal": 3000, "stone": 5000, "Forge": 15}}
}
def __init__(self, *args):
super().__init__(*args)
def assets_and_liabilities_counter(self, assets, liabilities, costs=None,
profession="farmer", years=5, place=None,
minimum=50, maximum=151, resource="food"):
super().assets_and_liabilities_counter(assets, liabilities, {"water": 1},
profession, years, self.info,
minimum, maximum, resource)
def more_experience_workers(self, profession="farmer"):
super().more_experience_workers(profession)
@staticmethod
def building_a_new_facility(place, i_n=None, obj=None, name=None):
return ResourceFacility.building_a_new_facility(place, i_n=Farm.info,
obj=Farm, name="Farm")
def upgrade_the_facility(self, place, forge_level, i_n=None):
return ResourceFacility.upgrade_the_facility(
self, place, forge_level, i_n=Farm.info)
class HuntingHouse(ResourceFacility):
""" Making food by hunting prey. All information about hunting houses are in
the {info} {level: {information}}.
def production_and_costs() ::: total production of food and total costs of
wood and metal from 1 hunting house.
Worker :: hunter, "pro" if worker.employment_history["hunter"] >= 5. """
info = {
1: {"max w_s": 2, "jun": 2.5, "pro": 5, "build": {"wood": 50}},
2: {"max w_s": 3, "jun": 2.5, "pro": 5.3, "build": {"wood": 100}},
3: {"max w_s": 4, "jun": 2.5, "pro": 5.6, "build": {"wood": 150}},
4: {"max w_s": 5, "jun": 2.5, "pro": 6, "build": {"wood": 200}},
5: {"max w_s": 10, "jun": 5, "pro": 10,
"build": {"wood": 500, "metal": 250, "stone": 250, "Forge": 3}},
6: {"max w_s": 15, "jun": 5, "pro": 10.5, "build": {"wood": 500, "metal": 150}},
7: {"max w_s": 20, "jun": 5, "pro": 11, "build": {"wood": 500, "metal": 200}},
8: {"max w_s": 25, "jun": 5, "pro": 11.5, "build": {"wood": 500, "metal": 250}},
9: {"max w_s": 35, "jun": 5, "pro": 12, "build": {"wood": 600, "metal": 300}},
10: {"max w_s": 50, "jun": 7.5, "pro": 15,
"build": {"wood": 1000, "metal": 500, "stone": 500, "Forge": 8}}
}
def __init__(self, *args):
super().__init__(*args)
def assets_and_liabilities_counter(self, assets, liabilities, costs=None,
profession="hunter", years=5, place=None,
minimum=70, maximum=131, resource="food"):
super().assets_and_liabilities_counter(assets, liabilities, costs,
profession, years, self.info,
minimum, maximum, resource)
def more_experience_workers(self, profession="hunter"):
super().more_experience_workers(profession)
@staticmethod
def building_a_new_facility(place, i_n=None, obj=None, name=None):
return ResourceFacility.building_a_new_facility(place, i_n=HuntingHouse.info,
obj=HuntingHouse,
name="Hunting house")
def upgrade_the_facility(self, place, forge_level, i_n=None):
return ResourceFacility.upgrade_the_facility(
self, place, forge_level, i_n=HuntingHouse.info)
class Port(ResourceFacility):
""" Making food by fishing. All information about ports are in the
{info} {level: {information}}.
def production_and_costs() ::: total production of food and total costs of
wood and metal from 1 port.
Worker :: fisher, "pro" if worker.employment_history["fisher"] >= 3. """
info = {
1: {"max w_s": 3, "jun": 3, "pro": 5, "build": {"wood": 250}},
2: {"max w_s": 4, "jun": 3, "pro": 5.2, "build": {"wood": 100}},
3: {"max w_s": 5, "jun": 3, "pro": 5.4, "build": {"wood": 150}},
4: {"max w_s": 7, "jun": 3, "pro": 5.7, "build": {"wood": 250}},
5: {"max w_s": 10, "jun": 5, "pro": 10,
"build": {"wood": 1000, "metal": 500, "stone": 1000, "Forge": 5}},
6: {"max w_s": 15, "jun": 5, "pro": 10.5, "build": {"wood": 500, "metal": 50}},
7: {"max w_s": 20, "jun": 5, "pro": 11, "build": {"wood": 500, "metal": 50}},
8: {"max w_s": 25, "jun": 5, "pro": 11.5, "build": {"wood": 600, "metal": 75}},
9: {"max w_s": 35, "jun": 5, "pro": 12, "build": {"wood": 600, "metal": 75}},
10: {"max w_s": 50, "jun": 8, "pro": 19,
"build": {"wood": 2000, "metal": 1000, "stone": 2500, "Forge": 10}},
11: {"max w_s": 70, "jun": 8, "pro": 20, "build": {"wood": 750, "metal": 100}},
12: {"max w_s": 100, "jun": 10, "pro": 25,
"build": {"wood": 2500, "metal": 1500, "stone": 500, "Forge": 12}}
}
def __init__(self, *args):
super().__init__(*args)
def assets_and_liabilities_counter(self, assets, liabilities, costs=None,
profession="fisher", years=3, place=None,
minimum=85, maximum=116, resource="food"):
super().assets_and_liabilities_counter(assets, liabilities, costs,
profession, years, self.info,
minimum, maximum, resource)
def more_experience_workers(self, profession="fisher"):
super().more_experience_workers(profession)
@staticmethod
def building_a_new_facility(place, i_n=None, obj=None, name=None):
return ResourceFacility.building_a_new_facility(place, i_n=Port.info,
obj=Port, name="Port")
def upgrade_the_facility(self, place, forge_level, i_n=None):
return ResourceFacility.upgrade_the_facility(
self, place, forge_level, i_n=Port.info)
class Sawmill(ResourceFacility):
""" Making wood by chopping forest. All information about sawmills are
in the {info} {level: {information}}.
def production_and_costs() ::: total production of wood and total costs of
metal from 1 sawmill.
Worker :: chopper, "pro" if worker.employment_history["chopper"] >= 8. """
info = {
1: {"max w_s": 5, "jun": 5, "pro": 7.5, "build": {"wood": 50}},
2: {"max w_s": 7, "jun": 5.2, "pro": 8, "build": {"wood": 75}},
3: {"max w_s": 9, "jun": 5.4, "pro": 8.5, "build": {"wood": 100}},
4: {"max w_s": 12, "jun": 5.7, "pro": 9,
"build": {"wood": 100, "metal": 100, "Forge": 1}},
5: {"max w_s": 20, "jun": 6, "pro": 10, "build": {"wood": 150, "metal": 50}},
6: {"max w_s": 30, "jun": 6.3, "pro": 11, "build": {"wood": 200, "metal": 100}},
7: {"max w_s": 40, "jun": 6.7, "pro": 12, "build": {"wood": 250, "metal": 150}},
8: {"max w_s": 50, "jun": 7.1, "pro": 13, "build": {"wood": 250, "metal": 250}},
9: {"max w_s": 60, "jun": 7.5, "pro": 14, "build": {"wood": 250, "metal": 500}},
10: {"max w_s": 70, "jun": 10, "pro": 20,
"build": {"wood": 1000, "metal": 2500, "stone": 2500, "Forge": 8}},
11: {"max w_s": 80, "jun": 10.5, "pro": 22,
"build": {"metal": 400, "stone": 250}},
12: {"max w_s": 90, "jun": 11, "pro": 24,
"build": {"metal": 500, "stone": 250}},
13: {"max w_s": 100, "jun": 11.5, "pro": 26,
"build": {"metal": 650, "stone": 250}},
14: {"max w_s": 125, "jun": 12, "pro": 28,
"build": {"metal": 750, "stone": 500}},
15: {"max w_s": 150, "jun": 20, "pro": 40,
"build": {"wood": 2500, "metal": 5000, "stone": 5000, "Forge": 15}}
}
def __init__(self, *args):
super().__init__(*args)
def assets_and_liabilities_counter(self, assets, liabilities, costs=None,
profession="chopper", years=8, place=None,
minimum=95, maximum=106, resource="wood"):
super().assets_and_liabilities_counter(assets, liabilities, costs,
profession, years, self.info,
minimum, maximum, resource)
def more_experience_workers(self, profession="chopper"):
super().more_experience_workers(profession)
@staticmethod
def building_a_new_facility(place, i_n=None, obj=None, name=None):
return ResourceFacility.building_a_new_facility(
place=place, i_n=Sawmill.info, obj=Sawmill, name="Sawmill")
def upgrade_the_facility(self, place, forge_level, i_n=None):
return ResourceFacility.upgrade_the_facility(
self, place, forge_level, i_n=Sawmill.info)
class Mine(ResourceFacility):
""" Extracting ore by mining. All information about mines are in
the {info} {level: {information}}.
def production_and_costs() ::: total production of ore and total costs of
metal from 1 mine.
Worker :: miner, "pro" if worker.employment_history["miner"] >= 10. """
info = {
1: {"max w_s": 5, "jun": 5, "pro": 10, "build": {"wood": 150}},
2: {"max w_s": 7, "jun": 5, "pro": 10, "build": {"wood": 200}},
3: {"max w_s": 10, "jun": 5, "pro": 10,
"build": {"wood": 250, "metal": 50, "Forge": 1}},
4: {"max w_s": 15, "jun": 5, "pro": 10, "build": {"wood": 250, "metal": 100}},
5: {"max w_s": 20, "jun": 10, "pro": 15,
"build": {"wood": 500, "metal": 250, "stone": 250, "Forge": 2}},
6: {"max w_s": 25, "jun": 10, "pro": 15, "build": {"wood": 300, "metal": 300}},
7: {"max w_s": 35, "jun": 10, "pro": 15, "build": {"wood": 300, "metal": 300}},
8: {"max w_s": 50, "jun": 10, "pro": 15, "build": {"wood": 350, "metal": 350}},
9: {"max w_s": 75, "jun": 10, "pro": 15, "build": {"wood": 500, "metal": 500}},
10: {"max w_s": 100, "jun": 15, "pro": 30,
"build": {"wood": 2500, "metal": 2000, "stone": 2000, "Forge": 10}}
}
def __init__(self, *args):
super().__init__(*args)
def assets_and_liabilities_counter(self, assets, liabilities, costs=None,
profession="miner", years=10, place=None,
minimum=95, maximum=106, resource="ore"):
super().assets_and_liabilities_counter(assets, liabilities, costs,
profession, years, self.info,
minimum, maximum, resource)
def more_experience_workers(self, profession="miner"):
super().more_experience_workers(profession)
@staticmethod
def building_a_new_facility(place, i_n=None, obj=None, name=None):
return ResourceFacility.building_a_new_facility(place, i_n=Mine.info,
obj=Mine, name="Mine")
def upgrade_the_facility(self, place, forge_level, i_n=None):
return ResourceFacility.upgrade_the_facility(
self, place, forge_level, i_n=Mine.info)
class Quarry(ResourceFacility):
""" Extracting stone by mining. All information about quarries are in
the {info} {level: {information}}.
def production_and_costs() ::: total production of stone and total costs of
metal from 1 quarry.
Worker :: miner, "pro" if worker.employment_history["miner"] >= 10. """
info = {
1: {"max w_s": 5, "jun": 5, "pro": 10, "build": {"wood": 150}},
2: {"max w_s": 7, "jun": 5, "pro": 10, "build": {"wood": 200}},
3: {"max w_s": 10, "jun": 5, "pro": 10,
"build": {"wood": 250, "metal": 50, "Forge": 1}},
4: {"max w_s": 15, "jun": 5, "pro": 10, "build": {"wood": 250, "metal": 200}},
5: {"max w_s": 20, "jun": 10, "pro": 15,
"build": {"wood": 500, "metal": 250, "stone": 250, "Forge": 2}},
6: {"max w_s": 25, "jun": 10, "pro": 15, "build": {"wood": 300, "metal": 300}},
7: {"max w_s": 35, "jun": 10, "pro": 15, "build": {"wood": 300, "metal": 300}},
8: {"max w_s": 50, "jun": 10, "pro": 15, "build": {"wood": 350, "metal": 350}},
9: {"max w_s": 75, "jun": 10, "pro": 15, "build": {"wood": 500, "metal": 500}},
10: {"max w_s": 100, "jun": 15, "pro": 30,
"build": {"wood": 2500, "metal": 2000, "stone": 2000, "Forge": 10}}
}
def __init__(self, *args):
super().__init__(*args)
def assets_and_liabilities_counter(self, assets, liabilities, costs=None,
profession="miner", years=10, place=None,
minimum=95, maximum=106, resource="stone"):
super().assets_and_liabilities_counter(assets, liabilities, costs,
profession, years, self.info,
minimum, maximum, resource)
def more_experience_workers(self, profession="miner"):
super().more_experience_workers(profession)
@staticmethod
def building_a_new_facility(place, i_n=None, obj=None, name=None):
return ResourceFacility.building_a_new_facility(place, i_n=Quarry.info,
obj=Quarry, name="Quarry")
def upgrade_the_facility(self, place, forge_level, i_n=None):
return ResourceFacility.upgrade_the_facility(
self, place, forge_level, i_n=Quarry.info)
class Forge(ResourceFacility):
""" Forge are used for getting metal from ore, upgrading facilities,
making and repairing new equipment. It takes 2 ore for making 1 metal.
All information about forges are in the {info} {level: {information}}.
def production_and_costs() ::: total production of metal and total costs of
ore, wood and metal from 1 forge.
Worker :: blacksmith, "pro" if worker.employment_history["blacksmith"] >= 15. """
info = {
1: {"max w_s": 2, "jun": 1, "pro": 2.5, "build": {"wood": 500}},
2: {"max w_s": 3, "jun": 1, "pro": 2.8, "build": {"wood": 100}},
3: {"max w_s": 5, "jun": 1, "pro": 3.1, "build": {"wood": 150}},
4: {"max w_s": 7, "jun": 1, "pro": 3.5, "build": {"wood": 200}},
5: {"max w_s": 10, "jun": 5, "pro": 10,
"build": {"wood": 1000, "metal": 150, "stone": 250}},
6: {"max w_s": 15, "jun": 5, "pro": 10.5, "build": {"wood": 250, "metal": 100}},
7: {"max w_s": 20, "jun": 5, "pro": 11, "build": {"wood": 250, "metal": 150}},
8: {"max w_s": 25, "jun": 5, "pro": 11.5, "build": {"wood": 250, "metal": 200}},
9: {"max w_s": 35, "jun": 5, "pro": 12, "build": {"wood": 250, "metal": 250}},
10: {"max w_s": 50, "jun": 10, "pro": 20,
"build": {"wood": 2500, "metal": 1500, "stone": 2500}},
11: {"max w_s": 65, "jun": 10, "pro": 21,
"build": {"wood": 500, "metal": 500, "stone": 750}},
12: {"max w_s": 80, "jun": 10, "pro": 22,
"build": {"wood": 500, "metal": 500, "stone": 1000}},
13: {"max w_s": 100, "jun": 10, "pro": 23,
"build": {"wood": 750, "metal": 1000, "stone": 1500}},
14: {"max w_s": 125, "jun": 10, "pro": 24,
"build": {"wood": 1000, "metal": 1500, "stone": 2000}},
15: {"max w_s": 150, "jun": 15, "pro": 30,
"build": {"wood": 5000, "metal": 5000, "stone": 10000}}
}
def __init__(self, *args):
super().__init__(*args)
def assets_and_liabilities_counter(self, assets, liabilities, costs=None,
profession="blacksmith", years=15, place=None,
minimum=95, maximum=106, resource="metal"):
super().assets_and_liabilities_counter(assets, liabilities, {"ore": 2},
profession, years, self.info,
minimum, maximum, resource)
def more_experience_workers(self, profession="blacksmith"):
super().more_experience_workers(profession)
@staticmethod
def building_a_new_facility(place, i_n=None, obj=None, name=None):
return ResourceFacility.building_a_new_facility(place, i_n=Forge.info,
obj=Forge, name="Forge")
def upgrade_the_facility(self, place, forge_level, i_n=None):
return ResourceFacility.upgrade_the_facility(
self, place, forge_level, i_n=Forge.info)
class House:
""" House is a place, where people live. All houses have a unique number-key
which is Environment.house_index. The __len__ representation is a number
of alive people, living in the house. All information about houses are in
the {info} {level: {information}}. """
info = {
1: {"max p_l": 4, "cost: wood": 0.9, "build": {"wood": 50}},
2: {"max p_l": 8, "cost: wood": 0.8,
"build": {"wood": 300, "metal": 50, "Forge": 1}},
3: {"max p_l": 14, "cost: wood": 0.7,
"build": {"wood": 750, "metal": 150, "Forge": 3}},
4: {"max p_l": 22, "cost: wood": 0.6,
"build": {"wood": 1000, "metal": 250, "stone": 1000, "Forge": 5}},
5: {"max p_l": 32, "cost: wood": 0.5,
"build": {"wood": 1500, "metal": 500, "stone": 2000, "Forge": 8}}
}
def __init__(self, index, level=1):
self.index = index # int : is a Environment.house_index
self.level = level # int : level of a facility
self.tenants = [] # an array of people, who live in this house
def __len__(self):
return len(self.tenants)
def __str__(self):
return f"house {self.index} ({self.level}), amount of tenants = {len(self)}"
@staticmethod
def a_house_builder(place, family_flag=True, human_flag=False):
wood = place.resources["wood"] - House.info[1]["build"]["wood"]
if wood >= 0:
place.resources["wood"] -= House.info[1]["build"]["wood"]
house = House(place.house_index)
if family_flag:
for index, family in place.families.items():
if not family["house"]:
family["house"] = house.index
for array in (family["parents"], family["children"]):
for human in array:
human.house_index = house.index
house.tenants.append(human)
break
elif human_flag:
for array in (place.adults, place.elders):
for human in array:
if not human.house_index:
human.house_index = house.index
house.tenants.append(human)
break
return house
def upgrade_the_house(self, place, f_l):
upgrade_flag = True
for res, value in self.info[self.level + 1]["build"].items():
if res == "Forge":
if f_l < value:
upgrade_flag = False
elif place.resources[res] - value < 0:
upgrade_flag = False
if upgrade_flag:
self.level += 1
for res, value in self.info[self.level]["build"].items():
if res != "Forge":
place.resources[res] -= value
class Human:
""" Human is a alive create, who is trying to make his / her life. They try to
make new families and children. They have resources for building facilities,
like houses, where they can live, or buildings, where they can make other
resources. For there life, they need 1 water, 1 food and, depends on the
level of the house they are living in, 1 - 0.5 wood. """
def __init__(self, genome=None, surname=None, age=0, wish_attr=0.5,
family_parent_index=None, family_history="", house_index=None):
# base human attributes
self.genome = genome or "".join([chr(rdr(65, 91)) for _ in range(46)])
# str : 46 upper letters value as a unique human code
self.sex = "M" if rdm() >= 0.5 else "F" # str : Male or Female
self.age = age # int : human years, 0 when was born
self.death = 0.75 # int : number, which used in dead_function_by_age() function
with open("list_of_names.json", "r") as names_dict:
names = load(names_dict)
self.name = names["name_man"][rdr(0, 340)] if self.sex == "M" \
else names["name_woman"][rdr(0, 204)] # str : human name
self.surname = surname or names["surname"][rdr(0, 60)] # str : human surname
# attributes for family
self.attr = float("{:.2f}".format(wb(2.5, 2.5))) # float : attractiveness
self.wish_attr = wish_attr # float : wish attractiveness
self.marriage = None # Human() : None if not marriage else husband or wife
self.family_index = None # int : is a Environment.family_index
self.family_parent_index = family_parent_index # int : an index of the family
# where human() is a child
self.family_history = family_history # str : family history of the human
self.indexes = [] # all family_indexes of a human
# attributes for profession
self.employment_history = {"builder": 0, "farmer": 0, "hunter": 0,
"fisher": 0, "engineer": 0, "chopper": 0,
"miner": 0, "blacksmith": 0}
self.builder_status = False # bool : True if in Environment.brigades
self.job_status = None # int : if ResourceFacility.index, else None
# attribute for houses
self.house_index = house_index # int : index of the human house
def __str__(self):
return f"{self.surname} {self.name}, {self.sex}, {self.age}, family = " \
f"{self.family_index}, house = {self.house_index}, history = " \
f"'{self.family_history}', genome = {self.genome}"
@staticmethod
def dead_function_by_age(place):
for copies in (place.kids[:], place.adults[:], place.elders[:]):
counter = 0
for number, human in enumerate(copies):
if human.age < 25:
bones = abs(2.626225 * rdm() - (human.age / 24950)) / 3.5
elif human.age < 61:
bones = (2.3252332 * rdm() + ((human.age - 26) / 16250)) / 3.1
else:
bones = (1.726726 * rdm() + ((human.age - 61) / 75)) / 2.3
if bones >= human.death:
if human.age < 18:
place.grave.append(place.kids.pop(number - counter))
elif human.age < 55:
place.grave.append(place.adults.pop(number - counter))
elif human.age >= 55:
place.grave.append(place.elders.pop(number - counter))
counter += 1
for corpse in place.grave:
if corpse.family_parent_index:
place.families[corpse.family_parent_index]["children"].remove(corpse)
corpse.family_parent_index = None
if corpse.marriage:
for family in corpse.indexes:
place.families[family]["parents"].remove(corpse)
corpse.marriage.marriage = None
corpse.marriage, corpse.indexes, corpse.family_index = None, [], None
if not corpse.marriage and corpse.indexes:
for family in corpse.indexes:
place.families[family]["parents"].remove(corpse)
corpse.indexes, corpse.family_index = [], None
if corpse.house_index:
place.houses[corpse.house_index].tenants.remove(corpse)
corpse.house_index = None
if corpse.job_status:
if type(corpse.job_status) is int:
place.buildings[corpse.job_status].workers.remove(corpse)
corpse.job_status = None
elif type(corpse.job_status) is bool:
place.brigades.remove(corpse)
corpse.job_status = None
@staticmethod
def removing_all_families_without_parents(place):
for number, family in place.families.copy().items():
if len(family["parents"]) == 0:
for child in family["children"]:
child.family_parent_index = None
del place.families[number]
def attractiveness_parameter_changer(self):
return float("{:.2f}".format(self.attr +
((rdm() / 2) * ((50 - self.age) / 100))))
def wish_attractiveness_parameter_changer(self):
if self.age > 35 and not self.marriage:
wish = float("{:.2f}".format(self.wish_attr +
(rdm() * ((35 - self.age) / 200))))
else:
wish = float("{:.2f}".format(self.wish_attr +
(rdm() * ((50 - self.age) / 200))))
if wish < 0:
return 0
return wish
@staticmethod
def genome_checker(genome_1, genome_2):
counter, same = 0, 0
for _ in range(23):
if genome_1[counter:counter + 2] == genome_2[counter:counter + 2]:
same += 2
counter += 2
if same / 46 >= 0.15:
return False
return True
@staticmethod
def people_want_to_make_families(place):
for human in place.adults:
if not human.marriage:
for challenger in place.adults:
if not challenger.marriage and challenger.sex != human.sex \
and Human.genome_checker(human.genome, challenger.genome) \
and human.attr >= challenger.wish_attr \
and challenger.attr >= human.wish_attr:
if rdm() >= (0.6 + (abs(human.age - challenger.age) / 100)):
place.families[place.family_index] = {
"house": None, "parents": [human, challenger],
"children": []}
human.marriage, challenger.marriage = challenger, human
for parent in (human, challenger):
parent.indexes.append(place.family_index)
human.family_index = place.family_index
challenger.family_index = place.family_index
human.family_history += f"{place.family_index} "
challenger.family_history += f"{place.family_index} "
Human.new_house_for_a_new_family(place, human, challenger)
place.family_index += 1
break
continue
@staticmethod
def genome_parameter_for_making_a_new_human_via_a_family(genome_1, genome_2):
genome, counter = "", 0
for _ in range(23):
genome += chc([genome_1[counter:counter + 2], genome_2[counter:counter + 2]])
counter += 2
return genome
@staticmethod
def new_house_for_a_new_family(place, human, challenger):
if human.house_index and len(place.houses[human.house_index].tenants) == 1:
challenger.house_index = human.house_index
place.houses[human.house_index].tenants.append(challenger)
place.families[place.family_index]["house"] = human.house_index
return
if challenger.house_index and \
len(place.houses[challenger.house_index].tenants) == 1:
human.house_index = challenger.house_index
place.houses[challenger.house_index].tenants.append(human)
place.families[place.family_index]["house"] = challenger.house_index
return
@staticmethod
def baby_maker_function_via_a_family(gen_1, gen_2, surname, index, family_history,
house_index, place):
genome = Human.genome_parameter_for_making_a_new_human_via_a_family(gen_1, gen_2)
baby = Human(genome=genome, surname=surname, family_parent_index=index,
family_history=family_history, house_index=house_index)
place.kids.append(baby)
place.families[index]["children"].append(baby)
if house_index:
place.houses[house_index].tenants.append(baby)
@staticmethod
def people_want_to_make_new_people(place):
for index, fml in place.families.items():
if len(fml["parents"]) == 2 and rdm() \
>= (0.8 + (sqrt(len(fml["children"])) * 5 / 100)):
if fml["parents"][0].age in range(18, 56) and \
fml["parents"][1].age in range(18, 56):
gen_1, gen_2, surname, family_history = None, None, None, None
for parent in fml["parents"]:
if parent.sex == "M":
gen_1 = parent.genome
surname = parent.surname
family_history = parent.family_history
else:
gen_2 = parent.genome
Human.baby_maker_function_via_a_family(gen_1, gen_2, surname, index,
family_history, fml["house"],
place)
if rdm() >= 0.99:
Human.baby_maker_function_via_a_family(gen_1, gen_2, surname,
index, family_history,
fml["house"], place)
@staticmethod
def moving_people_from_array_to_array(place):
counter = 0
for number, child in enumerate(place.kids[:]):
if child.age >= 18:
place.adults.append(place.kids.pop(number - counter))
counter += 1
counter = 0
for number, adult in enumerate(place.adults[:]):
if adult.age >= 55:
place.elders.append(place.adults.pop(number - counter))
counter += 1
@staticmethod
def people_want_to_build_new_facilities(place, need):
have = 0
for builder in place.brigades:
have += 2 if builder.employment_history["builder"] >= 10 else 1
builder.employment_history["builder"] += 1
place.brigades.remove(builder)
builder.builder_status = False
if have >= need:
return True
return False
@staticmethod
def people_did_not_build_any_buildings(place):
for builder in place.brigades:
builder.builder_status = False
place.brigades.remove(builder)
def integer_checker(question=None, value=None, message=None):
if question:
print(question)
text = value or input()
while True:
try:
number = int(text)
if number < 0:
if message:
print(f"'{message}' >>> '{number}' is not acceptable. "
f"Should be at least equal to 0. Please, try again.")
else:
print(f"'{number}' is not acceptable. "
f"Should be at least equal to 0. Please, try again.")
else:
return number
except ValueError:
if message:
print(f"'{message}' >>> '{text}' is not acceptable. "
f"Please, print a number (int).")
else:
print(f"'{text}' is not acceptable. Please, print a number (int).")
text = input()
def average_life_function(place):
if not place.grave:
return 0
else:
average_life = 0
for dead_bodies in place.grave:
average_life += dead_bodies.age
return float("{:.2f}".format(average_life / len(place.grave)))
def data_collecting_function(seconds):
global Earth
Earth.data["years"] = Earth.year
Earth.data["seconds per year"].append(seconds)
for city in Earth.world:
city.data["kids"].append(len(city.kids))
city.data["adults"].append(len(city.adults))
city.data["elders"].append(len(city.elders))
city.data["people in the city"].append(len(city))
city.data["families"].append(len(city.families))
city.data["grave"].append(len(city.grave))
city.data["average life"] = average_life_function(city)
city.data["water"].append(round(city.water, 2))
city.data["food"].append(round(city.food, 2))
city.data["wood"].append(round(city.wood, 2))
city.data["ore"].append(round(city.ore, 2))
city.data["metal"].append(round(city.metal, 2))
city.data["stone"].append(round(city.stone, 2))
city.data["buildings"].append(len(city.buildings))
city.data["houses"].append(len(city.houses))
def printing():
global Earth
print(Earth)
print(f"It took {Earth.data['seconds per year'][-1]} seconds "
f"for making {Earth.year} year.")
table = PrettyTable(padding_width=2)
table.add_column("", ["People", "Families", "Elders", "Adults", "Kids", "Corpses",
"Average life", "Water", "Food", "Wood", "Ore", "Metal",
"Stone", "Buildings", "Houses"])
for v in Earth.world:
table.add_column(v.name, [str(v.data["people in the city"][-1]),
str(v.data["families"][-1]),
str(v.data["elders"][-1]),
str(v.data["adults"][-1]),
str(v.data["kids"][-1]),
str(v.data["grave"][-1]),
str(v.data["average life"]),
str(v.data["water"][-1]),
str(v.data["food"][-1]),
str(v.data["wood"][-1]),
str(v.data["ore"][-1]),
str(v.data["metal"][-1]),
str(v.data["stone"][-1]),
str(v.data["buildings"][-1]),
str(v.data["houses"][-1])])
print(table, end="\n\n")
def city_picker_for_more_info(message):
global Earth
names = [rr_rr.name for rr_rr in Earth.world]
print(f"'{message}' Please, choose a city (any register) : {', '.join(names)}")
while True:
city_pick = str(input()).title()
if city_pick == "":
print("You can't pass a space blanked name. Please, try again.")
elif city_pick not in names:
print(f"{city_pick} city doesn't exist. Please, try again.")
else:
index = names.index(city_pick)
return Earth.world[index]
if __name__ == "__main__":
Earth = World("Earth") # creating the World Object with "Earth" name
print(f"The world with the name '{Earth.name}' was created ...\n")
Earth.cities_creator(integer_checker(
question="Please, print how much cities do you want to have."))
looping = False # bool : if False -> press <enter> button for making a new year,
# if True -> passing years depends on loop_ration
loop_ratio = 0 # int : if looping = True, showing how much years computer
# automatically will count
while True:
while looping:
for _ in range(loop_ratio):
start = tm()
Earth.year += 1
Earth.year_maker()
data_collecting_function(tm() - start)
printing()
else:
looping = False
start = tm()
Earth.year += 1
Earth.year_maker()
data_collecting_function(tm() - start)
printing()
flag = True
while flag:
print("Commands: city, kid, adult, elder, "
"family, corpse, history, request, save, exit, (int).")
command = input("Your command ..........................").lower()
if command == "city":
if len(Earth.world) == 1:
city_city = Earth.world[0]
else:
city_city = city_picker_for_more_info("city")
print(city_city)
if command == "kid":
if len(Earth.world) == 1:
kids_from_the_city = Earth.world[0]
else:
kids_from_the_city = city_picker_for_more_info("kid")
for xx_xx in kids_from_the_city.kids:
print(xx_xx)
print()
if command == "adult":
if len(Earth.world) == 1:
adults_from_the_city = Earth.world[0]
else:
adults_from_the_city = city_picker_for_more_info("adult")
for xx_xx in adults_from_the_city.adults:
print(xx_xx)
print()
if command == "elder":
if len(Earth.world) == 1:
elders_from_the_city = Earth.world[0]
else:
elders_from_the_city = city_picker_for_more_info("elder")
for xx_xx in elders_from_the_city.elders:
print(xx_xx)
print()
if command == "family":
if len(Earth.world) == 1:
family_from_the_city = Earth.world[0]
else:
family_from_the_city = city_picker_for_more_info("family")
if len(family_from_the_city.families) > 0:
print("Families : ", end="\n\n")
for ind, fam in family_from_the_city.families.items():
print(f"Family with {ind} index")
print("Parents")
for par in fam["parents"]:
print(par)
if len(fam["children"]) > 0:
print("Children")
for cld in fam["children"]:
print(cld)
print()
if command == "corpse":
if len(Earth.world) == 1:
dead_from_the_city = Earth.world[0]
else:
dead_from_the_city = city_picker_for_more_info("corpse")
if len(dead_from_the_city.grave) > 0:
print("Grave")
for dead_b in dead_from_the_city.grave:
print(dead_b)
print()
if command == "history":
if len(Earth.world) == 1:
the_city_history = Earth.world[0]
else:
the_city_history = city_picker_for_more_info("history")
for h in the_city_history.kids:
print(f"{h.surname} {h.name}, {h.sex}, {h.age}, parent index = "
f"{h.family_parent_index}, family history = "
f"{h.family_history}")
for ooo in (the_city_history.adults, the_city_history.elders):
for o in ooo:
if o.marriage:
print(f"{o.surname} {o.name}, {o.sex}, {o.age}, marriage = "
f"{o.marriage.surname} {o.marriage.name}, "
f"parent index = {o.family_parent_index}, "
f"family history = {o.family_history}")
else:
print(f"{o.surname} {o.name}, {o.sex}, {o.age}, "
f"parent index = {o.family_parent_index}, "
f"family history = {o.family_history}")
print()
if command == "request":
for dd_ss in Earth.world:
print(f"City : {dd_ss.name}\n")
print(f"Queues : \n[{', '.join(map(str, dd_ss.queue))}]")
print(f"Alerts : \n[{', '.join(map(str, dd_ss.alert))}]")
print(f"Non_urgent : \n[{', '.join(map(str, dd_ss.non_urgent))}]")
print(f"Plan : \n[{', '.join(map(str, dd_ss.plan))}]")
print("-" * 103)
if command == "save":
with open("data_for_graph.json", "w") as file:
temporary_dict = {"years": Earth.data["years"],
"seconds per year": Earth.data["seconds per year"]}
for jj_jj in Earth.world:
temporary_dict[jj_jj.name] = jj_jj.data
dump(temporary_dict, file)
if command.isdigit():
looping, loop_ratio, flag = True, int(command), False
if command == "":
flag = False
if command == "exit":
exit()
|
Java | UTF-8 | 1,272 | 3.484375 | 3 | [] | no_license | package org.dimigo.collection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MelonGenreChart {
public static void main(String[] args) {
Map<String,List<Music>> map = new HashMap<>();
System.out.println("-- << ๋ฉ๋ก ์ฅ๋ฅด๋ณ ์ฑ ํธ >> --");
List<Music> list = new ArrayList<Music>();
map.put("๋ฐ๋ผ๋",list);
list.add(new Music("ํ๋ ํธ","์์ด์ "));
list = new ArrayList<>();
map.put("๋์ค", list);
list.add(new Music("I LUV IT","PSY"));
list.add(new Music("๋ง์ง","์ธ๋์ฐ"));
printMap(map);
System.out.println();
System.out.println("-- << ๋์ค 2์ ๊ณก ๋ณ๊ฒฝ >> --");
map.get("๋์ค").set(1, new Music("SIGNAL","ํธ์์ด์ค"));
printMap(map);
System.out.println();
System.out.println("-- << ๋์ค 1์ ๊ณก ์ญ์ >> --");
map.get("๋์ค").remove(0);
printMap(map);
System.out.println();
System.out.println("-- << ์ ์ฒด ๋ฆฌ์คํธ ์ญ์ >> --");
map.clear();
printMap(map);
}
public static void printMap(Map<String, List<Music> > map){
for(String key : map.keySet()){
int i=1;
System.out.println("[" + key + "]");
for(Music m : map.get(key)){
System.out.println(i +". " + m);
i++;
}
}
}
}
|
Markdown | UTF-8 | 1,206 | 2.578125 | 3 | [
"MIT"
] | permissive | # React Native - The Practical Guide
- 02.Diving into the Basics - [rn-basics - Course Goals App](https://github.com/mdamyanova/Udemy-Courses/tree/master/React%20Native%20-%20The%20Practical%20Guide/rn-basics)
- working with Components, Styles, Flexbox and Scrollable view
- 04.Components, Styling, Layouts - [rn-guess-number - Guess the Number App](https://github.com/mdamyanova/Udemy-Courses/tree/master/React%20Native%20-%20The%20Practical%20Guide/rn-guess-number)
- working with basics + Headers, User Input, Alerts, Screens
- 06.Navigation and React Navigation - [rn-meals - The Meals App](https://github.com/mdamyanova/Udemy-Courses/tree/master/React%20Native%20-%20The%20Practical%20Guide/rn-meals)
- working with basics + advanced styling + Navigation + Menu + Redux
- 08.The Shop App - [rn-shop - The Shop App](https://github.com/mdamyanova/Udemy-Courses/tree/master/React%20Native%20-%20The%20Practical%20Guide/rn-shop)
- exercise app + http requests + authentication
- 12.Native Device Features - [rn-places - Places App](https://github.com/mdamyanova/Udemy-Courses/tree/master/React%20Native%20-%20The%20Practical%20Guide/rn-places)
- exercise app + camera + location + maps + SQLite
|
C++ | UTF-8 | 815 | 2.546875 | 3 | [] | no_license | #ifndef __ModuleWindow_H__
#define __ModuleWindow_H__
#include "Module.h"
#include "SDL/include/SDL.h"
#include "Module.h"
#include "Globals.h"
class Application;
class ModuleWindow : public Module
{
public:
//The window we'll be rendering to
SDL_Window * window;
public:
ModuleWindow() {};
~ModuleWindow() {};
// Called before quitting
bool Init() {
LOG("Init SDL window & surface");
bool ret = true;
if (SDL_Init(SDL_INIT_VIDEO) < 0)
{
LOG("SDL_VIDEO could not initialize! SDL_Error: %s\n", SDL_GetError());
ret = false;
}
else {
SDL_Window* window = SDL_CreateWindow("window", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1200, 800, 0);
}
return ret;
}
// Called before quitting
bool CleanUp() {
SDL_DestroyWindow(window);
}
};
#endif // __ModuleWindow_H__ |
Java | UTF-8 | 14,672 | 1.90625 | 2 | [] | no_license | package fr.ippon.kompetitors.web.rest;
import fr.ippon.kompetitors.Kompetitors2App;
import fr.ippon.kompetitors.config.TestSecurityConfiguration;
import fr.ippon.kompetitors.domain.ListTechPartners;
import fr.ippon.kompetitors.repository.ListTechPartnersRepository;
import fr.ippon.kompetitors.service.ListTechPartnersService;
import fr.ippon.kompetitors.service.dto.ListTechPartnersDTO;
import fr.ippon.kompetitors.service.mapper.ListTechPartnersMapper;
import fr.ippon.kompetitors.web.rest.errors.ExceptionTranslator;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.MockitoAnnotations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.web.PageableHandlerMethodArgumentResolver;
import org.springframework.http.MediaType;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Base64Utils;
import org.springframework.validation.Validator;
import javax.persistence.EntityManager;
import java.util.List;
import static fr.ippon.kompetitors.web.rest.TestUtil.createFormattingConversionService;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.hasItem;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
/**
* Integration tests for the {@link ListTechPartnersResource} REST controller.
*/
@SpringBootTest(classes = {Kompetitors2App.class, TestSecurityConfiguration.class})
public class ListTechPartnersResourceIT {
private static final String DEFAULT_VALUE = "AAAAAAAAAA";
private static final String UPDATED_VALUE = "BBBBBBBBBB";
private static final byte[] DEFAULT_IMAGE = TestUtil.createByteArray(1, "0");
private static final byte[] UPDATED_IMAGE = TestUtil.createByteArray(1, "1");
private static final String DEFAULT_IMAGE_CONTENT_TYPE = "image/jpg";
private static final String UPDATED_IMAGE_CONTENT_TYPE = "image/png";
@Autowired
private ListTechPartnersRepository listTechPartnersRepository;
@Autowired
private ListTechPartnersMapper listTechPartnersMapper;
@Autowired
private ListTechPartnersService listTechPartnersService;
@Autowired
private MappingJackson2HttpMessageConverter jacksonMessageConverter;
@Autowired
private PageableHandlerMethodArgumentResolver pageableArgumentResolver;
@Autowired
private ExceptionTranslator exceptionTranslator;
@Autowired
private EntityManager em;
@Autowired
private Validator validator;
private MockMvc restListTechPartnersMockMvc;
private ListTechPartners listTechPartners;
@BeforeEach
public void setup() {
MockitoAnnotations.initMocks(this);
final ListTechPartnersResource listTechPartnersResource = new ListTechPartnersResource(listTechPartnersService);
this.restListTechPartnersMockMvc = MockMvcBuilders.standaloneSetup(listTechPartnersResource)
.setCustomArgumentResolvers(pageableArgumentResolver)
.setControllerAdvice(exceptionTranslator)
.setConversionService(createFormattingConversionService())
.setMessageConverters(jacksonMessageConverter)
.setValidator(validator).build();
}
/**
* Create an entity for this test.
*
* This is a static method, as tests for other entities might also need it,
* if they test an entity which requires the current entity.
*/
public static ListTechPartners createEntity(EntityManager em) {
ListTechPartners listTechPartners = new ListTechPartners()
.value(DEFAULT_VALUE)
.image(DEFAULT_IMAGE)
.imageContentType(DEFAULT_IMAGE_CONTENT_TYPE);
return listTechPartners;
}
/**
* Create an updated entity for this test.
*
* This is a static method, as tests for other entities might also need it,
* if they test an entity which requires the current entity.
*/
public static ListTechPartners createUpdatedEntity(EntityManager em) {
ListTechPartners listTechPartners = new ListTechPartners()
.value(UPDATED_VALUE)
.image(UPDATED_IMAGE)
.imageContentType(UPDATED_IMAGE_CONTENT_TYPE);
return listTechPartners;
}
@BeforeEach
public void initTest() {
listTechPartners = createEntity(em);
}
@Test
@Transactional
public void createListTechPartners() throws Exception {
int databaseSizeBeforeCreate = listTechPartnersRepository.findAll().size();
// Create the ListTechPartners
ListTechPartnersDTO listTechPartnersDTO = listTechPartnersMapper.toDto(listTechPartners);
restListTechPartnersMockMvc.perform(post("/api/list-tech-partners")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(listTechPartnersDTO)))
.andExpect(status().isCreated());
// Validate the ListTechPartners in the database
List<ListTechPartners> listTechPartnersList = listTechPartnersRepository.findAll();
assertThat(listTechPartnersList).hasSize(databaseSizeBeforeCreate + 1);
ListTechPartners testListTechPartners = listTechPartnersList.get(listTechPartnersList.size() - 1);
assertThat(testListTechPartners.getValue()).isEqualTo(DEFAULT_VALUE);
assertThat(testListTechPartners.getImage()).isEqualTo(DEFAULT_IMAGE);
assertThat(testListTechPartners.getImageContentType()).isEqualTo(DEFAULT_IMAGE_CONTENT_TYPE);
}
@Test
@Transactional
public void createListTechPartnersWithExistingId() throws Exception {
int databaseSizeBeforeCreate = listTechPartnersRepository.findAll().size();
// Create the ListTechPartners with an existing ID
listTechPartners.setId(1L);
ListTechPartnersDTO listTechPartnersDTO = listTechPartnersMapper.toDto(listTechPartners);
// An entity with an existing ID cannot be created, so this API call must fail
restListTechPartnersMockMvc.perform(post("/api/list-tech-partners")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(listTechPartnersDTO)))
.andExpect(status().isBadRequest());
// Validate the ListTechPartners in the database
List<ListTechPartners> listTechPartnersList = listTechPartnersRepository.findAll();
assertThat(listTechPartnersList).hasSize(databaseSizeBeforeCreate);
}
@Test
@Transactional
public void checkValueIsRequired() throws Exception {
int databaseSizeBeforeTest = listTechPartnersRepository.findAll().size();
// set the field null
listTechPartners.setValue(null);
// Create the ListTechPartners, which fails.
ListTechPartnersDTO listTechPartnersDTO = listTechPartnersMapper.toDto(listTechPartners);
restListTechPartnersMockMvc.perform(post("/api/list-tech-partners")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(listTechPartnersDTO)))
.andExpect(status().isBadRequest());
List<ListTechPartners> listTechPartnersList = listTechPartnersRepository.findAll();
assertThat(listTechPartnersList).hasSize(databaseSizeBeforeTest);
}
@Test
@Transactional
public void getAllListTechPartners() throws Exception {
// Initialize the database
listTechPartnersRepository.saveAndFlush(listTechPartners);
// Get all the listTechPartnersList
restListTechPartnersMockMvc.perform(get("/api/list-tech-partners?sort=id,desc"))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.[*].id").value(hasItem(listTechPartners.getId().intValue())))
.andExpect(jsonPath("$.[*].value").value(hasItem(DEFAULT_VALUE)))
.andExpect(jsonPath("$.[*].imageContentType").value(hasItem(DEFAULT_IMAGE_CONTENT_TYPE)))
.andExpect(jsonPath("$.[*].image").value(hasItem(Base64Utils.encodeToString(DEFAULT_IMAGE))));
}
@Test
@Transactional
public void getListTechPartners() throws Exception {
// Initialize the database
listTechPartnersRepository.saveAndFlush(listTechPartners);
// Get the listTechPartners
restListTechPartnersMockMvc.perform(get("/api/list-tech-partners/{id}", listTechPartners.getId()))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.id").value(listTechPartners.getId().intValue()))
.andExpect(jsonPath("$.value").value(DEFAULT_VALUE))
.andExpect(jsonPath("$.imageContentType").value(DEFAULT_IMAGE_CONTENT_TYPE))
.andExpect(jsonPath("$.image").value(Base64Utils.encodeToString(DEFAULT_IMAGE)));
}
@Test
@Transactional
public void getNonExistingListTechPartners() throws Exception {
// Get the listTechPartners
restListTechPartnersMockMvc.perform(get("/api/list-tech-partners/{id}", Long.MAX_VALUE))
.andExpect(status().isNotFound());
}
@Test
@Transactional
public void updateListTechPartners() throws Exception {
// Initialize the database
listTechPartnersRepository.saveAndFlush(listTechPartners);
int databaseSizeBeforeUpdate = listTechPartnersRepository.findAll().size();
// Update the listTechPartners
ListTechPartners updatedListTechPartners = listTechPartnersRepository.findById(listTechPartners.getId()).get();
// Disconnect from session so that the updates on updatedListTechPartners are not directly saved in db
em.detach(updatedListTechPartners);
updatedListTechPartners
.value(UPDATED_VALUE)
.image(UPDATED_IMAGE)
.imageContentType(UPDATED_IMAGE_CONTENT_TYPE);
ListTechPartnersDTO listTechPartnersDTO = listTechPartnersMapper.toDto(updatedListTechPartners);
restListTechPartnersMockMvc.perform(put("/api/list-tech-partners")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(listTechPartnersDTO)))
.andExpect(status().isOk());
// Validate the ListTechPartners in the database
List<ListTechPartners> listTechPartnersList = listTechPartnersRepository.findAll();
assertThat(listTechPartnersList).hasSize(databaseSizeBeforeUpdate);
ListTechPartners testListTechPartners = listTechPartnersList.get(listTechPartnersList.size() - 1);
assertThat(testListTechPartners.getValue()).isEqualTo(UPDATED_VALUE);
assertThat(testListTechPartners.getImage()).isEqualTo(UPDATED_IMAGE);
assertThat(testListTechPartners.getImageContentType()).isEqualTo(UPDATED_IMAGE_CONTENT_TYPE);
}
@Test
@Transactional
public void updateNonExistingListTechPartners() throws Exception {
int databaseSizeBeforeUpdate = listTechPartnersRepository.findAll().size();
// Create the ListTechPartners
ListTechPartnersDTO listTechPartnersDTO = listTechPartnersMapper.toDto(listTechPartners);
// If the entity doesn't have an ID, it will throw BadRequestAlertException
restListTechPartnersMockMvc.perform(put("/api/list-tech-partners")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(listTechPartnersDTO)))
.andExpect(status().isBadRequest());
// Validate the ListTechPartners in the database
List<ListTechPartners> listTechPartnersList = listTechPartnersRepository.findAll();
assertThat(listTechPartnersList).hasSize(databaseSizeBeforeUpdate);
}
@Test
@Transactional
public void deleteListTechPartners() throws Exception {
// Initialize the database
listTechPartnersRepository.saveAndFlush(listTechPartners);
int databaseSizeBeforeDelete = listTechPartnersRepository.findAll().size();
// Delete the listTechPartners
restListTechPartnersMockMvc.perform(delete("/api/list-tech-partners/{id}", listTechPartners.getId())
.accept(TestUtil.APPLICATION_JSON_UTF8))
.andExpect(status().isNoContent());
// Validate the database contains one less item
List<ListTechPartners> listTechPartnersList = listTechPartnersRepository.findAll();
assertThat(listTechPartnersList).hasSize(databaseSizeBeforeDelete - 1);
}
@Test
@Transactional
public void equalsVerifier() throws Exception {
TestUtil.equalsVerifier(ListTechPartners.class);
ListTechPartners listTechPartners1 = new ListTechPartners();
listTechPartners1.setId(1L);
ListTechPartners listTechPartners2 = new ListTechPartners();
listTechPartners2.setId(listTechPartners1.getId());
assertThat(listTechPartners1).isEqualTo(listTechPartners2);
listTechPartners2.setId(2L);
assertThat(listTechPartners1).isNotEqualTo(listTechPartners2);
listTechPartners1.setId(null);
assertThat(listTechPartners1).isNotEqualTo(listTechPartners2);
}
@Test
@Transactional
public void dtoEqualsVerifier() throws Exception {
TestUtil.equalsVerifier(ListTechPartnersDTO.class);
ListTechPartnersDTO listTechPartnersDTO1 = new ListTechPartnersDTO();
listTechPartnersDTO1.setId(1L);
ListTechPartnersDTO listTechPartnersDTO2 = new ListTechPartnersDTO();
assertThat(listTechPartnersDTO1).isNotEqualTo(listTechPartnersDTO2);
listTechPartnersDTO2.setId(listTechPartnersDTO1.getId());
assertThat(listTechPartnersDTO1).isEqualTo(listTechPartnersDTO2);
listTechPartnersDTO2.setId(2L);
assertThat(listTechPartnersDTO1).isNotEqualTo(listTechPartnersDTO2);
listTechPartnersDTO1.setId(null);
assertThat(listTechPartnersDTO1).isNotEqualTo(listTechPartnersDTO2);
}
@Test
@Transactional
public void testEntityFromId() {
assertThat(listTechPartnersMapper.fromId(42L).getId()).isEqualTo(42);
assertThat(listTechPartnersMapper.fromId(null)).isNull();
}
}
|
Python | UTF-8 | 1,862 | 2.859375 | 3 | [] | no_license | #!/usr/bin/python
# -*- coding: utf-8 -*-
import pickle
import networkx as nx
import matplotlib.pyplot as plt
FILENAME = "graph_properties_nobel_ger_demand_ger_uniform_Link_Disjoint.pkl"
G = nx.Graph()
def add_proprieties(protection_distance, demands, working_distance):
for key in protection_distance.keys():
G.add_edge(key[0], key[1],
protection_distance=protection_distance.get(key),
demand=demands.get(key),
working_distance = working_distance.get(key))
G[key[0]][key[1]]['color']='grey'
def add_working_paths(obj):
for key in obj.keys():
print(key[0], key[1])
for key_inner in obj.get(key):
G.add_edge(key_inner[0], key_inner[1], type='working_path', connection=key)
G[key_inner[0]][key_inner[1]]['color']='blue'
def add_protection_path(obj):
for key in obj.keys():
print(key[0], key[1])
for key_inner in obj.get(key):
G.add_edge(key_inner[0], key_inner[1], type='protection_path', connection=key)
G[key_inner[0]][key_inner[1]]['color']='red'
with open(FILENAME, 'rb') as f:
# The protocol version used is detected automatically, so we do not
# have to specify it.
data = pickle.load(f)
protection_distance = data["protection_distance"]
demands = data["demands"]
working_distance = data["working_distance"]
add_proprieties(protection_distance, demands, working_distance)
working_paths = data["working_paths"]
add_working_paths(working_paths)
protection_path = data["protection_path"]
add_protection_path(protection_path)
print(data)
edges = G.edges()
colors = []
for (u,v,attrib_dict) in list(G.edges.data()):
colors.append(attrib_dict['color'])
nx.draw(G, with_labels=True, edges=edges, edge_color=colors)
plt.show()
|
C# | UTF-8 | 4,573 | 2.546875 | 3 | [
"MIT"
] | permissive | ๏ปฟ
using Newtonsoft.Json;
using Open.Genersoft.Component.Logging.Facade;
using System;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Threading;
using System.Xml;
using System.Reflection;
namespace Open.Genersoft.Component.Logging.Default
{
public class DefaultLogger : GeneralLogger
{
private readonly object lockObj = new object();
private StreamWriter writer;
private readonly string processName;
private string currentFile = "";
private int num = 0;
public DefaultLogger()
{
DatePattern = "yyyy-MM-dd";
processName = Process.GetCurrentProcess().ProcessName;
}
public override void Debug(params string[] text)
{
if (Level > LogLevel.DEBUG) return;
Print(LogLevel.DEBUG, text);
}
public override void Error(string text, Exception ex = null)
{
if (Level > LogLevel.ERROR) return;
if (ex != null)
Print(LogLevel.ERROR, text, ex.Message, ex.StackTrace);
else
Print(LogLevel.ERROR, text);
}
public override void Info(params string[] text)
{
if (Level > LogLevel.INFO) return;
Print(LogLevel.INFO, text);
}
public override void Warn(params string[] text)
{
if (Level > LogLevel.WARN) return;
Print(LogLevel.WARN, text);
}
private void Print(LogLevel level, params string[] text)
{
if (Level == LogLevel.OFF) return;
StringBuilder sb = new StringBuilder(256);
StackTrace st;
StackFrame sf;
MethodBase method = null;
int line = 0;
string className = "";
if (level == LogLevel.TRACE)
{
st = new StackTrace(true);
sf = st.GetFrame(2);
method = sf.GetMethod();
line = sf.GetFileLineNumber();
className = method.DeclaringType.FullName;
}
foreach (var s in text)
{
sb.Append(s);
sb.Append(Environment.NewLine);
}
try
{
CreatePathIfNotExists();
bool token = false;
while(!token)
Monitor.TryEnter(lockObj, 100, ref token);
if (token)
{
string date = DateTime.Now.ToString(DatePattern);
if(!currentFile.Contains(date))
{
num = 0;
currentFile = Path + $"{Name}-Log{date}-part{num}.txt";
}
else
{
SliceFileIfSpill(date);
}
using (writer = new StreamWriter(currentFile, true, Encoding.Default))
{
string time = DateTime.Now.ToString(TimePattern);
writer.AutoFlush = false;
writer.WriteLine(time + $":ใ{ levelDict[level]}ใ");
if(level == LogLevel.FATAL)
{
writer.WriteLine("ใ็ณป็ป้่ฏฏใ๏ผ" + text[0]);
}
if(level == LogLevel.TRACE)
{
writer.WriteLine("ใ่ฟ็จใ๏ผ" + processName);
writer.WriteLine("ใ็บฟ็จIDใ๏ผ" + Thread.CurrentThread.ManagedThreadId);
writer.WriteLine("ใ็ฑปๅใ๏ผ" + className);
writer.WriteLine("ใๆนๆณๅใ๏ผ" + method.Name);
writer.WriteLine("ใ่กๅทใ๏ผ" + line);
}
writer.WriteLine("ใไฟกๆฏใ๏ผ" + sb);
writer.Flush();
}
Monitor.Exit(lockObj);
}
}
catch (Exception) {}
}
public override void PrintObject(object obj)
{
Print(Level, JsonConvert.SerializeObject(obj, Newtonsoft.Json.Formatting.Indented));
}
/// <summary>
/// xmlๆๅฐ
/// </summary>
/// <param name="desc"></param>
/// <param name="doc"></param>
public override void PrintXml(string desc, string xmlStr)
{
XmlDocument doc = new XmlDocument();
doc.LoadXml(xmlStr);
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
using (XmlTextWriter writer = new XmlTextWriter(sw))
{
writer.Indentation = 4; // ็ผฉ่ฟไธชๆฐ
writer.IndentChar = ' '; // ็ผฉ่ฟๅญ็ฌฆ
writer.Formatting = System.Xml.Formatting.Indented;
doc.WriteTo(writer);
}
Print(Level, desc, sb.ToString());
}
private void CreatePathIfNotExists()
{
if (!Directory.Exists(Path))
{
Directory.CreateDirectory(Path);
}
}
private void SliceFileIfSpill(string date)
{
if (File.Exists(currentFile))
{
FileInfo info = new FileInfo(currentFile);
if (info.Length > Slice * 1024 * 1024)
{
num++;
currentFile = Path + $"{Name}-Log{date}-part{num}.txt";
}
}
}
public override void Fatal(string text, Exception ex = null)
{
if (Level > LogLevel.FATAL) return;
if (ex != null)
Print(LogLevel.FATAL, text, ex.Message, ex.StackTrace);
else
Print(LogLevel.FATAL, text);
}
public override void Trace(params string[] text)
{
if (Level > LogLevel.TRACE) return;
Print(LogLevel.TRACE, text);
}
}
}
|
Markdown | UTF-8 | 3,489 | 3.1875 | 3 | [] | no_license |
# First Timers Contributions
Make sure you have Git installed, If you don't have git on your machine, [install it]( https://help.github.com/articles/set-up-git/).
## Fork this repository
<img align="right" width="300" src="./assets/image/fork.JPG" alt="fork this repository" />
Fork this repo by clicking on the fork button on the top of this page.
This will create a copy of this repository in your account.
## Clone the repository
<img align="right" width="300" src="./assets/image/clone.JPG" alt="clone this repository" />
Now clone the forked repo to your machine. Go to your GitHub account, open the forked repo, click on the clone button and then click the *copy to clipboard* icon.
Open a terminal and run the following git command:
```
git clone "url you just copied"
```
where "url you just copied" (without the quote marks) is the url to this repository (your fork of this project). See the previous steps to obtain the url.
<img align="right" width="300" src="./assets/image/clipboard.JPG" alt="copy URL to clipboard" />
For example:
```
git clone https://github.com/this-is-you/starter-project.git
```
where `this-is-you` is your GitHub username. Here you're copying the contents of the starter-project repository in GitHub to your computer.
## Create a branch
Change to the repository directory on your computer (if you are not already there):
```
cd starter-project
```
Now create a branch using the `git checkout` command:
```
git checkout -b <add-your-new-branch-name>
```
For example:
```
git checkout -b add-my-profile
```
(The name of the branch does not need to have the word *add* in it, but it's a reasonable thing to include because the purpose of this branch is to add your profile to a list.)
## Make necessary changes and commit those changes
Now open `person.json` file in a text editor, add your name, image, and reason why you code to it. in the below format inside the square
brackets [] and save your changes.
```
{
"firstname": "Your firstname here",
"lastname": "Your lastname here",
"image": "/starter_project/assets/image/<your_image_name.ext>",
"word": "Reason why you learn to code"
},
```
Now, save the file.
<img align="right" width="450" src="./assets/image/status.JPG" alt="git status" />
If you go to the project directory and execute the command `git status`, you'll see there are changes.
Add those changes to the branch you just created using the `git add` command:
```
git add person.json
```
Now commit those changes using the `git commit` command:
```
git commit -m "Add my profile to the list"
```
## Push changes to GitHub
Push your changes using the command `git push`:
```
git push origin <add-your-branch-name>
```
replacing `<add-your-branch-name>` with the name of the branch you created earlier.
## Submit your changes for review
If you go to your repository on GitHub, you'll see a `Compare & pull request` button. Click on that button.
<img style="float: right;" src="./assets/image/compare-and-pull.JPG" alt="create a pull request" />
Now submit the pull request.
<img style="float: right;" src="./assets/image/submit-pull-request.JPG" alt="submit pull request" />
Soon I'll be merging all your changes into the master branch of this project. You will get a notification email once the changes have been merged.
## Where to go from here?
Congrats! You just completed the standard _fork -> clone -> edit -> PR_ workflow that you'll encounter often as a contributor!
|
C# | UTF-8 | 890 | 2.75 | 3 | [] | no_license | using System.Collections.Generic;
using System.Linq;
using Ecommerce.Dto;
using Ecommerce.UnitOfWork;
namespace Ecommerce.Service.Services
{
public class ProductService : IProductService
{
private readonly IUnitOfWork _uow;
public ProductService(IUnitOfWork uow)
{
_uow = uow;
}
public ServiceResponse<List<ProductDto>> GetAll()
{
var products = _uow.ProductRepository.FindAll().Select(x => new ProductDto
{
ProductId = x.ProductId,
Code = x.Code,
Name = x.Name,
Price = x.Price
}).ToList();
return new ServiceResponse<List<ProductDto>>
{
Success = true,
Message = "Products listed successfully.",
Data = products
};
}
}
} |
Java | UTF-8 | 4,311 | 2.203125 | 2 | [] | no_license | package com.jss.educenter.controller;
import com.google.gson.Gson;
import com.jss.commonutils.JwtUtils;
import com.jss.educenter.entity.UcenterMember;
import com.jss.educenter.service.UcenterMemberService;
import com.jss.educenter.utils.ConstantWxUtils;
import com.jss.educenter.utils.HttpClientUtils;
import com.jss.servicebase.exceptionhandler.CollegeException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import java.net.URLEncoder;
import java.util.HashMap;
@Controller
@RequestMapping("/api/ucenter/wx")
@CrossOrigin
public class WxApiController {
@Autowired
private UcenterMemberService service;
@GetMapping("callback")
public String callback(String code,String state){
//ๆผๆฅๅฐๅ
String baseAccessTokenUrl = "https://api.weixin.qq.com/sns/oauth2/access_token" +
"?appid=%s" +
"&secret=%s" +
"&code=%s" +
"&grant_type=authorization_code";
String accessTokenUrl = String.format(
baseAccessTokenUrl,
ConstantWxUtils.WX_OPEN_APP_ID,
ConstantWxUtils.WX_OPEN_APP_SECRET,
code
);
try{
//ๆฟ็codeๅป่ทๅacess_token && openid
String accessTokenInfo = HttpClientUtils.get(accessTokenUrl); //ๅญ็ฌฆไธฒ
//System.out.println("======="+accessTokenInfo);
//ๅฐaccessTokenInfo่ฝฌๆขๆmap,ๆ นๆฎmap็key่ทๅพๅผ
Gson gson = new Gson();
HashMap mapToken = gson.fromJson(accessTokenInfo, HashMap.class);
String accessToken = (String)mapToken.get("access_token");
String openid = (String)mapToken.get("openid");
//ๅคๆญๆฐๆฎๅบไธญๆฏๅฆๅญๅจ็ธๅ็ๅพฎไฟก
UcenterMember member = service.getOpenIdMember(openid);
if(member == null){
//ๆ นๆฎaccess_token && openid ่ฎฟ้ฎๅพฎไฟก็่ตๆบๆๅกๅจ๏ผ่ทๅ็จๆทไฟกๆฏ
String baseUserInfoUrl = "https://api.weixin.qq.com/sns/userinfo" +
"?access_token=%s" +
"&openid=%s";
String urlInfoUrl = String.format(
baseUserInfoUrl,
accessToken,
openid);
//ๅ้่ฏทๆฑ
String userInfo = HttpClientUtils.get(urlInfoUrl);
//System.out.println("********"+userInfo);
//่ทๅ่ฟๅๅ็ๆซ็ ไบบไฟกๆฏ
HashMap userMap = gson.fromJson(userInfo, HashMap.class);
String nickname = (String) userMap.get("nickname");
String headimgurl = (String) userMap.get("headimgurl");
member = new UcenterMember();
member.setOpenid(openid);
member.setNickname(nickname);
member.setAvatar(headimgurl);
service.save(member);
}
//็ๆtoken
String token = JwtUtils.getJwtToken(member.getId(), member.getNickname());
return "redirect:http://localhost:3000?token="+token;
}catch (Exception e){
e.printStackTrace();
throw new CollegeException(20001,"ๅพฎไฟก็ปๅฝๅคฑ่ดฅ");
}
}
@GetMapping("login")
public String getWxCode(){
String baseUrl = "https://open.weixin.qq.com/connect/qrconnect" +
"?appid=%s" +
"&redirect_uri=%s" +
"&response_type=code" +
"&scope=snsapi_login" +
"&state=%s" +
"#wechat_redirect";
//ๅฏนredirect_url่ฟ่ก็ผ็
String redirectUrl = ConstantWxUtils.WX_OPEN_REDIRECT_URL;
try{
redirectUrl = URLEncoder.encode(redirectUrl,"utf-8");
}catch (Exception e){
e.printStackTrace();
System.out.println("็ผ็ ้่ฏฏ");
}
String url = String.format(
baseUrl,
ConstantWxUtils.WX_OPEN_APP_ID,
redirectUrl,
"atguigu"
);
return "redirect:"+url;
}
}
|
Java | UTF-8 | 3,196 | 2.953125 | 3 | [] | no_license | package edu.gatech.virtual_pet_app;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class EventHandler
{
List<REvent> events;
List<Interaction> inter;
List<Illness> illness;
public EventHandler(List<REvent> events, List<Interaction> interaction, List<Illness> illness)
{
this.events = events;
this.inter = interaction;
this.illness = illness;
}
public REvent getRandomEvent(Pet pet)
{
Random rand = new Random();
List <REvent> array = new ArrayList<REvent>();
int avgHunger=0;
int hunHit = 0;
int count = 0;
int moodHit = 0;
int hapHit = 0;
int total = 0;
calcMood(pet);
for (Interaction s : inter)
{
if(s.getPostHunger() > 0)
{
avgHunger = avgHunger + s.getPostHap();
count++;
}
}
avgHunger = avgHunger/count;
if(avgHunger > 60 || avgHunger < 40)
{
hunHit = 20;
}
else if(avgHunger > 70 || avgHunger < 30)
{
hunHit = 40;
}
else
{
hunHit = 0;
}
if(pet.getMood() == Pet.Mood.AGRESSIVE)
{
moodHit = 40;
}
else if(pet.getMood() == Pet.Mood.DEPRESSED)
{
moodHit = 30;
}
else if(pet.getMood() == Pet.Mood.CONTENT)
{
moodHit = 20;
}
else
{
moodHit = 10;
}
if(pet.getHappiness() < 40)
{
hapHit = 20;
}
else if(pet.getHappiness() < 60)
{
hapHit = 15;
}
else if (pet.getHappiness() < 75)
{
hapHit = 10;
}
else
{
hapHit = 0;
}
total = hapHit + hunHit + moodHit;
int number = 0;
if(rand.nextInt(100) > total)
{
for(REvent e: events)
{
if((e.getHappiness() > 0 || e.getHealth() > 0 || e.getHunger() > 0) || (e.getItem() != null))
{
array.add(e);
number++;
}
}
}
else
{
for(REvent e: events)
{
if((e.getHappiness() > 0 || e.getHealth() > 0 || e.getHunger() > 0) || (e.getItem() != null))
{}
else
{
array.add(e);
number++;
}
}
}
return array.get((rand.nextInt(number)));
}
public void calcMood(Pet pet)
{
int count = 0;
int hap = 0;
for (Interaction s : inter)
{
if(s.getPostHap() > 0)
{
hap = hap + s.getPostHap();
count++;
}
}
if((hap/count) > 75)
{
pet.setMood(Pet.Mood.FRIENDLY);
}
else if((hap/count) > 60)
{
pet.setMood(Pet.Mood.CONTENT);
}
else if((hap/count) > 40)
{
pet.setMood(Pet.Mood.DEPRESSED);
}
else
{
pet.setMood(Pet.Mood.AGRESSIVE);
}
}
public int changeWeight(Pet pet)
{
int count = 0;
int hun = 0;
int avgHunger = 0;
for (Interaction s : inter)
{
if(s.getPostHunger() > 0)
{
hun = hun + s.getPostHunger();
count++;
}
}
avgHunger = hun/count;
if(avgHunger > 50)
{
pet.setWeight(pet.getWeight() + (int)(((avgHunger-50)/10)));
}
else
{
pet.setWeight(pet.getWeight() - (int)(((avgHunger)/10)));
}
if(pet.getWeight() < 0)
{
pet.setWeight(1);
}
//if weight > x obesity given time
//if weight < x mal-nutrition
return pet.getWeight();
}
}
|
Java | UTF-8 | 2,601 | 2.1875 | 2 | [
"Apache-2.0"
] | permissive | package com.hs.mail.imap.processor.ext;
import javax.security.auth.login.AccountNotFoundException;
import com.hs.mail.exception.MailboxException;
import com.hs.mail.exception.MailboxNotFoundException;
import com.hs.mail.imap.ImapConstants;
import com.hs.mail.imap.ImapSession;
import com.hs.mail.imap.mailbox.Mailbox;
import com.hs.mail.imap.mailbox.MailboxManager;
import com.hs.mail.imap.mailbox.MailboxPath;
import com.hs.mail.imap.message.request.AbstractMailboxRequest;
import com.hs.mail.imap.message.response.HumanReadableText;
import com.hs.mail.imap.processor.AbstractImapProcessor;
import com.hs.mail.imap.user.UserManager;
/**
*
* @author Wonchul Doh
* @since December 4, 2016
*
*/
public abstract class AbstractACLProcessor extends AbstractImapProcessor {
protected static final String ACL_ANYONE_RIGHTS = "acl_anyone_rights";
protected static final String ACL_OWNER_RIGHTS = "acl_owner_rights";
protected static final String ACL_OTHER_RIGHTS = "acl_other_rights";
protected long getUserID(String identifier) throws AccountNotFoundException {
if (ImapConstants.ANYONE.equals(identifier)) {
return ImapConstants.ANYONE_ID;
}
UserManager manager = getUserManager();
String address = manager.rewriteAddress(identifier);
long userid = manager.getUserID(address);
if (userid == 0) {
throw new AccountNotFoundException("Account for " + identifier + " not found");
}
return userid;
}
protected Mailbox getAuthorizedMailbox(ImapSession session,
AbstractMailboxRequest request) throws MailboxException {
MailboxPath path = buildMailboxPath(session, request.getMailbox());
MailboxManager manager = getMailboxManager();
Mailbox mailbox = manager.getMailbox(path.getUserID(),
path.getFullName());
if (mailbox == null) {
throw new MailboxNotFoundException(
HumanReadableText.MAILBOX_NOT_FOUND);
}
String rights = manager.getRights(session.getUserID(),
mailbox.getMailboxID(), true);
/*
* RFC 4314 section 6.
* An implementation MUST make sure the ACL commands themselves do
* not give information about mailboxes with appropriately
* restricted ACLs.
*/
if (rights.indexOf('l') == -1) {
throw new MailboxNotFoundException(
HumanReadableText.MAILBOX_NOT_FOUND);
}
/*
* RFC 4314 section 4.
* Rights required to perform SETACL/DEETEACL/GETACL/LISTRIGHTS
* commands.
*/
else if (rights.indexOf('a') == -1) {
throw new MailboxException(HumanReadableText.INSUFFICIENT_RIGHTS);
}
return mailbox;
}
}
|
Java | UTF-8 | 3,318 | 2.390625 | 2 | [
"Apache-2.0"
] | permissive | package com.example.android.sunshine.app;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.support.v4.view.accessibility.AccessibilityManagerCompat;
import android.util.AttributeSet;
import android.view.View;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityManager;
public class CompassView extends View {
private int mMyHeight;
private int mMyWidth;
private float mDirection;
private Paint mOuterRing;
private Paint mInnerRing;
private Paint mArrow;
public CompassView(Context context) {
super(context);
init();
}
public CompassView(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public CompassView(Context context, AttributeSet attrs, int defaultStyle) {
super(context, attrs, defaultStyle);
init();
}
private void init() {
mOuterRing = new Paint(Paint.ANTI_ALIAS_FLAG);
mOuterRing.setStyle(Paint.Style.FILL);
mOuterRing.setColor(getResources().getColor(R.color.sunshine_dark_blue));
mInnerRing = new Paint(Paint.ANTI_ALIAS_FLAG);
mInnerRing.setStyle(Paint.Style.FILL);
mInnerRing.setColor(getResources().getColor(R.color.sunshine_blue));
mArrow = new Paint(Paint.ANTI_ALIAS_FLAG);
mArrow.setStyle(Paint.Style.FILL_AND_STROKE);
mArrow.setColor(getResources().getColor(android.R.color.white));
mArrow.setStrokeWidth(5f);
sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_TEXT_CHANGED);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
int hSpecMode = MeasureSpec.getMode(heightMeasureSpec);
int hSpecSize = MeasureSpec.getSize(heightMeasureSpec);
mMyHeight = hSpecSize;
int wSpecMode = MeasureSpec.getMode(widthMeasureSpec);
int wSpecSize = MeasureSpec.getSize(widthMeasureSpec);
mMyWidth = wSpecSize;
if (hSpecMode == MeasureSpec.EXACTLY) {
} else if (hSpecMode == MeasureSpec.AT_MOST) {
} else if (hSpecMode == MeasureSpec.UNSPECIFIED) {
}
if (wSpecMode == MeasureSpec.EXACTLY) {
} else if (wSpecMode == MeasureSpec.AT_MOST) {
} else if (wSpecMode == MeasureSpec.UNSPECIFIED) {
}
setMeasuredDimension(mMyWidth, mMyHeight);
}
@Override
protected void onDraw(Canvas canvas) {
float cx = mMyHeight/2;
float cy = mMyWidth/2;
float outerRadius = mMyHeight/2;
float innerRadius = mMyHeight/2 * 0.9f;
canvas.drawCircle(cx, cy, outerRadius, mOuterRing);
canvas.drawCircle(cx, cy, innerRadius, mInnerRing);
canvas.drawLine(
cx,
cy,
(float)(cx + innerRadius * Math.sin(Math.toRadians(mDirection))),
(float)(cy - innerRadius * Math.cos(Math.toRadians(mDirection))),
mArrow);
}
public void setDirection(float dir) {
mDirection = dir;
invalidate();
}
@Override
public boolean dispatchPopulateAccessibilityEvent(AccessibilityEvent event) {
event.getText().add(String.valueOf(mDirection));
return true;
}
}
|
C | UTF-8 | 7,060 | 3.3125 | 3 | [] | no_license | #include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <wait.h>
#include <pthread.h>
int item_to_produce; //ํ์ฌ ๋ง๋ค์ด์ผํ๋ ์์ดํ
๋ด๋ ๋ณ์
int curr_buf_size; //ํ์ฌ ๋ฒํผ์ ์๋ ํฌ๊ธฐ
int total_items; //์์ฐํ๊ณ ์ถ์ ์ด ์์ดํ
์ (0~M-1)
int consumed_item_size; //์๋นํ ์์ดํ
์
int max_buf_size; //๋ฒํผ ์ต๋ ํฌ๊ธฐ
int num_workers; //์์ปค ์ค๋ ๋์ ์
int num_masters; //๋ง์คํฐ ์ค๋ ๋์ ์
int num_cur_workers; //ํ์ฌ ๋๊ณ ์๋ ์์ปค ์ค๋ ๋์ ์
int num_cur_masters; //ํ์ฌ ๋๊ณ ์๋ ๋ง์คํฐ ์ค๋ ๋์ ์
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; //๋ฝ ๊ฑธ๊ธฐ ์ํ mutex๋ณ์ ์์ฑ
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //์ฐ๋ ๋ ์กฐ๊ฑด๋ณ์ ์์ฑ
int *buffer; //๋ฒํผ(๋ฐฐ์ด)
void print_produced(int num, int master) { //์์ฐ๋์๋ค๋๊ฑธ ์ถ๋ ฅํ๋ ํจ์
printf("Produced %d by master %d\n", num, master);
}
void print_consumed(int num, int worker) { //์๋น๋์๋ค๋๊ฑธ ์ถ๋ ฅํ๋ ํจ์
printf("Consumed %d by worker %d\n", num, worker);
}
//์์ดํ
๋ฒํผ์ ์์ฑํ๋ ๋ง์คํฐ ์ฐ๋ ๋๊ฐ ๋๋ฆฌ๋ ํจ์
void *generate_requests_loop(void *data)
{
int thread_id = *((int *)data); //์ธ์๋ก ๋ฐ์ ๋ฐ์ดํฐ ์ ์ํ์ผ๋ก ํ์
๋ณํ
while(1) //๋ฌดํ ๋ฐ๋ณต
{
pthread_mutex_lock(&mutex); //๋ฝ๊ฑธ๊ธฐ
if(item_to_produce >= total_items) { //ํ์ฌ ๋ง๋ค์ด์ผํ๋ ๋ณ์๊ฐ ๋ฒ์ ๋ฒ์ด๋ ๊ฒฝ์ฐ
num_cur_masters--;
pthread_cond_signal(&cond); //์๊ทธ๋ ๋ณด๋ด๊ธฐ
pthread_mutex_unlock(&mutex); //๋ฝ ํ๊ธฐ
break; //๋ฌดํ ๋ฐ๋ณต ํ์ถ
}
if(curr_buf_size > max_buf_size){ //์ต๋ ๋ฒํผ ์ฌ์ด์ฆ๋ฅผ ๋์ด์ฐ์ ๊ฒฝ์ฐ
pthread_cond_signal(&cond); //์๊ทธ๋ ๋ณด๋ด๊ธฐ
if(num_cur_masters > 1)
pthread_cond_wait(&cond, &mutex); //์๊ทธ๋ ๊ธฐ๋ค๋ฆฌ๊ธฐ
pthread_mutex_unlock(&mutex); //๋ฝ ํ๊ธฐ
continue;
}
buffer[curr_buf_size++] = item_to_produce; //๋ฒํผ์ ์์ดํ
๋ฃ์ด์ฃผ๊ณ curr_buf_size ์ฆ๊ฐ
print_produced(item_to_produce, thread_id); //์์ฐํ ์์ดํ
์ธ์๋ก ๋ฃ์ด์ค ์ฐ๋ ๋ id์ ํจ๊ป ์ถ๋ ฅ
item_to_produce++; //์์ฐํด์ผํ๋ ์์ดํ
์ฌ์ง์
pthread_cond_signal(&cond); //์๊ทธ๋ ๋ณด๋ด๊ธฐ
if(num_cur_masters > 1)
pthread_cond_wait(&cond, &mutex); //์๊ทธ๋ ๊ธฐ๋ค๋ฆฌ๊ธฐ
pthread_mutex_unlock(&mutex); //๋ฝ ํ๊ธฐ
}
return 0;
}
//์์ดํ
์ ์๋นํ๊ณ , ๋ฒํผ์์ ์ง์ฐ๋ ์์ปค ์ฐ๋ ๋๊ฐ ๋๋ฆฌ๋ ํจ์
void *consume_requests_loop(void *data)
{
int thread_id = *((int *)data);
int item_to_consumed = 0;
while(1) //๋ฌดํ ๋ฐ๋ณต
{
pthread_mutex_lock(&mutex); //๋ฝ๊ฑธ๊ธฐ
if(consumed_item_size >= total_items) { //๋ค ์๋นํ๋๋ฐ๋ ์๋นํ๋ ค๊ณ ํ ๋
num_cur_workers--;
pthread_cond_signal(&cond); //์๊ทธ๋ ๋ณด๋ด๊ธฐ
pthread_mutex_unlock(&mutex); //๋ฝ ํ๊ธฐ
break;
}
if(curr_buf_size < 1){ //๋ฒํผ ๋ค ๋น์๋๋ฐ ์๋นํ๋ ค๊ณ ํ ๋
pthread_cond_signal(&cond); //์๊ทธ๋ ๋ณด๋ด๊ธฐ
if(num_cur_workers > 1)
pthread_cond_wait(&cond, &mutex); //์๊ทธ๋ ๊ธฐ๋ค๋ฆฌ๊ธฐ
pthread_mutex_unlock(&mutex); //๋ฝ ํ๊ธฐ
continue;
}
item_to_consumed = buffer[curr_buf_size-1]; //๋ฒํผ ์๋ฆฌ ์์ดํ
consumed_item์ผ๋ก ๋นผ์ฃผ๊ณ
buffer[--curr_buf_size] = 0; //๊ทธ ์๋ฆฌ ๋น์์ฃผ๊ธฐ
print_consumed(item_to_consumed, thread_id); //์๋นํ ์์ดํ
์ฐ๋ ๋ id์ ํจ๊ป ์ถ๋ ฅ
consumed_item_size++;
pthread_cond_signal(&cond); //์๊ทธ๋ ๋ณด๋ด๊ธฐ
if(num_cur_workers > 1)
pthread_cond_wait(&cond, &mutex); //์๊ทธ๋ ๊ธฐ๋ค๋ฆฌ๊ธฐ
pthread_mutex_unlock(&mutex); //๋ฝ ํ๊ธฐ
}
return 0;
}
//write function to be run by worker threads
//ensure that the workers call the function print_consumed when they consume an item
int main(int argc, char *argv[])
{
int *master_thread_id; //๋ง์คํฐ ์ฐ๋ ๋ ์์ด๋ ๋ด์ ๋ฐฐ์ด
pthread_t *master_thread; //๋ง์คํฐ ์ฐ๋ ๋ ๋ด์ ๋ฐฐ์ด
int *worker_thread_id; //์์ปค ์ฐ๋ ๋ ์์ด๋ ๋ด์ ๋ฐฐ์ด
pthread_t *worker_thread; //์์ปค ์ฐ๋ ๋ ๋ด์ ๋ฐฐ์ด
item_to_produce = 0;
curr_buf_size = 0; //ํ์ฌ ๋ฒํผ ์ฐจ์๋ ์ ๋
consumed_item_size = 0; //์๋นํ ์์ดํ
๊ฐ์
int i;
//์
๋ ฅ์ธ์ ๋ฐ๋ ๊ณผ์
if (argc < 5) {
printf("./master-worker #total_items #max_buf_size #num_workers #masters e.g. ./exe 10000 1000 4 3\n");
exit(1);
}
else {
num_masters = atoi(argv[4]);
num_workers = atoi(argv[3]);
total_items = atoi(argv[1]);
max_buf_size = atoi(argv[2]);
}
//์ฌ๊ธฐ๊น์ง
buffer = (int *)malloc (sizeof(int) * max_buf_size); //๋ฒํผ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น(์
๋ ฅํ ๋ฒํผ ์ต๋ ํฌ๊ธฐ ์ฌ์ด์ฆ๋งํผ)
num_cur_masters = num_masters;
num_cur_workers = num_workers;
//create master producer threads
master_thread_id = (int *)malloc(sizeof(int) * num_masters);//๋ง์คํฐ ์ฐ๋ ๋ ์์ด๋ ๋ด์ ๋ฐฐ์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น
master_thread = (pthread_t *)malloc(sizeof(pthread_t) * num_masters); //๋ง์คํฐ ์ฐ๋ ๋ ๋ฐฐ์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น
for (i = 0; i < num_masters; i++) //๋ง์คํฐ ์ฐ๋ ๋ ์์ด๋ ๋ด์ ๋ฐฐ์ด ์ด๊ธฐํ
master_thread_id[i] = i;
for (i = 0; i < num_masters; i++) //๋ง์คํฐ ์ฐ๋ ๋ ์์ฑ, ๋ง์ฐํฐ ์ฐ๋ ๋๊ฐ ๋๋ฆด ํจ์์ ์ฐ๋ ๋ ์์ด๋ ์ธ์๋ก ๋๊ฒจ์ค
pthread_create(&master_thread[i], NULL, generate_requests_loop, (void *)&master_thread_id[i]);
//create worker consumer threads
worker_thread_id = (int *)malloc(sizeof(int) * num_workers);//์์ปค ์ฐ๋ ๋ ์์ด๋ ๋ด์ ๋ฐฐ์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น
worker_thread = (pthread_t *)malloc(sizeof(pthread_t) * num_workers); //์์ปค ์ฐ๋ ๋ ๋ฐฐ์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น
for (i = 0; i < num_workers; i++) //์์ปค ์ฐ๋ ๋ ์์ด๋ ๋ด์ ๋ฐฐ์ด ์ด๊ธฐํ
worker_thread_id[i] = i;
for (i = 0; i < num_workers; i++) //์์ปค ์ฐ๋ ๋ ์์ฑ, ์์ปค ์ฐ๋ ๋๊ฐ ๋๋ฆด ํจ์์ ์ฐ๋ ๋ ์์ด๋ ์ธ์๋ก ๋๊ฒจ์ค
pthread_create(&worker_thread[i], NULL, consume_requests_loop, (void *)&worker_thread_id[i]);
pthread_cond_signal(&cond); //cond๋ก ์๊ทธ๋ ๋ณด๋
//wait for all threads to complete
for (i = 0; i < num_masters; i++) //์ ์ฒด ๋ง์คํฐ ์ฐ๋ ๋์ ๋ํ์ฌ
{
pthread_join(master_thread[i], NULL); //๋ง์คํฐ ์ฐ๋ ๋ ๊ธฐ๋ค๋ฆฐ๋ค.
printf("master %d joined\n", i); //์ข
๋ฃ๋ ๋ง์คํฐ ์ฐ๋ ๋ ์ถ๋ ฅ
}
//wait for all threads to complete
for (i = 0; i < num_workers; i++) //์ ์ฒด ์์ปค ์ฐ๋ ๋์ ๋ํ์ฌ
{
pthread_join(worker_thread[i], NULL); //์์ปค ์ฐ๋ ๋ ๊ธฐ๋ค๋ฆฐ๋ค.
printf("worker %d joined\n", i); //์ข
๋ฃ๋ ์์ปค ์ฐ๋ ๋ ์ถ๋ ฅ
}
pthread_cond_destroy(&cond);
pthread_mutex_destroy(&mutex);
return 0;
}
|
Ruby | UTF-8 | 224 | 3.5 | 4 | [] | no_license | for num in 1..100 do
if num % 5 == 0 && num % 3 == 0 then
puts num.to_s+":FizzBuzz"
elsif num % 5 == 0 then
puts num.to_s+":Buzz"
elsif num % 3 == 0 then
puts num.to_s+":Fizz"
end
end |
Python | UTF-8 | 681 | 3.265625 | 3 | [] | no_license | import random
import string
import json
class VariousFunctions:
def random_string(self, string_size, chars=string.ascii_uppercase + string.digits):
self.string_size = string_size
final_string = ''.join(random.choice(chars) for i in range(string_size))
return final_string
def create_json(self, json_data, json_path):
self.json_data = json_data
self.json_path = json_path
with open(self.json_path, 'w') as json_file:
json.dump(self.json_data, json_file, indent=4)
json_file.close()
def random(self, pref):
value = self.random_string(random.randint(5, 10))
return pref + value
|
Java | UTF-8 | 2,352 | 2.09375 | 2 | [] | no_license | package com.uiet.casehearing;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import android.app.ProgressDialog;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.firebase.auth.FirebaseAuth;
public class ResetPassword extends AppCompatActivity {
private FirebaseAuth mAuth;
ProgressDialog progressDialog;
EditText email;
Button reset;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_reset_password);
mAuth = FirebaseAuth.getInstance();
email = findViewById(R.id.emailId);
reset = findViewById(R.id.resetButton);
progressDialog = new ProgressDialog(this);
reset.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
String userId = email.getText().toString();
if(userId.isEmpty()){
email.setError("Email is required");
return;
}
progressDialog.setMessage("Sending Email...");
progressDialog.show();
mAuth.sendPasswordResetEmail(userId).addOnSuccessListener(new OnSuccessListener<Void>() {
@Override
public void onSuccess(Void aVoid) {
progressDialog.cancel();
Toast.makeText(getApplicationContext(),"Password Reset Mail Sent...",Toast.LENGTH_LONG).show();
Intent intent = new Intent(getApplicationContext(),Login.class);
startActivity(intent);
}
}).addOnFailureListener(new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
progressDialog.cancel();
Toast.makeText(getApplicationContext(),e.getMessage(),Toast.LENGTH_LONG).show();
}
});
}
});
}
}
|
Markdown | UTF-8 | 1,446 | 2.953125 | 3 | [] | no_license | ## About
This project uses Springboot, NodeJS, and ReactJS.
Search for a place to eat if you are hungry. mehungry utilizes the Yelp Developer's API to obtain multiple restaurant search
results based on the type of food you want to eat, and location, as well as sorting by best match, lowest price, or most reviewed.
Each restaurant listing contains important information you would want to know such as its name, address, price range,
phone number, and rating.
This project gets search results from the Yelp Developer's API. To run this project, make sure that you supply your own Yelp API key in the DiningPlaceController.java which can be obtained from creating an account with Yelp Developers at [this website](https://www.yelp.com/developers).
## Front-end
1. Open a command window and goes to restaurant-search\src\main\web
2. Run "npm install"
3. Run in development mode: npm start
4. Build production bundle: npm run build
1. This will generate a few files under "build" directory
2. Copy the above files to src/main/resources/public to be used by springboot server.
## Back-end
1. Run maven install
2. Start springboot server: two ways to do it
1. java -jar restaurant-search-0.0.1-SNAPSHOT.jar
2. In IDE, right click RestaurantSearchApplication.java to run as application.
3. Access from browser: http://localhost:8080/
*Front-end development is based on my Codeacademy project.
|
C++ | UTF-8 | 494 | 3.125 | 3 | [] | no_license | #include <iostream>
using namespace std;
int gcd(int a, int b)
{
while (b != 0)
{
int tmp = b;
b = a % b;
a = tmp;
}
return a;
}
int main()
{
int n;
while (cin >> n && n != 0)
{
int G = 0;
for (int i = 1; i < n; i++)
{
for (int j = i + 1; j <= n; j++)
{
G += gcd(j, i);
}
}
cout << G << endl;
}
return 0;
} |
Java | UTF-8 | 718 | 2.84375 | 3 | [] | no_license |
package skipbo;
public class DiscardPile extends Structure implements Pile
{
public void addCard(Card card)
{
list.add(card);
}
@Override
public Card getTopCard()
{
Card card=list.get(list.size()-1);
list.remove(list.size()-1);
return card;
}
public Card geCard(int number)
{
Card card=list.get(number);
list.remove(number);
return card;
}
public Card getTopCardType()
{
return list.get(list.size()-1);
}
public int size()
{
return list.size();
}
public int getTopCardValue()
{
return list.get(list.size()-1).getValue();
}
}
|
Java | UTF-8 | 2,591 | 2.359375 | 2 | [] | no_license | /*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
package anhnd.rmi.impls;
import anhnd.entity.Registrations;
import anhnd.impl.repos.RegistrationsRepositoryImpl;
import anhnd.intefaces.repos.IRegistrationsRepository;
import anhnd.interfaces.rmi.IRegistrationsRMI;
import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;
import java.util.ArrayList;
import java.util.List;
/**
*
* @author anhnd
*/
public class RegistrationsRMI extends UnicastRemoteObject implements IRegistrationsRMI{
private IRegistrationsRepository registrationsRepository;
public RegistrationsRMI() throws RemoteException{
}
@Override
public ArrayList<Registrations> getAllRegistrations() throws RemoteException{
registrationsRepository = new RegistrationsRepositoryImpl();
return registrationsRepository.getAllRegistrations();
}
@Override
public Registrations findByRegistrationID(String id) throws RemoteException {
registrationsRepository = new RegistrationsRepositoryImpl();
return registrationsRepository.findByRegistrationID(id);
}
@Override
public boolean createRegistration(Registrations registration) throws RemoteException {
registrationsRepository = new RegistrationsRepositoryImpl();
return registrationsRepository.createRegistration(registration);
}
@Override
public boolean updateRegistration(Registrations registration) throws RemoteException {
registrationsRepository = new RegistrationsRepositoryImpl();
return registrationsRepository.updateRegistration(registration);
}
@Override
public boolean removeRegistration(String id) throws RemoteException {
registrationsRepository = new RegistrationsRepositoryImpl();
return registrationsRepository.removeRegistration(id);
}
@Override
public ArrayList<Registrations> findRegistrationByLikeName(String keywords) throws RemoteException {
ArrayList<Registrations> result = new ArrayList<>();
registrationsRepository = new RegistrationsRepositoryImpl();
ArrayList<Registrations> registrations = registrationsRepository.getAllRegistrations();
for (Registrations registration : registrations) {
if(registration.getFullname().toLowerCase().contains(keywords.toLowerCase())){
result.add(registration);
}
}
return result;
}
}
|
Java | UTF-8 | 8,888 | 2.078125 | 2 | [] | no_license | package com.dzf.zxkj.platform.service.common.impl;
import com.dzf.zxkj.base.dao.SingleObjectBO;
import com.dzf.zxkj.base.framework.SQLParameter;
import com.dzf.zxkj.base.framework.processor.ResultSetProcessor;
import com.dzf.zxkj.base.exception.BusinessException;
import com.dzf.zxkj.base.exception.DAOException;
import com.dzf.zxkj.base.exception.DZFWarpException;
import com.dzf.zxkj.common.utils.StringUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* ๅบ็กๆฐๆฎๅผ็จ่กจใ ๅๅปบๆฅๆ๏ผ(2001-7-17 15:44:24)
*
* @author๏ผ่ตต็ปงๆฑ
*/
@Slf4j
public class ReferenceManagerDMO /* extends DataManageObject */
{
private SingleObjectBO singleObjectBO;
public SingleObjectBO getSingleObjectBO() {
return singleObjectBO;
}
@Autowired
public void setSingleObjectBO(SingleObjectBO singleObjectBO) {
this.singleObjectBO = singleObjectBO;
}
class BD_Realtion {
String corpfieldName;
String fieldName;
String selfPkName;
String tableName;
String errorMsg;
/**
* @param tableName
* @param fieldName
*/
public BD_Realtion(String tableName, String fieldName,
String selfPkName, String corpfieldName,String errorMsg) {
super();
this.tableName = tableName;
this.fieldName = fieldName;
this.selfPkName = selfPkName;
this.corpfieldName = corpfieldName;
this.errorMsg = errorMsg;
}
}
private static final String WITH_CORP_FLAG = "$";
private final ResultSetProcessor ResultSetHasDataJudger = new ResultSetProcessor() {
private static final long serialVersionUID = 8347151336502175602L;
public Object handleResultSet(ResultSet rs) throws SQLException {
rs.next();
return rs.getInt(1) > 0;
// if (rs.next())
// return Boolean.TRUE;
// else
// return Boolean.FALSE;
}
};
private HashMap<String, List<BD_Realtion>> tableName_ReferenceTables_Map;
/**
* ReferenceManagerDMO ๆ้ ๅญๆณจ่งฃใ
*
* @exception javax.naming.NamingException
* ๅผๅธธ่ฏดๆใ
* @exception nc.bs.pub.SystemException
* ๅผๅธธ่ฏดๆใ
*/
public ReferenceManagerDMO(SingleObjectBO singleObjectBO) {
super();
if(singleObjectBO==null)
throw new DAOException("SingleObjectBOๆชๆๅๅๅงๅ");
this.singleObjectBO=singleObjectBO;
}
private boolean checkReferenceBySql(String tableName, String pk_corp,
BD_Realtion relation, String key, String sql) {
boolean referenced = false;
try {
SQLParameter para = new SQLParameter();
para.addParam(key);
if (relation.corpfieldName != null
&& relation.corpfieldName.trim().length() > 0)
para.addParam(pk_corp);
referenced = (Boolean) getSingleObjectBO().executeQuery(sql, para,
ResultSetHasDataJudger);
} catch (DAOException e) {// ๅฆๆๅ็ไบ้่ฏฏไธ่ฌๆฏๅผ็จๆณจๅ่กจไธญๆณจๅไบไธๅญๅจ่กจ(ๆๅฏนๅบไบงๅๆฒกๆๅฎ่ฃ
).ๅฟฝ็ฅ.
log.warn("ๆฅ่ฏขๆฐๆฎๅบ่กจ" + relation.tableName + "ๅฏน่กจ" + tableName
+ "็ๅผ็จๆถๅบ้,ๅฏ่ฝๆฏๅฏนๅบไบงๅๆฒกๅฎ่ฃ
");
log.warn(e.getMessage(), e);
}
return referenced;
}
private ArrayList<BD_Realtion> getRelationListByTableName(String tableName,
boolean isModifyCheck) throws DAOException {
return getRelationListByTableNameAndWithcorp(tableName, false,
isModifyCheck);
}
/**
* @param tableName
* @return
* @throws SQLException
*/
@SuppressWarnings("unchecked")
private ArrayList<BD_Realtion> getRelationListByTableNameAndWithcorp(
String tableName, boolean isWithCorp, boolean isModifyCheck)
throws DAOException {
String newTableName = isWithCorp ? WITH_CORP_FLAG + tableName
: tableName;
ArrayList<BD_Realtion> al = (ArrayList<BD_Realtion>) this
.getTableName_ReferenceTables_Map().get(newTableName);
if (al == null) {
// ้ๆฉๆๆๅผ็จ่ฏฅ่กจ็่กจ๏ผ
String sql = "select referencedtablekey, referencingtablename, referencingtablecolumn, referencingcorpfield,refmsg from bd_ref_relation where referencedtablename = '"
+ tableName + "'";
if (isWithCorp) {
sql += " and referencingcorpfield is not null ";
} else {
sql += " and referencingcorpfield is null ";
}
if (isModifyCheck) {
sql += " and ismodifycheck = 'Y'";
}
ResultSetProcessor p = new ResultSetProcessor() {
private static final long serialVersionUID = 3730593948830478187L;
public Object handleResultSet(ResultSet rs) throws SQLException {
ArrayList<BD_Realtion> result = new ArrayList<BD_Realtion>();
while (rs.next()) {
String ReferencedTableKey = rs
.getString("referencedtablekey");
String ReferencingTableName = rs
.getString("referencingtablename");
String ReferencingTableColumn = rs
.getString("referencingtablecolumn");
String referencingcorpfield = rs
.getString("referencingcorpfield");
String errormsg = rs.getString("refmsg");
BD_Realtion r = new BD_Realtion(ReferencingTableName,
ReferencingTableColumn, ReferencedTableKey,
referencingcorpfield,errormsg);
result.add(r);
}
return result;
}
};
al = (ArrayList<BD_Realtion>) getSingleObjectBO().executeQuery(sql,null, p);
getTableName_ReferenceTables_Map().put(newTableName, al);
}
return al;
}
/**
* @param key
* @param relation
* @return
*/
private String getSqlQeury(String key, BD_Realtion relation) {
// ๅฉ็จwhere exists็็ญ่ทฏ็นๆงๆฅๆ้ซๆ็, ้็จbd_currtypeๆฏๅ ไธบ
// ๅฏนไบNCๆฅ่ฏด่ฏฅ่กจไธๅฎๅญๅจ่ไธๆฐๆฎ้ๅคๅฐใ ไปฅๅๅฏไน่่ๅปบ็ซไธไธชไธ้จ็่พ
ๅฉ่กจ.
StringBuilder buf = new StringBuilder();
buf.append("select count(1) from dual where exists (");
buf.append("select ");
buf.append("1");
buf.append(" from ");
buf.append(relation.tableName);
buf.append(" where ");
buf.append(relation.fieldName);
buf.append("=");
buf.append("?");
if (relation.corpfieldName != null
&& relation.corpfieldName.trim().length() > 0) {
buf.append(" and ");
buf.append(relation.corpfieldName);
buf.append(" = ? ");
}
buf.append(")");
String sql = buf.toString();
return sql;
}
private String getSqlQeuryWithDr(String key, BD_Realtion relation) {
StringBuffer buf = new StringBuffer();
buf.append("select count(1) from dual where exists (");
buf.append("select ");
buf.append("1");
buf.append(" from ");
buf.append(relation.tableName);
buf.append(" where ");
buf.append(relation.fieldName);
buf.append("=");
buf.append("?");
if (relation.corpfieldName != null
&& relation.corpfieldName.trim().length() > 0) {
buf.append(" and ");
buf.append(relation.corpfieldName);
buf.append(" = ? ");
}
buf.append(" and nvl(dr,0)=0");
buf.append(")");
String sql = buf.toString();
return sql;
}
protected HashMap<String, List<BD_Realtion>> getTableName_ReferenceTables_Map() {
if (this.tableName_ReferenceTables_Map == null) {
this.tableName_ReferenceTables_Map = new HashMap<String, List<BD_Realtion>>();
}
return this.tableName_ReferenceTables_Map;
}
public void isReferencedRefmsg(String tableName, String key,
boolean isModifyCheck) throws DZFWarpException {
List<BD_Realtion> relationList = getRelationListByTableName(tableName,
isModifyCheck);
checkReferenceHelper(tableName, key, relationList);
}
private void checkReferenceHelper(String tableName, String key,
List<BD_Realtion> relationList) throws DZFWarpException{
checkReferenceHelper(tableName, null, key, relationList);
}
private void checkReferenceHelper(String tableName, String pk_corp,
String key, List<BD_Realtion> relationList) throws DZFWarpException{
// ๆฒกๆๅผ็จ่ฏฅ่กจ็ๆ
ๅต๏ผ
if (relationList.size() == 0)
return ;
for (BD_Realtion relation : relationList) {
String checkSqlWithoutDr = getSqlQeury(key, relation);
String checkSqlWithDr = getSqlQeuryWithDr(key, relation);
// ๅ
ไธๅ
ๅซdr่ฟ่กๆฅ่ฏข๏ผๅฐฝ้ๅฉ็จไธ็ดขๅผ๏ผๅฆๆ่ขซๅผ็จไบ๏ผๅๅ ไธdrๆกไปถ็กฎ่ฎคไธไธใ
boolean referenced = checkReferenceBySql(tableName, pk_corp, relation, key,
checkSqlWithoutDr)
&& checkReferenceBySql(tableName, pk_corp, relation, key,
checkSqlWithDr);
if (referenced) {
if(!StringUtil.isEmpty(relation.errorMsg)){
throw new BusinessException(relation.errorMsg);
}else{
throw new BusinessException("ๆฐๆฎๅทฒ่ขซๅผ็จ๏ผไธๅ
่ฎธๅ ้ค๏ผ");
}
}
}
return ;
}
} |
TypeScript | UTF-8 | 10,829 | 2.90625 | 3 | [
"MIT"
] | permissive | /**
* Specifies the direction of the ken burns effect.
*/
export const enum Direction {
Normal = 'normal',
Reverse = 'reverse',
Random = 'random',
}
/**
* All available ken burns CSS animations.
*/
export const animationNames = [
'ken-burns-bottom-right',
'ken-burns-top-left',
'ken-burns-bottom-left',
'ken-burns-top-right',
'ken-burns-middle-left',
'ken-burns-middle-right',
'ken-burns-top-middle',
'ken-burns-bottom-middle',
'ken-burns-center',
];
const enum Attributes {
AnimationDirection = 'animation-direction',
AnimationNames = 'animation-names',
FadeDuration = 'fade-duration',
Images = 'images',
SlideDuration = 'slide-duration',
}
const template = document.createElement('template') as HTMLTemplateElement;
template.innerHTML = `
<style>
:host {
overflow: hidden;
position: relative;
}
div, img {
height: 100%;
width: 100%;
}
div {
position: absolute;
will-change: transform;
}
img {
filter: var(--img-filter);
object-fit: cover;
}
@keyframes fade-in {
from {
opacity: 0;
}
to {
opacity: 1;
}
}
@keyframes ken-burns-bottom-right {
to {
transform: scale3d(1.5, 1.5, 1.5) translate3d(-10%, -7%, 0);
}
}
@keyframes ken-burns-top-right {
to {
transform: scale3d(1.5, 1.5, 1.5) translate3d(-10%, 7%, 0);
}
}
@keyframes ken-burns-top-left {
to {
transform: scale3d(1.5, 1.5, 1.5) translate3d(10%, 7%, 0);
}
}
@keyframes ken-burns-bottom-left {
to {
transform: scale3d(1.5, 1.5, 1.5) translate3d(10%, -7%, 0);
}
}
@keyframes ken-burns-middle-left {
to {
transform: scale3d(1.5, 1.5, 1.5) translate3d(10%, 0, 0);
}
}
@keyframes ken-burns-middle-right {
to {
transform: scale3d(1.5, 1.5, 1.5) translate3d(-10%, 0, 0);
}
}
@keyframes ken-burns-top-middle {
to {
transform: scale3d(1.5, 1.5, 1.5) translate3d(0, 10%, 0);
}
}
@keyframes ken-burns-bottom-middle {
to {
transform: scale3d(1.5, 1.5, 1.5) translate3d(0, -10%, 0);
}
}
@keyframes ken-burns-center {
to {
transform: scale3d(1.5, 1.5, 1.5);
}
}
</style>
`;
if (typeof (window as any).ShadyCSS === 'object') {
(window as any).ShadyCSS.prepareTemplate(template, 'ken-burns-carousel');
}
/**
* `ken-burns-carousel`
*
* Displays a set of images in a smoothly-fading ken burns style carousel.
*
* @demo ../demo/index.html
*/
export default class KenBurnsCarousel extends HTMLElement {
static get observedAttributes(): string[] {
return [
Attributes.AnimationDirection,
Attributes.AnimationNames,
Attributes.FadeDuration,
Attributes.Images,
Attributes.SlideDuration,
];
}
/**
* Specifies the list of ken burns animations to apply to the elements.
*
* This allows customizing the built-in animations to your liking by overriding
* the ones you don't like with custom CSS animations.
*
* This can also be set via setting the `animation-names`-attribute to a space-
* separated list of CSS animation names.
*
* @type String[]
*/
animationNames: string[] = animationNames;
/**
* The direction to play the animations in.
*
* Defaults to Direction.Random, meaning that with each image the associated ken
* burns animation is either played forwards or backwards adding additional visual
* diversity.
*
* This can also be set via the `animation-direction`-attribute.
*
* @type Direction
*/
animationDirection: Direction = Direction.Random;
private _fadeDuration: number = 2500;
private _imgList: string[] = [];
private _slideDuration: number = 20000;
private _timeout: number = 0;
private _zCounter: number = 0;
/**
* The duration of the crossfading animation in millseconds.
*
* Must be smaller than the slide duration. Defaults to 2500ms.
* This can also be set via the `fade-duration`-attribute.
*
* @type number
*/
get fadeDuration() {
return this._fadeDuration;
}
set fadeDuration(val: number) {
if (val > this.slideDuration) {
throw new RangeError("Fade duration must be smaller than slide duration");
}
this._fadeDuration = val;
}
/**
* The list of URLs to the images to display.
*
* You can either set this property directly, or set the `images`-attribute
* to a space-separated list of URLs.
*
* The element will dirty-check this property to avoid switching to the next image
* even if the images set were the same. If you forcefully want to rerender, ensure
* you pass a different array because the dirty-check will check for identity.
*
* @type string[]
*/
get images(): string[] {
return this._imgList;
}
set images(images: string[]) {
if (arraysEqual(this._imgList, images)) {
return;
}
this._imgList = images;
if (images.length > 0) {
this.animateImages(images);
} else {
this.stop();
}
}
/**
* The duration of the sliding (or ken burns) animation in millseconds.
*
* Must be greater than or equal to the fade duration. Defaults to 20s.
* This can also be set via the `slide-duration`-attribute.
*
* @type number
*/
get slideDuration() {
return this._slideDuration;
}
set slideDuration(val: number) {
if (val < this.fadeDuration) {
throw new RangeError("Slide duration must be greater than fade duration");
}
this._slideDuration = val;
}
constructor() {
super();
this.attachShadow({ mode: 'open' });
this.shadowRoot!.appendChild(template.content.cloneNode(true));
}
attributeChangedCallback(name: string, oldVal: string, newVal: string) {
switch (name) {
case Attributes.AnimationDirection:
this.animationDirection = newVal as Direction;
break;
case Attributes.AnimationNames:
this.animationNames = newVal
? newVal.split(' ').filter(name => name)
: animationNames;
break;
case Attributes.FadeDuration:
this.fadeDuration = Number(newVal);
break;
case Attributes.Images:
this.images = newVal
? newVal.split(' ').filter(url => url)
: [];
break;
case Attributes.SlideDuration:
this.slideDuration = Number(newVal);
break;
}
}
connectedCallback() {
if (typeof (window as any).ShadyCSS === 'object') {
(window as any).ShadyCSS.styleElement(this);
}
}
private animateImages(images: string[]) {
const insert = (index: number, img: HTMLImageElement) => {
const random = Math.random();
const animationIndex = Math.floor(random * this.animationNames.length);
const direction = this.animationDirection === Direction.Random
? random > .5 ? 'normal' : 'reverse'
: this.animationDirection;
/*
* Here we wrap the image element into a surrounding div that is promoted
* onto a separate GPU layer using `will-change: transform`. The wrapping div
* is then ken-burns-animated instead of the image itself.
*
* This leads the browser to pre-computing the image filter (--img-filter)
* instead of computing it every frame. This can be a massive performance boost
* if the filter is expensive.
*
* See https://developers.google.com/web/updates/2017/10/animated-blur for
* more information.
*/
const wrap = document.createElement('div');
wrap.appendChild(img);
wrap.style.animationName = `${this.animationNames[animationIndex]}, fade-in`;
wrap.style.animationDuration = `${this.slideDuration}ms, ${this.fadeDuration}ms`;
wrap.style.animationDirection = `${direction}, normal`;
wrap.style.animationTimingFunction = 'linear, ease';
wrap.style.zIndex = String(this._zCounter++);
this.shadowRoot!.appendChild(wrap);
setTimeout(() => wrap.remove(), this.slideDuration);
// Preload next image and place it in browser cache
const nextIndex = (index + 1) % images.length;
const next = document.createElement('img') as HTMLImageElement;
next.src = images[nextIndex];
this._timeout = setTimeout(
() => insert(nextIndex, next),
this.slideDuration - this.fadeDuration,
);
};
const img = document.createElement('img') as HTMLImageElement;
img.src = images[0];
img.onload = () => {
/*
* Prevent race condition leading to wrong list being displayed.
*
* The problem arose when you were switching out the image list before
* this callback had fired. The callback of a later list could have fired
* faster than the one of earlier lists, which lead to the later slideshow
* (the right one) being cancelled when the previous one became available.
*
* We now check whether we're still displaying the list we started
* with and only then proceed with actually stopping the old slideshow
* and displaying it.
*/
if (!arraysEqual(this._imgList, images))ย {
return;
}
this.stop();
insert(0, img);
};
}
private stop() {
clearTimeout(this._timeout);
this._timeout = 0;
}
}
function arraysEqual<T>(arr1: T[] | null, arr2: T[]ย | null) {
// tslint:disable-next-line:triple-equals
if (arr1 === arr2 || (!arr1 && !arr2)) { // undefined == null here
return true;
}
if (!arr1 || !arr2 || arr1.length !== arr2.length) {
return false;
}
for (let i = 0; i < arr1.length; i++) {
if (arr1[i] !== arr2[i]) {
return false;
}
}
return true;
}
|
C++ | UTF-8 | 1,057 | 2.859375 | 3 | [
"Unlicense"
] | permissive | //
// 2018 Rico Schulz
//
#pragma once
#include "actuator.h"
#define GHPI_PWM_CLOCK 384
#define GHPI_PWM_RANGE 1000
#define SERVO_OFF_POS 0
#define SERVO_ON_POS -130
namespace ghpi {
// Class for the Kuman KY72 Servo
class Servo : public Actuator {
public:
void TurnOn() override;
void TurnOff() override;
int get_angle();
void Initialize();
Servo(int max_angle, int init_angle);
~Servo();
private:
// Functions
void SetUpPWM();
void SetPosition(int angle);
// Converts an angle to corresponding value for PWM.
// Function assumes 50Hz and a PWM Range of 1000.
// 0ยฐ is the neutral position of the motor
// Angle is evenly spreaded around the neutral position.
// ARGS:
// angle: angle the motor should be steered to
// RETURNS:
// The corresponding value for the PWM
int ConvertAngleToValue(int angle);
// Data Member
// Angle the motor can totaly rotate
int max_angle_;
// Current angle of the motor
int angle_;
};
}; |
Shell | UTF-8 | 666 | 3.21875 | 3 | [] | no_license | #!/bin/sh
# $Id$
#
#
#set -x
#
URL_SUM_24h="http://192.168.178.10:8080/api/getPlainValue/3862"
URL_SUM="http://192.168.178.10:8080/api/getPlainValue/3858"
#
SCRIPT=`basename $0`
EXITCODE="0"
#-------------------------------
info()
{
logger -t "${SCRIPT}[$$]" $*
}
error()
{
logger -p user.err -t "${SCRIPT}[$$]" "ERROR: $*"
}
debug()
{
logger -p user.debug -t "${SCRIPT}[$$]" $*
}
#--------------------------------------------
# MAIN
#-----
SUM_24h=`wget -q -O - $URL_SUM_24h`
SUM=`wget -q -O - $URL_SUM`
echo "Stromverbrauch letzte 24h: ${SUM_24h}. Summe: ${SUM}." | sendgtalk &
#---------------------------------------------------
exit $EXITCODE
# EOF
|
Java | UTF-8 | 746 | 3.140625 | 3 | [
"MIT"
] | permissive |
public class Matriz {
public static float[][] transpose(float A[][]) {
int Rows = A.length,
int Columns = A[0].length;
float[][] resultant = new float[Columns][Rows];
for(int i = 0; i < Rows; i++)
for (int j = 0; j < Columns; j++)
resultant[j][i] = a[i][j];
return resultant;
}
public static float[][] normalize(float A[][]){
int ARows = A.length,
int AColumns = A[0].length;
float[][] resultant = new float[ARows-1][AColumns];
for (int i = 0; i < ARows-1; i++){
for (int j = 0; j < AColumns; j++)
resultant[i][j] = a[i][j]/A[ARows-1][j];
}
return resultant;
}
}
|
Java | UTF-8 | 661 | 2.875 | 3 | [] | no_license | import java.io.*;
import java.net.*;
public class server_rw
{
public static void main(String args[]) throws Exception
{
ServerSocket s1 = new ServerSocket(1055);
Socket s = s1.accept();
DataInputStream din = new DataInputStream(s.getInputStream());
DataOutputStream dout= new DataOutputStream(s.getOutputStream());
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str1 = "", str2 = "";
while(!str1.equals("stop"))
{
str1 = din.readUTF();
System.out.println("Client says : " +str1);
str2 = br.readLine();
dout.writeUTF(str2);
dout.flush();
}
din.close();
s.close();
s1.close();
}
}
|
Shell | UTF-8 | 861 | 3.65625 | 4 | [
"Apache-2.0"
] | permissive | set -e
usage() {
echo "Usage: $0 -o path [-b]"
echo -e "\t-o package files output directory"
echo -e "\t-b opencl backend"
exit 1
}
while getopts "o:hb" opt; do
case "$opt" in
o ) path=$OPTARG ;;
b ) opencl=true ;;
h|? ) usage ;;
esac
done
# clear and create package directory
./schema/generate.sh
rm -rf $path && mkdir -p $path
TOOLS_PATH=$(realpath $path)
CMAKE_ARGS="-DCMAKE_BUILD_TYPE=Release -DMNN_SEP_BUILD=OFF -DMNN_BUILD_SHARED_LIBS=OFF -DMNN_BUILD_CONVERTER=ON -DMNN_BUILD_TRAIN=ON -DMNN_PORTABLE_BUILD=ON -DMNN_BUILD_TOOLS=ON -DMNN_BUILD_QUANTOOLS=ON -DMNN_BUILD_BENCHMARK=ON -DMNN_BUILD_TEST=ON"
if [ ! -z $opencl ]; then
CMAKE_ARGS="$CMAKE_ARGS -DMNN_OPENCL=ON"
fi
rm -rf build && mkdir build
pushd build
[ -f CMakeCache.txt ] && rm CMakeCache.txt
cmake $CMAKE_ARGS .. && make -j24
cp *.out $TOOLS_PATH
popd
|
PHP | UTF-8 | 1,160 | 2.984375 | 3 | [
"MIT"
] | permissive | <?php
namespace core\Http;
class Request
{
/**
* Las peticiones
*
* @var array
*/
protected $requests = [];
/**
* Rescata las peticiones
*
* @return void
*/
public function __construct()
{
$this->requests = $this->mergeData($_POST, $_FILES);
}
/**
* Fusiona datos de POST y FILES
*
* @param array $post
* @param array $files
*
* @return array
*/
protected function mergeData(array $post, array $files)
{
foreach($post as $key => $value) {
if(is_string($value)) {
$post[$key] = trim($value);
}
}
return array_merge($files, $post);
}
/**
* Acceso a los datos de las peticiones
*
* @param string $name
*
* @return mixed
*/
public function input($name)
{
return array_key_exists($name, $this->requests) ? $this->requests[$name] : null;
}
/**
* Obtener todas las requests
*
* @return array
*/
public function all()
{
return $this->requests;
}
}
|
Python | UTF-8 | 730 | 4.71875 | 5 | [] | no_license | ###################################################################
# SORTING BY KEY #
###################################################################
# use of common method for sorting values
example_list = [[1, 4], [5, 8], [5, 4], [3, 2], [9, 1]]
print(example_list)
example_list.sort() # the list must first be sorted and then printed, sort() method can't be used alongside with print() method
print(example_list)
# use of better method for sorting values
example_list.sort(key=lambda x: x[1]) # list will be sorted by second element of each list
print(example_list)
example_list.sort(key=lambda x: x[1], reverse=True) # return reversed list
print(example_list) |
C++ | UTF-8 | 4,752 | 2.71875 | 3 | [] | no_license | ๏ปฟ// _____________________________________
// | FuelTank.cpp - class implementation |
// | Jack Flower - December 2012 |
// |_____________________________________|
//
#include "FuelTank.h"
#include "../../../Rendering/Drawable/Layers.h"
#include "../../../Rendering/Animations/AnimSet.h"
using namespace rendering::animation;
using namespace rendering::drawable;
namespace equipment
{
RTTI_IMPL(FuelTank, Actor)
//Chroniony konstruktor domyลlny
FuelTank::FuelTank(const std::wstring & uniqueId)
:
Actor{ uniqueId },//konstruktor klasy bazowej
m_fuel_tank_name{},
m_fuel_tank_capacity{ 0.0f },
m_fuel{ 0.0f },
m_fueltank_state{ EFuelTankState::FUELTANK_DEFAULT },
m_unit_controller{ true }//urzฤ
dzenie wลฤ
czone
{
setZIndexBody(Z_PHYSICAL_FUEL_TANK_BODY);
setZIndexShadowBody(Z_PHYSICAL_SHADOW_FUEL_TANK_BODY);
setZIndexHead(Z_PHYSICAL_FUEL_TANK_HEAD);
setZIndexShadowHead(Z_PHYSICAL_SHADOW_FUEL_TANK_HEAD);
}
//Chroniony konstruktor kopiujฤ
cy
FuelTank::FuelTank(const FuelTank & FuelTankCopy)
:
Actor(FuelTankCopy),//konstruktor kopiujฤ
cy klasy bazowej
m_fuel_tank_name{ FuelTankCopy.m_fuel_tank_name },
m_fuel_tank_capacity{ FuelTankCopy.m_fuel_tank_capacity },
m_fuel{ FuelTankCopy.m_fuel },
m_fueltank_state{ FuelTankCopy.m_fueltank_state },
m_unit_controller{ FuelTankCopy.m_unit_controller }
{
setZIndexBody(Z_PHYSICAL_FUEL_TANK_BODY);
setZIndexShadowBody(Z_PHYSICAL_SHADOW_FUEL_TANK_BODY);
setZIndexHead(Z_PHYSICAL_FUEL_TANK_HEAD);
setZIndexShadowHead(Z_PHYSICAL_SHADOW_FUEL_TANK_HEAD);
}
//Destruktor wirtualny
FuelTank::~FuelTank(void)
{
//~Actor()
m_fuel_tank_name = "";
m_fuel_tank_capacity = 0.0f;
m_fuel = 0.0f;
m_fueltank_state = EFuelTankState::FUELTANK_DEFAULT;
m_unit_controller;
}
//Metoda zwraca typ obiektu /RTTI/
const std::string FuelTank::getType() const
{
return rtti.getNameClass();
}
//Metoda zwraca nazwฤ zbiornika
const std::string FuelTank::getFuelTankName() const
{
return m_fuel_tank_name;
}
//Metoda ustawia nazwฤ zbiornika
void FuelTank::setFuelTankName(const std::string& fuel_tank_name)
{
m_fuel_tank_name = fuel_tank_name;
}
//Metoda zwraca pojemnoลฤ zbiornika
const float FuelTank::getFuelTankCapacity() const
{
return m_fuel_tank_capacity;
}
//Metoda ustawia pojemnoลฤ zbiornika paliwa (tlenu)
void FuelTank::setFuelTankCapacity(float fuel_tank_capacity)
{
if (fuel_tank_capacity < 0) return;
m_fuel_tank_capacity = fuel_tank_capacity;
}
//Metoda zwraca iloลฤ paliwa (tlenu) obiektu
const float FuelTank::getFuel() const
{
return m_fuel;
}
//Metoda ustawia iloลฤ paliwa (tlenu) obiektu
void FuelTank::setFuel(float fuel)
{
if (fuel < 0) //jeลli tankujemy wartoลciฤ
ujemnฤ
- opuszczamy funkcjฤ
{
m_fuel = 0; //zerujemy
return;
}
if (m_fuel_tank_capacity > 0) //jeลli zbiornik ma pojemnoลฤ
{
if (fuel >= m_fuel_tank_capacity) //jeลli iloลฤ paliwa, ktรณrฤ
chcemy zatankowaฤ
//jest wiฤksza lub rรณwna pojemnoลci zbiornika
//reszta (nadmiar) nie jest wykorzystany
m_fuel = m_fuel_tank_capacity; //ustawiamy iloลฤ paliwa na pojemnoลฤ zbiornika
else
m_fuel = fuel; //tankujemy tyle ile zamierzamy (Parametr funkcji fuel)
}
else //zbiornik nie ma pojemnoลฤi
m_fuel = 0; //nie moลผna tankowaฤ.
}
//Wirtualna metoda aktualizuje animacje w zaleลผnoลci od stanu logiki obiektu (move, attack, death, etc...)
void FuelTank::updateAnimations(float dt)
{
switch (m_fueltank_state)
{
case EFuelTankState::FUELTANK_DEFAULT:
{
if (p_anim_set)
{
setAnimationBody(p_anim_set->getFuelBodyDefaultAnim());
setAnimationHead(p_anim_set->getFuelHeadDefaultAnim());
}
break;
}
case EFuelTankState::FUELTANK_RESERVE:
{
if (p_anim_set)
{
setAnimationBody(p_anim_set->getFuelBodyReserveAnim());
setAnimationHead(p_anim_set->getFuelHeadReserveAnim());
}
break;
}
case EFuelTankState::FUELTANK_EMPTY:
{
if (p_anim_set)
{
setAnimationBody(p_anim_set->getFuelBodyEmptyAnim());
setAnimationHead(p_anim_set->getFuelHeadEmptyAnim());
}
break;
}
case EFuelTankState::FUELTANK_DAMAGE:
{
if (p_anim_set)
{
setAnimationBody(p_anim_set->getFuelBodyDamageAnim());
setAnimationHead(p_anim_set->getFuelHeadDamageAnim());
}
break;
}
default:
break;
}
}
//Metoda zwraca referencjcฤ na moduล sterowania
Switch & FuelTank::getUnitController()
{
return m_unit_controller;
}
//Wirtualna metoda aktualizujฤ
ca obiekt
void FuelTank::update(float dt)
{
updateShadow(dt); //aktualizacja shadow engine
if (m_unit_controller.getState())
updateAnimations(dt);
}
}//namespace equipment
|
Java | UTF-8 | 663 | 3.453125 | 3 | [] | no_license | package array;
/**
* https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii
*/
public class BestTimeToBuyAndSellStockII {
public int maxProfit(int[] prices) {
if (prices == null || prices.length < 2) return 0;
int profit = 0;
for (int i = 1; i < prices.length; i++) {
if (prices[i] > prices[i - 1]) {
profit += prices[i] - prices[i - 1];
}
}
return profit;
}
public static void main(String[] args) {
BestTimeToBuyAndSellStockII obj = new BestTimeToBuyAndSellStockII();
System.out.println(obj.maxProfit(new int[]{7, 1, 5, 3, 6, 4}));
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.