repo_name stringlengths 6 101 | path stringlengths 4 300 | text stringlengths 7 1.31M |
|---|---|---|
Raevar/bachelor-thesis | test/edu/tum/cup2/test/lr1blowup/Spec14NoPrec.java | <reponame>Raevar/bachelor-thesis
package edu.tum.cup2.test.lr1blowup;
import org.junit.Test;
import edu.tum.cup2.grammar.NonTerminal;
import edu.tum.cup2.grammar.Terminal;
import edu.tum.cup2.spec.CUP2Specification;
import edu.tum.cup2.test.Time;
//locate static imports after others to be compatible with javac
import static edu.tum.cup2.test.lr1blowup.Spec14NoPrec.NonTerminals.*;
import static edu.tum.cup2.test.lr1blowup.Spec14NoPrec.Terminals.*;
/**
* Grammar to test LR(1)-blowup.
*
* @author <NAME>
*/
public class Spec14NoPrec
extends CUP2Specification
{
//terminals
public enum Terminals implements Terminal
{
TERMINAL, LBR, RBR, OP1, OP2, OP3, OP4, OP5, OP6, OP7, OP8, OP9, OP10, OP11, OP12, OP13, OP14
}
//non-terminals
public enum NonTerminals implements NonTerminal
{
term, brackets, op1, op2, op3, op4, op5, op6, op7, op8, op9, op10, op11, op12, op13, op14
}
public Spec14NoPrec()
{
grammar(
prod(term,
rhs(op1)),
prod(op1,
rhs(op2),
rhs(op1, OP1, op2)),
prod(op2,
rhs(op3),
rhs(op2, OP2, op3)),
prod(op3,
rhs(op4),
rhs(op3, OP3, op4)),
prod(op4,
rhs(op5),
rhs(op4, OP4, op5)),
prod(op5,
rhs(op6),
rhs(op5, OP5, op6)),
prod(op6,
rhs(op7),
rhs(op6, OP6, op7)),
prod(op7,
rhs(op8),
rhs(op7, OP7, op8)),
prod(op8,
rhs(op9),
rhs(op8, OP8, op9)),
prod(op9,
rhs(op10),
rhs(op9, OP9, op10)),
prod(op10,
rhs(op11),
rhs(op10, OP10, op11)),
prod(op11,
rhs(op12),
rhs(op11, OP11, op12)),
prod(op12,
rhs(op13),
rhs(op12, OP12, op13)),
prod(op13,
rhs(op14),
rhs(op13, OP13, op14)),
prod(op14,
rhs(brackets),
rhs(op14, OP14, brackets)),
prod(brackets,
rhs(TERMINAL),
rhs(LBR, term, RBR))
);
}
@Test public void testTime()
{
Time.measureTime(new Spec14NoPrec());
}
} |
feiyu2016/hermes | hermes-metaserver/src/main/java/com/ctrip/hermes/meta/server/RestException.java | package com.ctrip.hermes.meta.server;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import org.codehaus.plexus.util.ExceptionUtils;
public class RestException extends WebApplicationException {
private static final long serialVersionUID = -5416250813243019949L;
public RestException(Exception e) {
this(e, Response.Status.INTERNAL_SERVER_ERROR);
}
public RestException(Exception e, Response.Status status) {
this(e.getMessage(), status);
}
public RestException(String content) {
this(content, Response.Status.INTERNAL_SERVER_ERROR);
}
public RestException(String content, Exception e) {
this(content + "\n" + ExceptionUtils.getStackTrace(e));
}
public RestException(String content, Response.Status status) {
super(Response.status(status).entity(content).type(MediaType.APPLICATION_JSON).build());
}
} |
TruthTreeASD/backend | modules/application/src/main/java/edu/northeastern/truthtree/adapter/utilities/URLUtil.java | package edu.northeastern.truthtree.adapter.utilities;
import org.json.simple.JSONArray;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestTemplate;
/**
* Represents the methods needed to read JSON from a URL API.
*/
@Component
public class URLUtil {
private static RestTemplate restTemplate = null;
@Autowired
public URLUtil(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}
/**
* Reads the content form a web address and converts it into a JSONArray.
*
* @param url The web address of the web page to be read and converted.
* @return JSONArray in the form of the text on the web page
*/
public static JSONArray readJSONFromURL(String url) {
String jsonString = readURL(url);
return JSONUtil.stringToJSONArray(jsonString);
}
public static String readJSONFromURLInString(String url) {
return readURL(url);
}
/**
* Reads a web page and turns its contents into a string.
*
* @param url The web address of the web page to be read and converted.
* @return Web contents as a string
*/
private static String readURL(String url) {
ResponseEntity<String> response
= restTemplate.getForEntity(url, String.class);
return response.getBody();
}
/**
* Reads a web page and turns its contents into a string.
*
* @param url The web address of the web page to be read and converted.
* @return Web contents as a string
*/
public static String postJSONFromURL(String url, String jsonString) {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
HttpEntity<String> entity = new HttpEntity<String>(jsonString, headers);
ResponseEntity<String> response = restTemplate.postForEntity(url, entity, String.class);
return response.getBody();
}
/**
* Reads a web page and turns its contents into a string.
*
* @param url The web address of the web page to be read and converted.
* @return Web contents as a string
*/
public static void putJSONFromURL(String url) {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
HttpEntity<String> entity = new HttpEntity<String>("", headers);
restTemplate.put(url, entity, String.class);
}
public static void deleteJSONFromURL(String url){
restTemplate.delete(url);
}
}
|
silviuvergoti/pebble | pebble/src/main/java/com/mitchellbosecke/pebble/node/expression/UnaryNotExpression.java | <gh_stars>100-1000
/*
* This file is part of Pebble.
*
* Copyright (c) 2014 by <NAME>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
package com.mitchellbosecke.pebble.node.expression;
import com.mitchellbosecke.pebble.error.PebbleException;
import com.mitchellbosecke.pebble.template.EvaluationContextImpl;
import com.mitchellbosecke.pebble.template.PebbleTemplateImpl;
import static com.mitchellbosecke.pebble.utils.TypeUtils.compatibleCast;
public class UnaryNotExpression extends UnaryExpression {
@Override
public Boolean evaluate(PebbleTemplateImpl self, EvaluationContextImpl context) {
Object result = this.getChildExpression().evaluate(self, context);
if (result != null) {
if (result instanceof Boolean
|| result instanceof Number
|| result instanceof String) {
return !compatibleCast(result, Boolean.class);
}
throw new PebbleException(
null,
String.format(
"Unsupported value type %s. Expected Boolean, String, Number in \"if\" statement",
result.getClass().getSimpleName()),
this.getLineNumber(),
self.getName());
}
// input is null
if (context.isStrictVariables()) {
throw new PebbleException(null,
"null value given to not() and strict variables is set to true", this.getLineNumber(),
self.getName());
}
return true;
}
}
|
cmfitzg2/2d-horror | src/Cutscenes/MansionExteriorCutscene1.java | package Cutscenes;
import Entities.Creatures.*;
import Entities.EntityManager;
import Entities.StaticEntities.IronGate;
import Entities.StaticEntities.Mansion;
import Graphics.Assets;
import Input.KeyManager;
import Textboxes.TextboxHandler;
import Tiles.Tile;
import Utils.GeneralUtils;
import Variables.GeneralConstants;
import Variables.Handler;
import Worlds.WorldManager;
import Graphics.GameCamera;
import java.awt.*;
public class MansionExteriorCutscene1 implements Cutscene {
Player player;
private boolean firstTime = true;
private Handler handler;
private final TextboxHandler textboxHandler1, textboxHandler2, textboxHandler3, textboxHandler4, textboxHandler5,
textboxHandler6, textboxHandler7, textboxHandler8, textboxHandler9, textboxHandler10, textboxHandler11,
textboxHandler12, textboxHandler13, textboxHandler14;
private KeyManager keyManager;
private Denial denial;
private Anger anger;
private Bargaining bargaining;
private Depression depression;
private Acceptance acceptance;
private EntityManager entityManager;
private Mansion mansion;
private IronGate ironGate;
private boolean textbox1, textbox2, textbox3, textbox4, textbox5, textbox6, textbox7, textbox8, textbox9, textbox10,
textbox11, textbox12, textbox13, dialogueOver, playerOutro, playerOutroTextbox, transitioning;
private boolean acceptanceStop1Hit, acceptanceStop2Hit, acceptanceStop3Hit;
private float acceptanceXStart = 20 * Tile.TILEWIDTH + Tile.TILEWIDTH / 32f;
private float acceptanceStop1, acceptanceStop2, acceptanceStop3;
private float acceptanceYStart;
private GameCamera gameCamera;
private final String message1 = "Well, here we are.",
message2 = "Man, talk about cliché.",
message3 = "It's obvious, isn't it? \r " +
"There wouldn't be any mystique surrounding this place if it didn't fit the profile of such a place. \r " +
"In other words, if it weren't cliché, we wouldn't be here. It's a self-fulfilling prophecy.",
message4 = "...Yeah, right? Totally cliché.",
message5 = "Cliche or not, I still think we shouldn't be here...",
message6 = "Oh, hey guys, Bargaining says we shouldn't be here. Guess we're heading home. \r " +
"If only you had said something before.",
message7 = "Listen to you, droning on and on. It's like you're trying to delay going inside. \r " +
"It's alright if you're scared. We won't think less of you!",
message8 = "Shut UP! I'm not scared! The whole reason I came was to prove that!",
message9 = "I had no idea my opinion was so important to you.",
message10 = "Alright already, geez. You guys sure are at each other's throats today.",
message11 = "You did say this place brings out \"the real you\" or whatever, right?",
message12 = "Fair enough. But for all our sake, let's try to keep the quarreling to a minimum. \r " +
"So on the that note, and if you're all ready...",
message13 = "Let's head inside.",
playerOutroMessage = "... \r " +
"Honestly, I think I expected the gate to slam behind me.";
public MansionExteriorCutscene1(Handler handler) {
this.handler = handler;
keyManager = handler.getKeyManager();
textboxHandler1 = new TextboxHandler(handler, Assets.acceptanceFont, message1, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxAcceptance, Assets.acceptanceText, 50, true, false);
textboxHandler2 = new TextboxHandler(handler, Assets.depressionFont, message2, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxDepression, Assets.depressionText, 50, true, false);
textboxHandler3 = new TextboxHandler(handler, Assets.denialFont, message3, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxDenial, Assets.denialText, 50, true, false);
textboxHandler4 = new TextboxHandler(handler, Assets.depressionFont, message4, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxDepression, Assets.depressionText, 50, true, false);
textboxHandler5 = new TextboxHandler(handler, Assets.bargainingFont, message5, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxBargaining, Assets.bargainingText, 50, true, false);
textboxHandler6 = new TextboxHandler(handler, Assets.angerFont, message6, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxAnger, Assets.angerText, 50, true, false);
textboxHandler7 = new TextboxHandler(handler, Assets.depressionFont, message7, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxDepression, Assets.depressionText, 50, true, false);
textboxHandler8 = new TextboxHandler(handler, Assets.angerFont, message8, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxAnger, Assets.angerText, 50, true, false);
textboxHandler9 = new TextboxHandler(handler, Assets.depressionFont, message9, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxDepression, Assets.depressionText, 50, true, false);
textboxHandler10 = new TextboxHandler(handler, Assets.acceptanceFont, message10, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxAcceptance, Assets.acceptanceText, 50, true, false);
textboxHandler11 = new TextboxHandler(handler, Assets.playerSpeakingFont, message11, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxPlayer, Assets.playerText, 50, true, false);
textboxHandler12 = new TextboxHandler(handler, Assets.acceptanceFont, message12, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxAcceptance, Assets.acceptanceText, 50, true, false);
textboxHandler13 = new TextboxHandler(handler, Assets.acceptanceFont, message13, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxAcceptance, Assets.acceptanceText, 50, true, false);
textboxHandler14 = new TextboxHandler(handler, Assets.playerThinkingFont, playerOutroMessage, null, GeneralConstants.defaultTextSpeed, Color.WHITE, null, Assets.textboxPlayerThinking, Assets.playerText, 50, true, false);
}
@Override
public void tick() {
if (firstTime) {
if (handler.getWorldManager().getActiveWorld().getId() != WorldManager.MANSION_EXTERIOR_ID) {
return;
}
gameCamera = handler.getGameCamera();
entityManager = handler.getWorldManager().getWorld(WorldManager.MANSION_EXTERIOR_ID).getEntityManager();
denial = (Denial) entityManager.getEntityByUid(GeneralConstants.UID_DENIAL_MANSIONEXTERIOR);
anger = (Anger) entityManager.getEntityByUid(GeneralConstants.UID_ANGER_MANSIONEXTERIOR);
bargaining = (Bargaining) entityManager.getEntityByUid(GeneralConstants.UID_BARGAINING_MANSIONEXTERIOR);
depression = (Depression) entityManager.getEntityByUid(GeneralConstants.UID_DEPRESSION_MANSIONEXTERIOR);
acceptance = (Acceptance) entityManager.getEntityByUid(GeneralConstants.UID_ACCEPTANCE_MANSIONEXTERIOR);
mansion = (Mansion) entityManager.getEntityByUid(GeneralConstants.UID_MANSION_MANSIONEXTERIOR);
ironGate = (IronGate) entityManager.getEntityByUid(GeneralConstants.UID_IRONGATEBOT_MANSIONEXTERIOR);
player = handler.getPlayer();
denial.setIgnoreCollision(true);
anger.setIgnoreCollision(true);
bargaining.setIgnoreCollision(true);
depression.setIgnoreCollision(true);
acceptance.setIgnoreCollision(true);
acceptanceYStart = 27 * Tile.TILEHEIGHT;
acceptanceStop1 = acceptanceXStart + player.getWidth() + Tile.TILEWIDTH / 32f;
acceptanceStop2 = acceptanceYStart - player.getHeight() * 3;
acceptanceStop3 = acceptanceXStart - player.getWidth() / 2f;
player.setIgnoreCollision(true);
handler.setPlayerFrozen(true);
textbox1 = true;
firstTime = false;
}
if (player.getY() <= 27 * Tile.TILEHEIGHT && !handler.getGame().isFadeIn()) {
if (textbox1) {
if (!handler.getTimerManager().timerAdded("initial-mansion-timer")) {
handler.getTimerManager().addTimer("initial-mansion-timer", 60);
} else if (handler.getTimerManager().timerExpired("initial-mansion-timer")) {
if (!textboxHandler1.isFinished()) {
textboxHandler1.tick();
}
}
}
if (textbox2) {
if (gameCamera.getyOffset() > mansion.getY()) {
gameCamera.setyOffset(gameCamera.getyOffset() - 2);
} else {
if (!textboxHandler2.isFinished()) {
textboxHandler2.tick();
}
}
}
if (textbox3) {
if (!textboxHandler3.isFinished()) {
textboxHandler3.tick();
}
}
if (textbox4) {
if (!textboxHandler4.isFinished()) {
textboxHandler4.tick();
}
}
if (textbox5) {
if (!textboxHandler5.isFinished()) {
textboxHandler5.tick();
}
}
if (textbox6) {
if (!textboxHandler6.isFinished()) {
textboxHandler6.tick();
}
}
if (textbox7) {
if (!textboxHandler7.isFinished()) {
textboxHandler7.tick();
}
}
if (textbox8) {
if (!textboxHandler8.isFinished()) {
textboxHandler8.tick();
}
}
if (textbox9) {
if (!textboxHandler9.isFinished()) {
textboxHandler9.tick();
}
}
if (textbox10) {
if (!textboxHandler10.isFinished()) {
textboxHandler10.tick();
}
}
if (textbox11) {
if (!textboxHandler11.isFinished()) {
textboxHandler11.tick();
}
}
if (textbox12) {
if (!textboxHandler12.isFinished()) {
textboxHandler12.tick();
}
}
if (textbox13) {
if (!textboxHandler13.isFinished()) {
textboxHandler13.tick();
}
}
if (playerOutroTextbox) {
if (!textboxHandler14.isFinished()) {
textboxHandler14.tick();
}
}
}
}
@Override
public void render(Graphics g) {
if (firstTime || handler.getGame().isFadeIn()) {
return;
}
if (!dialogueOver) {
if (player.getY() > 27 * Tile.TILEHEIGHT) {
if (textbox1) {
denial.setyMove(-denial.getSpeed());
anger.setyMove(-anger.getSpeed());
bargaining.setyMove(-bargaining.getSpeed());
depression.setyMove(-depression.getSpeed());
acceptance.setyMove(-acceptance.getSpeed());
player.setyMove(-player.getCutsceneSpeed());
}
} else {
if (textbox1) {
denial.setyMove(0);
anger.setyMove(0);
bargaining.setyMove(0);
depression.setyMove(0);
acceptance.setyMove(0);
player.setyMove(0);
if (handler.getTimerManager().timerExpired("initial-mansion-timer")) {
if (!textboxHandler1.isFinished()) {
textboxHandler1.render(g);
} else {
textbox2 = true;
textbox1 = false;
handler.getFlags().setCameraOverride(true);
}
}
}
if (textbox2) {
if (gameCamera.getyOffset() <= mansion.getY()) {
if (!handler.getTimerManager().timerAdded("mansion-view-timer")) {
handler.getTimerManager().addTimer("mansion-view-timer", 60);
} else if (handler.getTimerManager().timerExpired("mansion-view-timer")) {
if (!textboxHandler2.isFinished()) {
textboxHandler2.render(g);
} else {
textbox3 = true;
textbox2 = false;
}
}
}
}
if (textbox3) {
if (!textboxHandler3.isFinished()) {
textboxHandler3.render(g);
} else {
textbox4 = true;
textbox3 = false;
}
}
if (textbox4) {
if (!textboxHandler4.isFinished()) {
textboxHandler4.render(g);
} else {
textbox5 = true;
textbox4 = false;
}
}
if (textbox5) {
if (!textboxHandler5.isFinished()) {
textboxHandler5.render(g);
} else {
textbox6 = true;
textbox5 = false;
}
}
if (textbox6) {
if (!textboxHandler6.isFinished()) {
textboxHandler6.render(g);
} else {
textbox7 = true;
textbox6 = false;
}
}
if (textbox7) {
if (!textboxHandler7.isFinished()) {
textboxHandler7.render(g);
} else {
textbox8 = true;
textbox7 = false;
}
}
if (textbox8) {
if (!textboxHandler8.isFinished()) {
textboxHandler8.render(g);
} else {
textbox9 = true;
textbox8 = false;
}
}
if (textbox9) {
if (!textboxHandler9.isFinished()) {
textboxHandler9.render(g);
} else {
textbox10 = true;
textbox9 = false;
}
}
if (textbox10) {
if (!textboxHandler10.isFinished()) {
textboxHandler10.render(g);
} else {
textbox11 = true;
textbox10 = false;
}
}
if (textbox11) {
if (!textboxHandler11.isFinished()) {
textboxHandler11.render(g);
} else {
textbox12 = true;
textbox11 = false;
}
}
if (textbox12) {
if (!textboxHandler12.isFinished()) {
textboxHandler12.render(g);
} else {
textbox12 = false;
textbox13 = true;
}
}
if (textbox13) {
if (gameCamera.getyOffset() < handler.getActiveWorld().getHeight() * Tile.TILEHEIGHT - handler.getHeight()) {
gameCamera.setyOffset(gameCamera.getyOffset() + 2);
} else {
handler.getFlags().setCameraOverride(false);
if (!acceptanceStop1Hit) {
if (acceptance.getX() < acceptanceStop1) {
acceptance.setxMove(acceptance.getSpeed());
} else {
acceptance.setxMove(0);
acceptanceStop1Hit = true;
}
} else if (!acceptanceStop2Hit) {
if (acceptance.getY() > acceptanceStop2) {
acceptance.setyMove(-acceptance.getSpeed());
} else {
acceptance.setyMove(0);
acceptanceStop2Hit = true;
}
} else if (!acceptanceStop3Hit) {
if (acceptance.getX() > acceptanceStop3) {
acceptance.setxMove(-acceptance.getSpeed());
} else {
acceptance.setxMove(0);
acceptanceStop3Hit = true;
acceptance.setDirection(GeneralConstants.DIR_UP);
ironGate.setOpen(true);
}
} else if (!handler.getTimerManager().timerAdded("gateopen-timer")) {
handler.getTimerManager().addTimer("gateopen-timer", 60);
} else if (handler.getTimerManager().timerExpired("gateopen-timer")) {
if (!textboxHandler13.isFinished()) {
textboxHandler13.render(g);
} else {
dialogueOver = true;
textbox13 = false;
}
}
}
}
}
} else {
if (!playerOutro) {
if (acceptance.getY() > mansion.getY() + mansion.getHeight()) {
acceptance.setyMove(-acceptance.getSpeed());
} else {
acceptance.setyMove(0);
entityManager.removeEntity(acceptance);
}
if (acceptance.getY() < acceptanceStop2 - Tile.TILEHEIGHT / 2f) {
if (denial.getY() > mansion.getY() + mansion.getHeight()) {
denial.setyMove(-denial.getSpeed());
} else {
denial.setyMove(0);
entityManager.removeEntity(denial);
}
if (anger.getY() > mansion.getY() + mansion.getHeight()) {
anger.setyMove(-anger.getSpeed());
} else {
anger.setyMove(0);
entityManager.removeEntity(anger);
}
if (anger.getY() < acceptanceStop2) {
if (bargaining.getY() > mansion.getY() + mansion.getHeight()) {
bargaining.setyMove(-bargaining.getSpeed());
} else {
bargaining.setyMove(0);
entityManager.removeEntity(bargaining);
}
if (depression.getY() > mansion.getY() + mansion.getHeight()) {
depression.setyMove(-depression.getSpeed());
} else {
depression.setyMove(0);
entityManager.removeEntity(depression);
}
if (depression.getY() < acceptanceStop2 + Tile.TILEHEIGHT / 2f) {
if (player.getY() > mansion.getY() + mansion.getHeight() + Tile.TILEHEIGHT / 2f) {
player.setyMove(-player.getCutsceneSpeed());
} else {
playerOutro = true;
player.setyMove(0);
handler.getTimerManager().addTimer("final-mansion-timer1", 60);
}
}
}
}
} else {
//player outro
if (handler.getTimerManager().timerExpired("final-mansion-timer1") && !playerOutroTextbox) {
handler.getPlayer().setDirection("down");
playerOutroTextbox = true;
}
if (playerOutroTextbox) {
if (!textboxHandler14.isFinished()) {
textboxHandler14.render(g);
} else {
if (player.getY() > mansion.getY() + mansion.getHeight()) {
player.setyMove(-player.getCutsceneSpeed());
} else {
player.setyMove(0);
if (handler.getGame().isFinishedFadingOut()) {
handler.getActiveWorld().transitionFrom(handler.getWorldManager().getWorld(WorldManager.MANSION_L2_ROOM_1_ID), 17 * Tile.TILEWIDTH + handler.getPlayer().getWidth() / 2f, 17.5f * Tile.TILEHEIGHT, GeneralConstants.longLevelTransition);
exit();
GeneralUtils.levelFadeIn(handler, GeneralConstants.longLevelTransition);
return;
}
handler.getActiveWorld().transitionFrom(handler.getWorldManager().getWorld(WorldManager.MANSION_L2_ROOM_1_ID), 17 * Tile.TILEWIDTH + handler.getPlayer().getWidth() / 2f, 17.5f * Tile.TILEHEIGHT, GeneralConstants.longLevelTransition);
if (ironGate.isOpen() && handler.getGame().getAlpha() >= 120) {
ironGate.setOpen(false);
}
}
}
}
}
}
}
@Override
public void exit() {
handler.setPlayerFrozen(false);
handler.getCutsceneManager().setActiveCutscene(null);
handler.getFlags().setCutsceneActive(false);
denial.setIgnoreCollision(false);
anger.setIgnoreCollision(false);
bargaining.setIgnoreCollision(false);
depression.setIgnoreCollision(false);
acceptance.setIgnoreCollision(false);
player.setIgnoreCollision(false);
}
}
|
Yomy1996/P1 | odoo-14.0/addons/website_event_track_quiz/__manifest__.py | # -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
{
'name': 'Quizzes on Tracks',
'category': 'Marketing/Events',
'sequence': 1007,
'version': '1.0',
'summary': 'Quizzes on tracks',
'website': 'https://www.odoo.com/page/events',
'description': "",
'depends': [
'website_profile',
'website_event_track',
],
'data': [
'security/ir.model.access.csv',
'views/assets.xml',
'views/event_leaderboard_templates.xml',
'views/event_quiz_views.xml',
'views/event_quiz_question_views.xml',
'views/event_track_views.xml',
'views/event_track_visitor_views.xml',
'views/event_menus.xml',
'views/event_quiz_templates.xml',
'views/event_track_templates_page.xml',
'views/event_event_views.xml',
'views/event_type_views.xml'
],
'demo': [
'data/quiz_demo.xml',
],
'application': False,
'installable': True,
}
|
artemaminov/spree_cropper | app/models/spree/types_dimension.rb | module Spree
class TypesDimension < Spree::Base
belongs_to :cropper_dimension, class_name: 'Spree::CropperDimension', foreign_key: 'spree_cropper_dimension_id', inverse_of: :types_dimensions
belongs_to :block_type, class_name: 'Spree::ImageCombineBlockType', foreign_key: 'spree_image_combine_block_type_id', inverse_of: :types_dimensions
end
end
|
shenkevin/B2CStore | app/src/main/java/cn/mstar/store/activity/ReturnGoodsProgressActivity.java | <gh_stars>1-10
package cn.mstar.store.activity;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.RelativeLayout;
import android.widget.TextView;
import com.google.gson.Gson;
import com.google.gson.JsonElement;
import com.nostra13.universalimageloader.core.ImageLoader;
import butterknife.Bind;
import butterknife.ButterKnife;
import butterknife.OnClick;
import cn.mstar.store.R;
import cn.mstar.store.app.MyApplication;
import cn.mstar.store.customviews.LoadingDialog;
import cn.mstar.store.entity.ReturnGoodProgressEntity;
import cn.mstar.store.utils.ImageLoadOptions;
import cn.mstar.store.utils.L;
import cn.mstar.store.utils.NewLink;
import cn.mstar.store.utils.Utils;
import cn.mstar.store.utils.VolleyRequest;
public class ReturnGoodsProgressActivity extends AppCompatActivity {
// 进度条
@Bind(R.id.progress_1) RelativeLayout rel_progress_1;
@Bind(R.id.progress_2) RelativeLayout rel_progress_2;
@Bind(R.id.progress_3) RelativeLayout rel_progress_3;
// 进度按钮
@Bind(R.id.icon_progress_1) ImageView iv_icon_progress_1;
@Bind(R.id.icon_progress_2) ImageView iv_icon_progress_2;
@Bind(R.id.icon_progress_3) ImageView iv_icon_progress_3;
@Bind(R.id.icon_progress_4) ImageView iv_icon_progress_4;
public void setMyTitle(String title) {
tv_title.setText(title);
}
int proId = -1;
String orderId = "";
public static final String PROID = "PROID", ORDERID = "ORDERID";
private Gson gson;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_return_goods_progress);
Utils.setNavigationBarColor(this, getResources().getColor(R.color.status_bar_color));
Utils.setStatusBarColor(this, getResources().getColor(R.color.status_bar_color));
// inflate the data with the content of the data.
ButterKnife.bind(this);
setMyTitle(getString(R.string.request_sendback));
setAllGray();
gson = new Gson();
iv_back.setVisibility(View.VISIBLE);
proId = getIntent().getIntExtra(PROID, 1);
orderId = getIntent().getStringExtra(ORDERID);
loadInfo(proId, orderId);
}
private void loadInfo(int proId, String orderId) {
i_showProgressDialog();
String link = NewLink.RETURN_PRODUCT_PROGRESS+"&key="+ Utils.getTokenKey((MyApplication) getApplication())+"&orderNo="+orderId+"&proId="+proId;
L.d("progress:::", link);
VolleyRequest.GetCookieRequest(this, link, new VolleyRequest.HttpStringRequsetCallBack() {
@Override
public void onSuccess(String result) {
L.d("progress:::", result);
try {
JsonElement elm = gson.fromJson(result, JsonElement.class).getAsJsonObject().get("error");
if ("0".equals(elm.getAsString())) {
makeToast("可以解析");
ReturnGoodProgressEntity entity = gson.fromJson(gson.fromJson(result, JsonElement.class).getAsJsonObject().get("data").getAsJsonObject(), ReturnGoodProgressEntity.class);
entity.message = entity.message.replaceAll("'$|^'", "");
L.d("progress:::", entity.toString());
inflateData(entity);
} else {
makeToast("请求有错误");
finish();
}
// orderDetailsEntity = gson.fromJson(elm, OrderDetailsEntity.class);
} catch (Exception e) {
e.printStackTrace();
makeToast("请求有错误");
finish();
} finally {
// i_dismissProgressDialog();
}
}
@Override
public void onFail(String error) {
makeToast(getString(R.string.network_error));
i_dismissProgressDialog();
finish();
}
});
}
// view
@Bind(R.id.tv_order_id) TextView tv_order_id;
@Bind(R.id.tv_date) TextView tv_date;
// 自动添加
@Bind(R.id.lny_logistic_details) LinearLayout lny_logistic_details;
@Bind(R.id.lny_about_product) LinearLayout lny_about_product;
@Bind(R.id.lny_problem_description) LinearLayout lny_problem_description;
private void inflateData(ReturnGoodProgressEntity entity) {
setState(Integer.valueOf(entity.totalInfo.states));
tv_date.setText(entity.receiverInfo.add_time);
tv_order_id.setText(entity.totalInfo.orderNo);
// 物流信息
TextView tv_postName = new TextView(this);
tv_postName.setText(getString(R.string.postname)+entity.receiverInfo.postName); // 收货人
TextView tv_address = new TextView(this);
tv_address.setText(getString(R.string.adress)+entity.receiverInfo.address); // 地址
TextView tv_eship_name = new TextView(this);
tv_eship_name.setText(getString(R.string.e_ship_company)+entity.receiverInfo.e_name); // 快递公司
TextView tv_eship_code = new TextView(this);
tv_eship_code.setText(getString(R.string.e_ship_code)+" "); // 运单号码
TextView tv_eship_resume = new TextView(this);
tv_eship_resume.setText(getString(R.string.tv_eship_resume)+""); // 运单号码
lny_logistic_details.addView(tv_postName);
lny_logistic_details.addView(tv_address);
lny_logistic_details.addView(tv_eship_name);
lny_logistic_details.addView(tv_eship_code);
lny_logistic_details.addView(tv_eship_resume);
// 关联产品
TextView tv_product_name = new TextView(this);
tv_product_name.setText(getString(R.string.product_name) + entity.proInfo[0].pName); // 产品名称
TextView tv_product_specials = new TextView(this);
tv_product_specials.setText(getString(R.string.product_specials)+entity.proInfo[0].specialTitle); // 产品规格
TextView tv_product_idnumber = new TextView(this);
tv_product_idnumber.setText(getString(R.string.product_idnumber)+proId/**/); // 产品单号
lny_about_product.addView(tv_product_name);
lny_about_product.addView(tv_product_specials);
lny_about_product.addView(tv_product_idnumber);
// 问题描述
TextView tv_message = new TextView(this);
tv_message.setText(getString(R.string.problem_description1)+entity.message); // 产品单号
lny_problem_description.addView(tv_message);
i_dismissProgressDialog();
}
private void makeToast(String message) {
// Toast.makeText(this, message, Toast.LENGTH_SHORT).show();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_return_goods_progress, menu);
return true;
}
LoadingDialog dialog;
public void i_showProgressDialog() {
dialog = new LoadingDialog(this);
dialog.show();
}
public void i_dismissProgressDialog () {
if (dialog != null) {
dialog.cancel();
dialog.dismiss();
dialog = null;
}
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
//noinspection SimplifiableIfStatement
if (id == R.id.action_settings) {
return true;
}
return super.onOptionsItemSelected(item);
}
public void setState (int i) {
// 一共有四个状态、 1.提交 2. 审核中 3. 退款中 4. 完成
// 把全进度条都变成灰色的
setAllGray ();
//
String uri_1 = "drawable://"+R.drawable.progress_down;
String uri_0 = "drawable://"+R.drawable.progress_norm;
switch (i) {
case 1:
ImageLoader.getInstance().displayImage(uri_1, iv_icon_progress_1, ImageLoadOptions.getOptions());
break;
case 2:
rel_progress_1.setBackgroundResource(R.color.green);
ImageLoader.getInstance().displayImage(uri_0, iv_icon_progress_1, ImageLoadOptions.getOptions());
ImageLoader.getInstance().displayImage(uri_1, iv_icon_progress_2, ImageLoadOptions.getOptions());
break;
case 3:
rel_progress_1.setBackgroundResource(R.color.green);
rel_progress_2.setBackgroundResource(R.color.green);
ImageLoader.getInstance().displayImage(uri_0, iv_icon_progress_1, ImageLoadOptions.getOptions());
ImageLoader.getInstance().displayImage(uri_0, iv_icon_progress_2, ImageLoadOptions.getOptions());
ImageLoader.getInstance().displayImage(uri_1, iv_icon_progress_3, ImageLoadOptions.getOptions());
break;
case 4:
rel_progress_1.setBackgroundResource(R.color.green);
rel_progress_2.setBackgroundResource(R.color.green);
rel_progress_3.setBackgroundResource(R.color.green);
ImageLoader.getInstance().displayImage(uri_0, iv_icon_progress_1, ImageLoadOptions.getOptions());
ImageLoader.getInstance().displayImage(uri_0, iv_icon_progress_2, ImageLoadOptions.getOptions());
ImageLoader.getInstance().displayImage(uri_0, iv_icon_progress_3, ImageLoadOptions.getOptions());
ImageLoader.getInstance().displayImage(uri_1, iv_icon_progress_4, ImageLoadOptions.getOptions());
break;
}
}
private void setAllGray() {
/* @Bind(R.id.progress_1) RelativeLayout rel_progress_1;
@Bind(R.id.progress_2) RelativeLayout rel_progress_2;
@Bind(R.id.progress_3) RelativeLayout rel_progress_3;
// 进度按钮
@Bind(R.id.icon_progress_1) ImageView iv_icon_progress_1;
@Bind(R.id.icon_progress_2) ImageView iv_icon_progress_2;
@Bind(R.id.icon_progress_3) ImageView iv_icon_progress_3;
@Bind(R.id.icon_progress_4) ImageView iv_icon_progress_4;
*/
rel_progress_1.setBackgroundResource(R.color.page_background);
rel_progress_2.setBackgroundResource(R.color.page_background);
rel_progress_3.setBackgroundResource(R.color.page_background);
String uri = "drawable://"+R.drawable.icon_graycircle;
ImageLoader.getInstance().displayImage(uri, iv_icon_progress_1, ImageLoadOptions.getOptions());
ImageLoader.getInstance().displayImage(uri, iv_icon_progress_2, ImageLoadOptions.getOptions());
ImageLoader.getInstance().displayImage(uri, iv_icon_progress_3, ImageLoadOptions.getOptions());
ImageLoader.getInstance().displayImage(uri, iv_icon_progress_4, ImageLoadOptions.getOptions());
return;
}
//actionbar
@OnClick(R.id.title_back)
public void back () {
finish ();
}
@Bind(R.id.title_back) ImageView iv_back;
@Bind(R.id.title_name) TextView tv_title;
@Override
public void finish() {
super.finish();
overridePendingTransition(R.anim.slide_in_left, R.anim.slide_out_right);
}
}
|
debitan/Ndesign | src/pages/checkout.js | <filename>src/pages/checkout.js
import React, { useState } from 'react'
import styled from 'styled-components'
import { Elements } from 'react-stripe-elements'
import App from '../components/App'
import CheckoutForm from '../components/CheckoutForm'
import MyContext from '../components/MyContext'
import CustomerInformationForm from '../components/CustomerInformationForm'
import Confirmation from '../components/Cart/Confirmation'
import StyledHr from '../components/shared/StyledHr'
import MobileHr from '../components/shared/MobileHr'
import CheckoutDivider from '../components/shared/CheckoutDivider'
import CartProduct from '../components/CartProduct'
import NoItems from '../components/NoItems'
import shoppingCartIcon from '../images/shoppingCartIcon.svg'
import deliveryIcon from '../images/deliveryIcon.svg'
import paymentIcon from '../images/paymentIcon.svg'
const StyledWrapper = styled('div')`
display: grid;
grid-template-columns: minmax(0, 1fr);
grid-gap: 15px;
grid-auto-rows: minmax(100px, auto);
margin: 40px 0 40px 0;
margin-left: calc(50% - 50vw);
margin-right: calc(50% - 50vw);
@media (min-width: 480px) {
margin-left: 0;
margin-right: 0;
}
@media (min-width: 992px) {
grid-template-columns: 2fr 1fr;
}
`
const LeftSide = styled('div')`
grid-column: 1;
border: 1px solid #979797;
padding: 15px;
div :first-child {
padding-top: 15px;
}
`
const RightSide = styled('div')`
grid-column: 1;
border: 1px solid #979797;
grid-row: 1;
padding: 15px;
top: 95px;
height: fit-content;
@media (min-width: 992px) {
grid-column: 2;
position: sticky;
}
`
const CostContainer = styled('div')`
display: flex;
justify-content: space-between;
`
const TotalCostContainer = styled(CostContainer)`
justify-content: flex-end;
`
const Gokei = styled('div')`
padding-top: 15px;
`
function Checkout() {
const [kanjiName, setKanjiName] = useState('')
const [furiganaName, setFuriganaName] = useState('')
const [email, setEmail] = useState('')
const [postcode, setPostcode] = useState('')
const [prefecture, setPrefecture] = useState('')
const [addressLine1, setAddressLine1] = useState('')
const [addressLine2, setAddressLine2] = useState('')
const [phone, setPhone] = useState('')
const [confirmed, setConfirmed] = useState(false)
const [last4, setLast4] = useState('')
const [orderId, setOrderId] = useState('')
return (
<MyContext.Consumer>
{context => (
<App>
{confirmed ? (<Confirmation
orderId={orderId || 'abc12345678'}
last4={last4 || '1234'}
kanjiName={kanjiName}
postcode={postcode}
addressLine1={addressLine1}
addressLine2={addressLine2}
phone={phone}
totalCost={context.totalCost}
/>) : context.quantityOfItemsInBasket() === 0 ? (
<NoItems />
) : (
<StyledWrapper>
<LeftSide>
<CheckoutDivider
icon={shoppingCartIcon}
title='Cart'
JPTitle='ショッピングカート'
background={true}
/>
{context.itemsInBasket ? context.itemsInBasket.map(item => {
return (
<CartProduct
key={item.title}
title={item.title}
slug={item.slug}
price={item.price}
flower={item.flower}
type={item.type}
size={item.size}
quantity={item.quantity}
image={item.image}
updateQuantity={context.updateQuantity}
deleteProduct={context.deleteProduct}
/>)
}) : null}
</LeftSide>
<Elements>
<>
<LeftSide>
<CheckoutDivider
icon={deliveryIcon}
title='Delivery'
JPTitle='送付先'
background={true}
/>
<CustomerInformationForm
setKanjiName={setKanjiName}
setFuriganaName={setFuriganaName}
setEmail={setEmail}
setPostcode={setPostcode}
setPrefecture={setPrefecture}
setAddressLine1={setAddressLine1}
setAddressLine2={setAddressLine2}
setPhone={setPhone}
/>
</LeftSide>
<LeftSide>
<CheckoutDivider
icon={paymentIcon}
title='Payment'
JPTitle='結済方法'
background={true}
/>
<CheckoutForm
totalCost={context.totalCost + 1000}
kanjiName={kanjiName}
furiganaName={furiganaName}
email={email}
postcode={postcode}
prefecture={prefecture}
addressLine1={addressLine1}
addressLine2={addressLine2}
phone={phone}
setConfirmed={setConfirmed}
setLast4={setLast4}
setOrderId={setOrderId}
/>
</LeftSide>
</>
</Elements>
<RightSide>
<CheckoutDivider
singleTitle='合計'
background={true}
/>
<Gokei>
<CostContainer>
<h5>商品合計</h5>
<h5>¥{Number(context.totalCost).toLocaleString('jp')}</h5>
</CostContainer>
<CostContainer>
<span>送料 全国一律</span>
<span>¥1,000</span>
</CostContainer>
<StyledHr/>
<MobileHr />
<TotalCostContainer>
<h3>¥{Number(context.totalCost + 1000).toLocaleString('jp')}</h3>
</TotalCostContainer>
<button onClick={() => setConfirmed(true)}>Force confirmation</button>
</Gokei>
</RightSide>
</StyledWrapper>
)}
</App>
)}
</MyContext.Consumer>
)
}
export default Checkout
|
DeadZoneLuna/csso-src | src/game/shared/activitylist.cpp | //========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include "cbase.h"
#include "ai_activity.h"
#include "activitylist.h"
#include "stringregistry.h"
#include "isaverestore.h"
#include "filesystem.h"
#include <KeyValues.h>
#include "utldict.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
extern IFileSystem *filesystem;
// NOTE: If CStringRegistry allowed storing arbitrary data, we could just use that.
// in this case we have the "isPrivate" member and the replacement rules
// (activityIndex can be reused by private activities), so a custom table is necessary
struct activitylist_t
{
int activityIndex;
unsigned short stringKey;
short isPrivate;
};
CUtlVector<activitylist_t> g_ActivityList;
static CUtlDict< CActivityRemapCache, int > m_ActivityRemapDatabase;
// This stores the actual activity names. Also, the string ID in the registry is simply an index
// into the g_ActivityList array.
CStringRegistry g_ActivityStrings;
// this is just here to accelerate adds
static int g_HighestActivity = 0;
int g_nActivityListVersion = 1;
void ActivityList_Init( void )
{
g_HighestActivity = 0;
}
void ActivityList_Free( void )
{
g_ActivityStrings.ClearStrings();
g_ActivityList.Purge();
m_ActivityRemapDatabase.Purge();
// So studiohdrs can reindex activity indices
++g_nActivityListVersion;
}
// add a new activity to the database
activitylist_t *ActivityList_AddActivityEntry( const char *pName, int iActivityIndex, bool isPrivate )
{
MEM_ALLOC_CREDIT();
int index = g_ActivityList.AddToTail();
activitylist_t *pList = &g_ActivityList[index];
pList->activityIndex = iActivityIndex;
pList->stringKey = g_ActivityStrings.AddString( pName, index );
pList->isPrivate = isPrivate;
// UNDONE: This implies that ALL shared activities are added before ANY custom activities
// UNDONE: Segment these instead? It's a 32-bit int, how many activities do we need?
if ( iActivityIndex > g_HighestActivity )
{
g_HighestActivity = iActivityIndex;
}
return pList;
}
// get the database entry from a string
static activitylist_t *ListFromString( const char *pString )
{
// just use the string registry to do this search/map
int stringID = g_ActivityStrings.GetStringID( pString );
if ( stringID < 0 )
return NULL;
return &g_ActivityList[stringID];
}
// Get the database entry for an index
static activitylist_t *ListFromActivity( int activityIndex )
{
// ugly linear search
for ( int i = 0; i < g_ActivityList.Size(); i++ )
{
if ( g_ActivityList[i].activityIndex == activityIndex )
{
return &g_ActivityList[i];
}
}
return NULL;
}
bool ActivityList_RegisterSharedActivity( const char *pszActivityName, int iActivityIndex )
{
// UNDONE: Do we want to do these checks when not in developer mode? or maybe DEBUG only?
// They really only matter when you change the list of code controlled activities. IDs
// for content controlled activities never collide because they are generated.
// technically order isn't dependent, but it's too damn easy to forget to add new ACT_'s to all three lists.
static int lastActivityIndex = -1;
Assert( iActivityIndex < LAST_SHARED_ACTIVITY && (iActivityIndex == lastActivityIndex + 1 || iActivityIndex == 0) );
lastActivityIndex = iActivityIndex;
// first, check to make sure the slot we're asking for is free. It must be for
// a shared activity.
activitylist_t *pList = ListFromString( pszActivityName );
if ( !pList )
{
pList = ListFromActivity( iActivityIndex );
}
if ( pList )
{
Warning( "***\nShared activity collision! %s<->%s\n***\n", pszActivityName, g_ActivityStrings.GetStringForKey( pList->stringKey ) );
Assert(0);
return false;
}
// ----------------------------------------------------------------
ActivityList_AddActivityEntry( pszActivityName, iActivityIndex, false );
return true;
}
Activity ActivityList_RegisterPrivateActivity( const char *pszActivityName )
{
activitylist_t *pList = ListFromString( pszActivityName );
if ( pList )
{
// this activity is already in the list. If the activity we collided with is also private,
// then the collision is OK. Otherwise, it's a bug.
if ( pList->isPrivate )
{
return (Activity)pList->activityIndex;
}
else
{
// this private activity collides with a shared activity. That is not allowed.
Warning( "***\nShared<->Private Activity collision!\n***\n" );
Assert(0);
return ACT_INVALID;
}
}
pList = ActivityList_AddActivityEntry( pszActivityName, g_HighestActivity+1, true );
return (Activity)pList->activityIndex;
}
// Get the index for a given activity name
// Done at load time for all models
int ActivityList_IndexForName( const char *pszActivityName )
{
// this is a fast O(lgn) search (actually does 2 O(lgn) searches)
activitylist_t *pList = ListFromString( pszActivityName );
if ( pList )
{
return pList->activityIndex;
}
return kActivityLookup_Missing;
}
// Get the name for a given index
// This should only be used in debug code, it does a linear search
// But at least it only compares integers
const char *ActivityList_NameForIndex( int activityIndex )
{
activitylist_t *pList = ListFromActivity( activityIndex );
if ( pList )
{
return g_ActivityStrings.GetStringForKey( pList->stringKey );
}
return NULL;
}
void ActivityList_RegisterSharedActivities( void )
{
REGISTER_SHARED_ACTIVITY( ACT_RESET );
REGISTER_SHARED_ACTIVITY( ACT_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_TRANSITION );
REGISTER_SHARED_ACTIVITY( ACT_COVER );
REGISTER_SHARED_ACTIVITY( ACT_COVER_MED );
REGISTER_SHARED_ACTIVITY( ACT_COVER_LOW );
REGISTER_SHARED_ACTIVITY( ACT_WALK );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM );
REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH );
REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH_AIM );
REGISTER_SHARED_ACTIVITY( ACT_RUN );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM );
REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH );
REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH_AIM );
REGISTER_SHARED_ACTIVITY( ACT_RUN_PROTECTED );
REGISTER_SHARED_ACTIVITY( ACT_SCRIPT_CUSTOM_MOVE );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK1 );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK2 );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK1_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK2_LOW );
REGISTER_SHARED_ACTIVITY( ACT_DIESIMPLE );
REGISTER_SHARED_ACTIVITY( ACT_DIEBACKWARD );
REGISTER_SHARED_ACTIVITY( ACT_DIEFORWARD );
REGISTER_SHARED_ACTIVITY( ACT_DIEVIOLENT );
REGISTER_SHARED_ACTIVITY( ACT_DIERAGDOLL );
REGISTER_SHARED_ACTIVITY( ACT_FLY );
REGISTER_SHARED_ACTIVITY( ACT_HOVER );
REGISTER_SHARED_ACTIVITY( ACT_GLIDE );
REGISTER_SHARED_ACTIVITY( ACT_SWIM );
REGISTER_SHARED_ACTIVITY( ACT_JUMP );
REGISTER_SHARED_ACTIVITY( ACT_HOP );
REGISTER_SHARED_ACTIVITY( ACT_LEAP );
REGISTER_SHARED_ACTIVITY( ACT_LAND );
REGISTER_SHARED_ACTIVITY( ACT_CLIMB_UP );
REGISTER_SHARED_ACTIVITY( ACT_CLIMB_DOWN );
REGISTER_SHARED_ACTIVITY( ACT_CLIMB_DISMOUNT );
REGISTER_SHARED_ACTIVITY( ACT_SHIPLADDER_UP );
REGISTER_SHARED_ACTIVITY( ACT_SHIPLADDER_DOWN );
REGISTER_SHARED_ACTIVITY( ACT_STRAFE_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_STRAFE_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_ROLL_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_ROLL_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_TURN_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_TURN_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_CROUCH );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHIDLE );
REGISTER_SHARED_ACTIVITY( ACT_STAND );
REGISTER_SHARED_ACTIVITY( ACT_USE );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL1 );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL2 );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL3 );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_ADVANCE );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_FORWARD );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_GROUP );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_HALT );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_SIGNAL_TAKECOVER );
REGISTER_SHARED_ACTIVITY( ACT_LOOKBACK_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_LOOKBACK_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_COWER );
REGISTER_SHARED_ACTIVITY( ACT_SMALL_FLINCH );
REGISTER_SHARED_ACTIVITY( ACT_BIG_FLINCH );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK1 );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK2 );
REGISTER_SHARED_ACTIVITY( ACT_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_RELOAD_START );
REGISTER_SHARED_ACTIVITY( ACT_RELOAD_FINISH );
REGISTER_SHARED_ACTIVITY( ACT_RELOAD_LOW );
REGISTER_SHARED_ACTIVITY( ACT_ARM );
REGISTER_SHARED_ACTIVITY( ACT_DISARM );
REGISTER_SHARED_ACTIVITY( ACT_DROP_WEAPON );
REGISTER_SHARED_ACTIVITY( ACT_DROP_WEAPON_SHOTGUN );
REGISTER_SHARED_ACTIVITY( ACT_PICKUP_GROUND );
REGISTER_SHARED_ACTIVITY( ACT_PICKUP_RACK );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_AGITATED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_STEALTH );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_HURT );
REGISTER_SHARED_ACTIVITY( ACT_WALK_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AGITATED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_STEALTH );
REGISTER_SHARED_ACTIVITY( ACT_RUN_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AGITATED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_STEALTH );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_AGITATED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_STEALTH );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_AGITATED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_STEALTH );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_AGITATED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_STEALTH );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHIDLE_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHIDLE_AIM_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHIDLE_AGITATED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_HURT );
REGISTER_SHARED_ACTIVITY( ACT_RUN_HURT );
REGISTER_SHARED_ACTIVITY( ACT_SPECIAL_ATTACK1 );
REGISTER_SHARED_ACTIVITY( ACT_SPECIAL_ATTACK2 );
REGISTER_SHARED_ACTIVITY( ACT_COMBAT_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_WALK_SCARED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_SCARED );
REGISTER_SHARED_ACTIVITY( ACT_VICTORY_DANCE );
REGISTER_SHARED_ACTIVITY( ACT_DIE_HEADSHOT );
REGISTER_SHARED_ACTIVITY( ACT_DIE_CHESTSHOT );
REGISTER_SHARED_ACTIVITY( ACT_DIE_GUTSHOT );
REGISTER_SHARED_ACTIVITY( ACT_DIE_BACKSHOT );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_HEAD );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CHEST );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_STOMACH );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_LEFTARM );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_RIGHTARM );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_LEFTLEG );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_RIGHTLEG );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_PHYSICS );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_HEAD_BACK );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_HEAD_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_HEAD_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CHEST_BACK );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_STOMACH_BACK );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CROUCH_FRONT );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CROUCH_BACK );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CROUCH_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_FLINCH_CROUCH_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_ON_FIRE );
REGISTER_SHARED_ACTIVITY( ACT_WALK_ON_FIRE );
REGISTER_SHARED_ACTIVITY( ACT_RUN_ON_FIRE );
REGISTER_SHARED_ACTIVITY( ACT_RAPPEL_LOOP );
REGISTER_SHARED_ACTIVITY( ACT_180_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_180_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_90_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_90_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_STEP_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_STEP_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_STEP_BACK );
REGISTER_SHARED_ACTIVITY( ACT_STEP_FORE );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK1 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK2 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_MELEE_ATTACK1 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_MELEE_ATTACK2 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK1_LOW );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK2_LOW );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_SWING_GESTURE );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_SMALL_FLINCH );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_BIG_FLINCH );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_BLAST );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_BLAST_SHOTGUN );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_BLAST_DAMAGED );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_BLAST_DAMAGED_SHOTGUN );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_HEAD );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_CHEST );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_STOMACH );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_LEFTARM );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_RIGHTARM );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_LEFTLEG );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_FLINCH_RIGHTLEG );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT45 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT45 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT90 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT90 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT45_FLAT );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT45_FLAT );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_LEFT90_FLAT );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_TURN_RIGHT90_FLAT );
// registered for Half-Life HGRUNT compatability
REGISTER_SHARED_ACTIVITY( ACT_BARNACLE_HIT );
REGISTER_SHARED_ACTIVITY( ACT_BARNACLE_PULL );
REGISTER_SHARED_ACTIVITY( ACT_BARNACLE_CHOMP );
REGISTER_SHARED_ACTIVITY( ACT_BARNACLE_CHEW );
REGISTER_SHARED_ACTIVITY( ACT_DO_NOT_DISTURB );
// Viewmodel activities may belong elsewhere, but since where is unclear right now,
// they'll be placed here.
REGISTER_SHARED_ACTIVITY( ACT_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_VM_FIDGET );
REGISTER_SHARED_ACTIVITY( ACT_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_VM_PULLBACK_HIGH );
REGISTER_SHARED_ACTIVITY( ACT_VM_PULLBACK_LOW );
REGISTER_SHARED_ACTIVITY( ACT_VM_THROW );
REGISTER_SHARED_ACTIVITY( ACT_VM_PULLPIN );
REGISTER_SHARED_ACTIVITY( ACT_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_VM_SECONDARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_VM_RELOAD_START );
REGISTER_SHARED_ACTIVITY( ACT_VM_RELOAD_FINISH );
REGISTER_SHARED_ACTIVITY( ACT_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_VM_HITLEFT );
REGISTER_SHARED_ACTIVITY( ACT_VM_HITLEFT2 );
REGISTER_SHARED_ACTIVITY( ACT_VM_HITRIGHT );
REGISTER_SHARED_ACTIVITY( ACT_VM_HITRIGHT2 );
REGISTER_SHARED_ACTIVITY( ACT_VM_HITCENTER );
REGISTER_SHARED_ACTIVITY( ACT_VM_HITCENTER2 );
REGISTER_SHARED_ACTIVITY( ACT_VM_MISSLEFT );
REGISTER_SHARED_ACTIVITY( ACT_VM_MISSLEFT2 );
REGISTER_SHARED_ACTIVITY( ACT_VM_MISSRIGHT );
REGISTER_SHARED_ACTIVITY( ACT_VM_MISSRIGHT2 );
REGISTER_SHARED_ACTIVITY( ACT_VM_MISSCENTER );
REGISTER_SHARED_ACTIVITY( ACT_VM_MISSCENTER2 );
REGISTER_SHARED_ACTIVITY( ACT_VM_HAULBACK );
REGISTER_SHARED_ACTIVITY( ACT_VM_SWINGHARD );
REGISTER_SHARED_ACTIVITY( ACT_VM_SWINGMISS );
REGISTER_SHARED_ACTIVITY( ACT_VM_SWINGHIT );
REGISTER_SHARED_ACTIVITY( ACT_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_VM_RECOIL1 );
REGISTER_SHARED_ACTIVITY( ACT_VM_RECOIL2 );
REGISTER_SHARED_ACTIVITY( ACT_VM_RECOIL3 );
REGISTER_SHARED_ACTIVITY( ACT_VM_PICKUP );
REGISTER_SHARED_ACTIVITY( ACT_VM_RELEASE );
REGISTER_SHARED_ACTIVITY ( ACT_VM_ATTACH_SILENCER );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DETACH_SILENCER );
// TF2 Scout Pack
REGISTER_SHARED_ACTIVITY ( ACT_VM_DRAW_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_HOLSTER_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PULLBACK_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_SECONDARYATTACK_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_HITCENTER_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_SWINGHARD_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_TO_LOWERED_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_LOWERED_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_LOWERED_TO_IDLE_SPECIAL );
REGISTER_SHARED_ACTIVITY ( ACT_FISTS_VM_HITLEFT );
REGISTER_SHARED_ACTIVITY ( ACT_FISTS_VM_HITRIGHT );
REGISTER_SHARED_ACTIVITY ( ACT_FISTS_VM_SWINGHARD );
REGISTER_SHARED_ACTIVITY ( ACT_FISTS_VM_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_FISTS_VM_DRAW );
//===========================
// HL2 Specific Activities
//===========================
// SLAM Specialty Activites
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_IDLE);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ND_IDLE);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ATTACH);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ATTACH2);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ND_ATTACH);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ND_ATTACH2);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_DETONATE);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_DETONATOR_HOLSTER);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_DRAW);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_ND_DRAW);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_TO_THROW);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_TO_THROW_ND);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_STICKWALL_TO_TRIPMINE_ND );
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_IDLE);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_ND_IDLE);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_THROW);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_THROW2);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_THROW_ND);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_THROW_ND2);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_DRAW);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_ND_DRAW);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_TO_STICKWALL);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_TO_STICKWALL_ND);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_DETONATE);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_DETONATOR_HOLSTER);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_THROW_TO_TRIPMINE_ND );
REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_IDLE);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_DRAW);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_ATTACH);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_ATTACH2);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_TO_STICKWALL_ND );
REGISTER_SHARED_ACTIVITY( ACT_SLAM_TRIPMINE_TO_THROW_ND );
REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_IDLE);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_DRAW);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_DETONATE);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_HOLSTER);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_STICKWALL_DRAW);
REGISTER_SHARED_ACTIVITY( ACT_SLAM_DETONATOR_THROW_DRAW);
// SHOTGUN specialty activities
REGISTER_SHARED_ACTIVITY( ACT_SHOTGUN_RELOAD_START);
REGISTER_SHARED_ACTIVITY( ACT_SHOTGUN_RELOAD_FINISH);
REGISTER_SHARED_ACTIVITY( ACT_SHOTGUN_PUMP);
// SMG2 special activities
REGISTER_SHARED_ACTIVITY( ACT_SMG2_IDLE2 );
REGISTER_SHARED_ACTIVITY( ACT_SMG2_FIRE2 );
REGISTER_SHARED_ACTIVITY( ACT_SMG2_DRAW2 );
REGISTER_SHARED_ACTIVITY( ACT_SMG2_RELOAD2 );
REGISTER_SHARED_ACTIVITY( ACT_SMG2_DRYFIRE2 );
REGISTER_SHARED_ACTIVITY( ACT_SMG2_TOAUTO );
REGISTER_SHARED_ACTIVITY( ACT_SMG2_TOBURST );
// Physcannon special activities
REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_UPGRADE );
// weapon override activities
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_AR1 );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_AR2 );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_AR2_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_AR2_GRENADE );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_HMG1 );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_ML );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SMG1 );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SMG1_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SMG2 );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SHOTGUN );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SHOTGUN_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_PISTOL_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SLAM );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_TRIPWIRE );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_THROW );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_SNIPER_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_ATTACK_RPG );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_SWING );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_AIM_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_AIM_SMG1_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_AIM_PISTOL_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RANGE_AIM_AR2_LOW );
REGISTER_SHARED_ACTIVITY( ACT_COVER_PISTOL_LOW );
REGISTER_SHARED_ACTIVITY( ACT_COVER_SMG1_LOW );
// weapon override activities
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_AR1 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_AR2 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_AR2_GRENADE );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_HMG1 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_ML );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SMG1 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SMG1_LOW );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SMG2 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SHOTGUN );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_PISTOL_LOW );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SLAM );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_TRIPWIRE );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_THROW );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RANGE_ATTACK_SNIPER_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_MELEE_ATTACK_SWING );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_SMG1 );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_SMG1 );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_SHOTGUN );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_STEALTH_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_PACKAGE );
REGISTER_SHARED_ACTIVITY( ACT_WALK_PACKAGE );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_SUITCASE );
REGISTER_SHARED_ACTIVITY( ACT_WALK_SUITCASE );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_SMG1_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_SMG1_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_RIFLE_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_RIFLE_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_RIFLE_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_RIFLE_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_AIM_RIFLE_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_RIFLE_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_RIFLE_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_SHOTGUN_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_SHOTGUN_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_SHOTGUN_AGITATED );
// Policing activities
REGISTER_SHARED_ACTIVITY( ACT_WALK_ANGRY );
REGISTER_SHARED_ACTIVITY( ACT_POLICE_HARASS1 );
REGISTER_SHARED_ACTIVITY( ACT_POLICE_HARASS2 );
// Manned guns
REGISTER_SHARED_ACTIVITY( ACT_IDLE_MANNEDGUN );
// Melee weapon activities
REGISTER_SHARED_ACTIVITY( ACT_IDLE_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_MELEE );
// RPG activities
REGISTER_SHARED_ACTIVITY( ACT_IDLE_RPG_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_RPG );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_ANGRY_RPG );
REGISTER_SHARED_ACTIVITY( ACT_COVER_LOW_RPG );
REGISTER_SHARED_ACTIVITY( ACT_WALK_RPG );
REGISTER_SHARED_ACTIVITY( ACT_RUN_RPG );
REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH_RPG );
REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH_RPG );
REGISTER_SHARED_ACTIVITY( ACT_WALK_RPG_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_RUN_RPG_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_WALK_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_WALK_CROUCH_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_RUN_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_RUN_CROUCH_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY( ACT_RUN_STEALTH_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_SHOTGUN );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_SHOTGUN );
REGISTER_SHARED_ACTIVITY( ACT_WALK_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_RUN_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_WALK_STEALTH_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_WALK_AIM_STEALTH_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_RUN_AIM_STEALTH_PISTOL );
// Reloads
REGISTER_SHARED_ACTIVITY( ACT_RELOAD_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_RELOAD_PISTOL_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RELOAD_SMG1 );
REGISTER_SHARED_ACTIVITY( ACT_RELOAD_SMG1_LOW );
REGISTER_SHARED_ACTIVITY( ACT_RELOAD_SHOTGUN );
REGISTER_SHARED_ACTIVITY( ACT_RELOAD_SHOTGUN_LOW );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RELOAD_PISTOL );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RELOAD_SMG1 );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_RELOAD_SHOTGUN );
// Busy animations
REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_LEFT );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_LEFT_ENTRY );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_LEFT_EXIT );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_BACK );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_BACK_ENTRY );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_LEAN_BACK_EXIT );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_GROUND );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_GROUND_ENTRY );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_GROUND_EXIT );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_CHAIR );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_CHAIR_ENTRY );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_SIT_CHAIR_EXIT );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_STAND );
REGISTER_SHARED_ACTIVITY( ACT_BUSY_QUEUE );
// Dodge animations
REGISTER_SHARED_ACTIVITY( ACT_DUCK_DODGE );
REGISTER_SHARED_ACTIVITY( ACT_DIE_BARNACLE_SWALLOW );
REGISTER_SHARED_ACTIVITY( ACT_GESTURE_BARNACLE_STRANGLE );
REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_DETACH );
REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_ANIMATE );
REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_ANIMATE_PRE );
REGISTER_SHARED_ACTIVITY( ACT_PHYSCANNON_ANIMATE_POST );
REGISTER_SHARED_ACTIVITY( ACT_DIE_FRONTSIDE );
REGISTER_SHARED_ACTIVITY( ACT_DIE_RIGHTSIDE );
REGISTER_SHARED_ACTIVITY( ACT_DIE_BACKSIDE );
REGISTER_SHARED_ACTIVITY( ACT_DIE_LEFTSIDE );
REGISTER_SHARED_ACTIVITY( ACT_OPEN_DOOR );
// Dynamic interactions
REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ZOMBIE_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ZOMBIE_TORSO_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_HEADCRAB_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ANTLION );
REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ZOMBIE_SHOTGUN64 );
REGISTER_SHARED_ACTIVITY( ACT_DI_ALYX_ZOMBIE_SHOTGUN26 );
//Readiness transitions
REGISTER_SHARED_ACTIVITY( ACT_READINESS_RELAXED_TO_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_READINESS_RELAXED_TO_STIMULATED_WALK );
REGISTER_SHARED_ACTIVITY( ACT_READINESS_AGITATED_TO_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_READINESS_STIMULATED_TO_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_READINESS_PISTOL_RELAXED_TO_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_READINESS_PISTOL_RELAXED_TO_STIMULATED_WALK );
REGISTER_SHARED_ACTIVITY( ACT_READINESS_PISTOL_AGITATED_TO_STIMULATED );
REGISTER_SHARED_ACTIVITY( ACT_READINESS_PISTOL_STIMULATED_TO_RELAXED );
REGISTER_SHARED_ACTIVITY( ACT_IDLE_CARRY );
REGISTER_SHARED_ACTIVITY( ACT_WALK_CARRY );
//===========================
// TF2 Specific Activities
//===========================
REGISTER_SHARED_ACTIVITY( ACT_STARTDYING );
REGISTER_SHARED_ACTIVITY( ACT_DYINGLOOP );
REGISTER_SHARED_ACTIVITY( ACT_DYINGTODEAD );
REGISTER_SHARED_ACTIVITY( ACT_RIDE_MANNED_GUN );
// All viewmodels
REGISTER_SHARED_ACTIVITY( ACT_VM_SPRINT_ENTER );
REGISTER_SHARED_ACTIVITY( ACT_VM_SPRINT_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_VM_SPRINT_LEAVE );
// Looping weapon firing
REGISTER_SHARED_ACTIVITY( ACT_FIRE_START );
REGISTER_SHARED_ACTIVITY( ACT_FIRE_LOOP );
REGISTER_SHARED_ACTIVITY( ACT_FIRE_END );
// TF2
REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_GRENADEIDLE );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_GRENADEREADY );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_GRENADEIDLE );
REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_GRENADEREADY );
REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_UP );
REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_DOWN );
REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_UP_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_ATTACK );
REGISTER_SHARED_ACTIVITY( ACT_OVERLAY_SHIELD_KNOCKBACK );
REGISTER_SHARED_ACTIVITY( ACT_SHIELD_UP );
REGISTER_SHARED_ACTIVITY( ACT_SHIELD_DOWN );
REGISTER_SHARED_ACTIVITY( ACT_SHIELD_UP_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_SHIELD_ATTACK );
REGISTER_SHARED_ACTIVITY( ACT_SHIELD_KNOCKBACK );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_UP );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_DOWN );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_UP_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_ATTACK );
REGISTER_SHARED_ACTIVITY( ACT_CROUCHING_SHIELD_KNOCKBACK );
REGISTER_SHARED_ACTIVITY( ACT_TURNRIGHT45 );
REGISTER_SHARED_ACTIVITY( ACT_TURNLEFT45 );
REGISTER_SHARED_ACTIVITY( ACT_TURN );
REGISTER_SHARED_ACTIVITY( ACT_OBJ_ASSEMBLING );
REGISTER_SHARED_ACTIVITY( ACT_OBJ_DISMANTLING );
REGISTER_SHARED_ACTIVITY( ACT_OBJ_STARTUP );
REGISTER_SHARED_ACTIVITY( ACT_OBJ_RUNNING );
REGISTER_SHARED_ACTIVITY( ACT_OBJ_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_OBJ_PLACING );
REGISTER_SHARED_ACTIVITY( ACT_OBJ_DETERIORATING );
REGISTER_SHARED_ACTIVITY( ACT_OBJ_UPGRADING );
// Deploy
REGISTER_SHARED_ACTIVITY( ACT_DEPLOY );
REGISTER_SHARED_ACTIVITY( ACT_DEPLOY_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_UNDEPLOY );
//===========================
// HL1 Specific Activities
//===========================
// Grenades
REGISTER_SHARED_ACTIVITY( ACT_GRENADE_ROLL );
REGISTER_SHARED_ACTIVITY( ACT_GRENADE_TOSS );
// Hand grenade
REGISTER_SHARED_ACTIVITY( ACT_HANDGRENADE_THROW1 );
REGISTER_SHARED_ACTIVITY( ACT_HANDGRENADE_THROW2 );
REGISTER_SHARED_ACTIVITY( ACT_HANDGRENADE_THROW3 );
// Shotgun
REGISTER_SHARED_ACTIVITY( ACT_SHOTGUN_IDLE_DEEP );
REGISTER_SHARED_ACTIVITY( ACT_SHOTGUN_IDLE4 );
// Glock
REGISTER_SHARED_ACTIVITY( ACT_GLOCK_SHOOTEMPTY );
REGISTER_SHARED_ACTIVITY( ACT_GLOCK_SHOOT_RELOAD );
// RPG
REGISTER_SHARED_ACTIVITY( ACT_RPG_DRAW_UNLOADED );
REGISTER_SHARED_ACTIVITY( ACT_RPG_HOLSTER_UNLOADED );
REGISTER_SHARED_ACTIVITY( ACT_RPG_IDLE_UNLOADED );
REGISTER_SHARED_ACTIVITY( ACT_RPG_FIDGET_UNLOADED );
// Crossbow
REGISTER_SHARED_ACTIVITY( ACT_CROSSBOW_DRAW_UNLOADED );
REGISTER_SHARED_ACTIVITY( ACT_CROSSBOW_IDLE_UNLOADED );
REGISTER_SHARED_ACTIVITY( ACT_CROSSBOW_FIDGET_UNLOADED );
// Gauss
REGISTER_SHARED_ACTIVITY( ACT_GAUSS_SPINUP );
REGISTER_SHARED_ACTIVITY( ACT_GAUSS_SPINCYCLE );
// Tripmine
REGISTER_SHARED_ACTIVITY( ACT_TRIPMINE_GROUND );
REGISTER_SHARED_ACTIVITY( ACT_TRIPMINE_WORLD );
//===========================
// CSPort Specific Activities
//===========================
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_SILENCED ); // fire
REGISTER_SHARED_ACTIVITY ( ACT_VM_RELOAD_SILENCED );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DRYFIRE_SILENCED ); // fire with no ammo loaded.
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_SILENCED );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DRAW_SILENCED );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_EMPTY_LEFT );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DRYFIRE_LEFT );
REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_IDLE_FIRE );
REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_CROUCH_FIRE );
REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_CROUCH_WALK_FIRE );
REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_WALK_FIRE );
REGISTER_SHARED_ACTIVITY ( ACT_PLAYER_RUN_FIRE );
REGISTER_SHARED_ACTIVITY ( ACT_IDLETORUN );
REGISTER_SHARED_ACTIVITY ( ACT_RUNTOIDLE );
//===========================
// DoD Specific Activities
//===========================
REGISTER_SHARED_ACTIVITY ( ACT_SPRINT );
// To get in and out of prone state.
REGISTER_SHARED_ACTIVITY ( ACT_GET_DOWN_STAND );
REGISTER_SHARED_ACTIVITY ( ACT_GET_UP_STAND );
REGISTER_SHARED_ACTIVITY ( ACT_GET_DOWN_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_GET_UP_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_PRONE_FORWARD );
REGISTER_SHARED_ACTIVITY ( ACT_PRONE_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_DEEPIDLE1 );
REGISTER_SHARED_ACTIVITY ( ACT_DEEPIDLE2 );
REGISTER_SHARED_ACTIVITY ( ACT_DEEPIDLE3 );
REGISTER_SHARED_ACTIVITY ( ACT_DEEPIDLE4 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_RELOAD_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_VM_RELOAD_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DRAW_DEPLOYED );
//Weapon is empty activities
REGISTER_SHARED_ACTIVITY ( ACT_VM_DRAW_EMPTY );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_EMPTY );
REGISTER_SHARED_ACTIVITY ( ACT_VM_RELOAD_EMPTY );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_EMPTY );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED_EMPTY );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_8 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_7 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_6 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_5 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_4 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_3 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_2 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_1 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED_8 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED_7 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED_6 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED_5 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED_4 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED_3 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED_2 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_IDLE_DEPLOYED_1 );
// Animation from prone idle to standing/crouch idle. Number designates bullets left
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY_8 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY_7 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY_6 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY_5 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY_4 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY_3 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY_1 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNDEPLOY_EMPTY );
// Animation from standing/crouch idle to prone idle. Number designates bullets left
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY_8 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY_7 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY_6 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY_5 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY_4 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY_3 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY_1 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_DEPLOY_EMPTY );
// Shooting animations for standing/crouch position. Number designates bullets left at START of animation
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_8 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_7 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_6 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_5 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_4 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_3 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_2 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_1 );
// Shooting animations for prone position. Number designates bullets left at START of animation
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED_8 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED_7 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED_6 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED_5 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED_4 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED_3 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED_2 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED_1 );
REGISTER_SHARED_ACTIVITY ( ACT_VM_PRIMARYATTACK_DEPLOYED_EMPTY );
// Player anim ACTs
// Base activities, we translate from these
REGISTER_SHARED_ACTIVITY ( ACT_DOD_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_IDLE_ZOOMED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_ZOOMED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_ZOOMED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_ZOOMED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_ZOOMED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_FORWARD_ZOOMED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_PRONE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM );
// Positions
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_AIM_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_AIM_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_AIM_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_AIM_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_AIM_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_AIM_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_AIM_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_AIM_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_AIM_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_AIM_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_AIM_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_AIM_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_AIM_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_AIM_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_BAR );
// ZOom
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_ZOOM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_ZOOM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_ZOOM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_ZOOM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_ZOOM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_ZOOM_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_ZOOM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_ZOOM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_ZOOM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_ZOOM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_ZOOM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_ZOOM_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_ZOOM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_ZOOM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_ZOOM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_ZOOM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_ZOOM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_ZOOM_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_ZOOM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_ZOOM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_ZOOM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_ZOOM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_ZOOM_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_ZOOM_PSCHRECK );
// Deployed Aim
REGISTER_SHARED_ACTIVITY ( ACT_DOD_DEPLOY_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_DEPLOY_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_DEPLOY_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_DEPLOY_30CAL );
// Prone Deployed Aim
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_DEPLOY_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_DEPLOY_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_DEPLOY_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_DEPLOY_30CAL );
// Attacks
// Rifle
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_PRONE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_DEPLOYED_RIFLE );
// Bolt
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_PRONE_BOLT );
// Tommy
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_PRONE_TOMMY );
// MP40
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_PRONE_MP40 );
// MP44
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_MP44 );
// Greasegun
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_GREASE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_GREASE );
// Pistols (<NAME>)
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_C96 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_C96 );
// Mgs (mg42, mg34)
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_DEPLOYED_MG );
// 30cal
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_DEPLOYED_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_DEPLOYED_30CAL );
// Grenades
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_GREN_STICK );
// Knife
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_KNIFE );
// Spade
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_SPADE );
// Bazooka
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_BAZOOKA );
// Pschreck
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_PSCHRECK );
// Bar
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_PRONE_BAR );
// Reloads
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_GARAND );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_K43 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_M1CARBINE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_GREASEGUN );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_FG42 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_RIFLEGRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_C96 );
// Crouch
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_RIFLEGRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_M1CARBINE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_CROUCH_C96 );
// Bazookas
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_ZOOMLOAD_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_ZOOMLOAD_PSCHRECK );
// Deployed
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_DEPLOYED_FG42 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_DEPLOYED_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_DEPLOYED_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_DEPLOYED_MG34 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_DEPLOYED_BAR );
// Prone
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_GARAND );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_M1CARBINE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_K43 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_MP40 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_GREASEGUN );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_FG42 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_RIFLEGRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_C96 );
// Prone bazooka
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_ZOOMLOAD_PRONE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_ZOOMLOAD_PRONE_PSCHRECK );
// Prone deployed
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_DEPLOYED_BAR );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_DEPLOYED_FG42 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_DEPLOYED_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_DEPLOYED_MG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RELOAD_PRONE_DEPLOYED_MG34 );
// Prone zoomed aim
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_ZOOM_FORWARD_RIFLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_ZOOM_FORWARD_BOLT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_ZOOM_FORWARD_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONE_ZOOM_FORWARD_PSCHRECK );
// Crouch attack.
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_CROUCH_SPADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_CROUCH_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_CROUCH_GREN_FRAG );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRIMARYATTACK_CROUCH_GREN_STICK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_CROUCH_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SECONDARYATTACK_CROUCH_MP40 );
// Hand Signals
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_MG42 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_STICKGRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_IDLE_K98 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_30CAL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_BAZOOKA );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_PSCHRECK );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_KNIFE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_MG42 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_STICKGRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_TOMMY );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_MP44 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_HS_CROUCH_K98 );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_STAND_IDLE_TNT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCH_IDLE_TNT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_CROUCHWALK_IDLE_TNT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_WALK_IDLE_TNT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_RUN_IDLE_TNT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_SPRINT_IDLE_TNT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PRONEWALK_IDLE_TNT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_PLANT_TNT );
REGISTER_SHARED_ACTIVITY ( ACT_DOD_DEFUSE_TNT );
//HL2MP
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_PISTOL );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_SMG1 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_SMG1 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_SMG1 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_SMG1 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_SMG1 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_SMG1 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_SMG1 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_AR2 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_AR2 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_AR2 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_AR2 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_AR2 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_AR2 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_AR2 );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_SHOTGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_SHOTGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_SHOTGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_SHOTGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_SHOTGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_SHOTGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_SHOTGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_RPG );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_RPG );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_RPG );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_RPG );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_RPG );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_RPG );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_RPG );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_PHYSGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_PHYSGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_PHYSGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_PHYSGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_PHYSGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_PHYSGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_PHYSGUN );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROSSBOW );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_CROSSBOW );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_CROSSBOW );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_CROSSBOW );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_CROSSBOW );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_CROSSBOW );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_CROSSBOW );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_SLAM );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_RUN_SLAM );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_IDLE_CROUCH_SLAM );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_WALK_CROUCH_SLAM );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RANGE_ATTACK_SLAM );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_GESTURE_RELOAD_SLAM );
REGISTER_SHARED_ACTIVITY ( ACT_HL2MP_JUMP_SLAM );
// Portal
REGISTER_SHARED_ACTIVITY ( ACT_VM_FIZZLE );
// Multiplayer
REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_DEPLOYED_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DEPLOYED_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN );
REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SPRINT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_VCD );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARYFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARYFIRE_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_SECONDARYFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARYFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARYFIRE_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_SECONDARYFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PRIMARYFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_SECONDARYFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_SECONDARYFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PREFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_POSTFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_STARTFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PREFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_POSTFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PREFIRE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_POSTFIRE );
// Multiplayer - Primary
REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DEPLOYED_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_DEPLOYED_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_DEPLOYED_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_DEPLOYED_IDLE_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_LOOP_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_END_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_LOOP_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_END_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY_LOOP_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY_END_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_LOOP_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_END_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARY_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARY_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PRIMARY_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_LOOP_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_LOOP_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_LOOP_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_PRIMARY_END_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_PRIMARY_END_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_PRIMARY_END_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_PRIMARY_ALT );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PRIMARY_SUPER );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_PRIMARY_SUPER );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PRIMARY_SUPER );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE_PRIMARY );
// Secondary
REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY_2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE_SECONDARY );
// Secondary2
REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY2_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_STAND_SECONDARY2_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY2_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_CROUCH_SECONDARY2_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY2_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_SWIM_SECONDARY2_END );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY2_LOOP );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RELOAD_AIRWALK_SECONDARY2_END );
// Melee
REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_MELEE_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_MELEE_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE_MELEE );
// Item1
REGISTER_SHARED_ACTIVITY( ACT_MP_STAND_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCH_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RUN_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_WALK_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_AIRWALK_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCHWALK_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_START_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_FLOAT_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_LAND_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_SWIM_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_ITEM1_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_ITEM1_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_SWIM_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_AIRWALK_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_DEPLOYED_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_DEPLOYED_IDLE_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCHWALK_DEPLOYED_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCH_DEPLOYED_IDLE_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED_ITEM1 );
// Item2
REGISTER_SHARED_ACTIVITY( ACT_MP_STAND_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCH_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RUN_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_WALK_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_AIRWALK_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCHWALK_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_START_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_FLOAT_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_LAND_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_SWIM_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_ITEM2_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_ITEM2_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_SWIM_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_AIRWALK_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_HARD_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_HARD_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_SWIM_HARD_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_DEPLOYED_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_DEPLOYED_IDLE_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCHWALK_DEPLOYED_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCH_DEPLOYED_IDLE_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_STAND_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_STAND_ITEM2_LOOP );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_STAND_ITEM2_END );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_CROUCH_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_CROUCH_ITEM2_LOOP );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_CROUCH_ITEM2_END );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_SWIM_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_SWIM_ITEM2_LOOP );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_SWIM_ITEM2_END );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_AIRWALK_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_AIRWALK_ITEM2_LOOP );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_AIRWALK_ITEM2_END );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_NO_AMMO_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_GRENADE_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_GRENADE_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_SWIM_GRENADE_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_AIRWALK_GRENADE_ITEM2 );
// Passtime
REGISTER_SHARED_ACTIVITY( ACT_MP_STAND_PASSTIME );
REGISTER_SHARED_ACTIVITY( ACT_MP_RUN_PASSTIME );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCHWALK_PASSTIME );
// Flinches
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_PRIMARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_HEAD );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_CHEST );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_STOMACH );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_LEFTARM );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_RIGHTARM );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_LEFTLEG );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_FLINCH_RIGHTLEG );
// TF Specific
REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE1_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE1_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE1_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE2_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE2_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_GRENADE2_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE1_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE1_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE1_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE2_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE2_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_PRIMARY_GRENADE2_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE1_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE1_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE1_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE2_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE2_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SECONDARY_GRENADE2_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE1_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE1_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE1_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE2_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE2_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_MELEE_GRENADE2_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE1_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE1_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE1_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE2_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE2_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM1_GRENADE2_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE1_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE1_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE1_ATTACK );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE2_DRAW );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE2_IDLE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ITEM2_GRENADE2_ATTACK );
// Building
REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE_BUILDING );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE_BUILDING );
// Building - Deployed
REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_GRENADE_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_CROUCH_GRENADE_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_GRENADE_BUILDING_DEPLOYED );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_AIRWALK_GRENADE_BUILDING_DEPLOYED );
// PDA
REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_STAND_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_ATTACK_SWIM_PDA );
REGISTER_SHARED_ACTIVITY ( ACT_MP_STAND_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCH_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_RUN_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_WALK_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_AIRWALK_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_CROUCHWALK_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_START_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_FLOAT_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_JUMP_LAND_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_SWIM_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP_CROUCH );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP_CROUCH_PRIMARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP_CROUCH_SECONDARY );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP_CROUCH_MELEE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP_CROUCH_ITEM1 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP_CROUCH_ITEM2 );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP_CROUCH_LOSERSTATE );
REGISTER_SHARED_ACTIVITY ( ACT_MP_DOUBLEJUMP_CROUCH_PASSTIME );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_PRIMARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_PRIMARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_PRIMARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_PRIMARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_PRIMARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_PRIMARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_SECONDARY );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_MELEE );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_ITEM1 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_ITEM2 );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_BUILDING );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_BUILDING );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_BUILDING );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_BUILDING );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_BUILDING );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_BUILDING );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_HANDMOUTH_PDA );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FINGERPOINT_PDA );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_FISTPUMP_PDA );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_THUMBSUP_PDA );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODYES_PDA );
REGISTER_SHARED_ACTIVITY( ACT_MP_GESTURE_VC_NODNO_PDA );
REGISTER_SHARED_ACTIVITY( ACT_MP_STUN_BEGIN );
REGISTER_SHARED_ACTIVITY( ACT_MP_STUN_MIDDLE );
REGISTER_SHARED_ACTIVITY( ACT_MP_STUN_END );
REGISTER_SHARED_ACTIVITY( ACT_MP_PASSTIME_THROW_BEGIN );
REGISTER_SHARED_ACTIVITY( ACT_MP_PASSTIME_THROW_MIDDLE );
REGISTER_SHARED_ACTIVITY( ACT_MP_PASSTIME_THROW_END );
REGISTER_SHARED_ACTIVITY( ACT_MP_PASSTIME_THROW_CANCEL );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNUSABLE );
REGISTER_SHARED_ACTIVITY ( ACT_VM_UNUSABLE_TO_USABLE );
REGISTER_SHARED_ACTIVITY ( ACT_VM_USABLE_TO_UNUSABLE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_SECONDARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_RELOAD_START );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_RELOAD_FINISH );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_RELOAD_2 );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_RELOAD_START_2 );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_RELOAD_FINISH_2 );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_RELOAD_3 );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_RELOAD_START_3 );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_RELOAD_FINISH_3 );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_PRIMARYATTACK_3 );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_SECONDARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_RELOAD_START );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_RELOAD_FINISH );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_RELOAD2 );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_DRAW_2 );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_IDLE_2 );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_PRIMARYATTACK_2 );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_RELOAD_2 );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_SECONDARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_STUN );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_HITCENTER );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_SWINGHARD );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_SECONDARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_PDA_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_PDA1_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_PDA2_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_BLD_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_PDA1_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_PDA2_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_BLD_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_IDLE_2 );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_SECONDARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_RELOAD_START );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_RELOAD_FINISH );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_HITCENTER );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_VM_SWINGHARD );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_BACKSTAB_VM_UP );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_BACKSTAB_VM_DOWN );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_BACKSTAB_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_ITEM1_STUN );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_SECONDARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_CHARGE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_IDLE_2 );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_IDLE_3 );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_CHARGE_IDLE_3 );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_HITCENTER );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_VM_SWINGHARD );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_BACKSTAB_VM_UP );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_BACKSTAB_VM_DOWN );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_BACKSTAB_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_ITEM2_STUN );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_SECONDARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_CHARGE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_IDLE_2 );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_IDLE_3 );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_CHARGE_IDLE_3 );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_HITCENTER );
REGISTER_SHARED_ACTIVITY( ACT_ITEM3_VM_SWINGHARD );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_SECONDARY2ATTACK );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_RELOAD_START );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_RELOAD_FINISH );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_RELOAD2 );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY2_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_BACKSTAB_VM_UP );
REGISTER_SHARED_ACTIVITY( ACT_BACKSTAB_VM_DOWN );
REGISTER_SHARED_ACTIVITY( ACT_BACKSTAB_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_ATTACK_STAND_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_ATTACK_STAND_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_ATTACK_STAND_STARTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_ATTACK_CROUCH_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_ATTACK_CROUCH_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_ATTACK_SWIM_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_ATTACK_SWIM_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_ATTACK_STAND_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_ATTACK_STAND_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_ATTACK_STAND_STARTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_ATTACK_CROUCH_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_ATTACK_CROUCH_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_ATTACK_SWIM_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_ATTACK_SWIM_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_STAND_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_STAND_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_STAND_STARTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_CROUCH_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_CROUCH_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_SWIM_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ATTACK_SWIM_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_ATTACK_STAND_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_ATTACK_STAND_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_ATTACK_STAND_STARTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_ATTACK_CROUCH_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_ATTACK_CROUCH_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_ATTACK_SWIM_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM1_ATTACK_SWIM_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_ATTACK_STAND_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_ATTACK_STAND_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_ATTACK_STAND_STARTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_ATTACK_CROUCH_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_ATTACK_CROUCH_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_ATTACK_SWIM_PREFIRE );
REGISTER_SHARED_ACTIVITY( ACT_ITEM2_ATTACK_SWIM_POSTFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MP_STAND_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCH_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_RUN_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_WALK_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_AIRWALK_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_CROUCHWALK_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_START_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_FLOAT_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_LAND_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_SWIM_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_STAND_MELEE_SECONDARY_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_CROUCH_MELEE_SECONDARY_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_SWIM_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MP_ATTACK_AIRWALK_MELEE_ALLCLASS );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_HOLSTER );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_PULLBACK );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_SECONDARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_DRYFIRE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_IDLE_TO_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_IDLE_LOWERED );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_LOWERED_TO_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_STUN );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_HITCENTER );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_ALLCLASS_VM_SWINGHARD );
REGISTER_SHARED_ACTIVITY( ACT_MP_STAND_BOMB );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_START_BOMB );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_FLOAT_BOMB );
REGISTER_SHARED_ACTIVITY( ACT_MP_JUMP_LAND_BOMB );
REGISTER_SHARED_ACTIVITY( ACT_MP_RUN_BOMB );
REGISTER_SHARED_ACTIVITY( ACT_MP_SWIM_BOMB );
REGISTER_SHARED_ACTIVITY( ACT_VM_DRAW_QRL );
REGISTER_SHARED_ACTIVITY( ACT_VM_IDLE_QRL );
REGISTER_SHARED_ACTIVITY( ACT_VM_PULLBACK_QRL );
REGISTER_SHARED_ACTIVITY( ACT_VM_PRIMARYATTACK_QRL );
REGISTER_SHARED_ACTIVITY( ACT_VM_RELOAD_QRL );
REGISTER_SHARED_ACTIVITY( ACT_VM_RELOAD_START_QRL );
REGISTER_SHARED_ACTIVITY( ACT_VM_RELOAD_FINISH_QRL );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_STAND_PRIMARY3 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_CROUCH_PRIMARY3 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_AIRWALK_PRIMARY3 );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_STAND_PRIMARY3_LOOP );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_CROUCH_PRIMARY3_LOOP );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_AIRWALK_PRIMARY3_LOOP );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_STAND_PRIMARY3_END );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_CROUCH_PRIMARY3_END );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_AIRWALK_PRIMARY3_END );
REGISTER_SHARED_ACTIVITY( ACT_MP_RELOAD_SWIM_PRIMARY3 );
REGISTER_SHARED_ACTIVITY( ACT_MP_THROW );
REGISTER_SHARED_ACTIVITY( ACT_THROWABLE_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_THROWABLE_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_THROWABLE_VM_FIRE );
REGISTER_SHARED_ACTIVITY( ACT_SPELL_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_SPELL_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_SPELL_VM_ARM );
REGISTER_SHARED_ACTIVITY( ACT_SPELL_VM_FIRE );
REGISTER_SHARED_ACTIVITY( ACT_BREADSAPPER_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_BREADSAPPER_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_BREADGLOVES_VM_HITLEFT );
REGISTER_SHARED_ACTIVITY( ACT_BREADGLOVES_VM_HITRIGHT );
REGISTER_SHARED_ACTIVITY( ACT_BREADGLOVES_VM_SWINGHARD );
REGISTER_SHARED_ACTIVITY( ACT_BREADGLOVES_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_BREADGLOVES_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_BREADMONSTER_GLOVES_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_BREADMONSTER_GLOVES_HITRIGHT );
REGISTER_SHARED_ACTIVITY( ACT_BREADMONSTER_GLOVES_HITUP );
REGISTER_SHARED_ACTIVITY( ACT_BREADMONSTER_VM_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_BREADMONSTER_VM_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_BREADMONSTER_VM_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_PARACHUTE_DEPLOY );
REGISTER_SHARED_ACTIVITY( ACT_PARACHUTE_DEPLOY_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_PARACHUTE_RETRACT );
REGISTER_SHARED_ACTIVITY( ACT_PARACHUTE_RETRACT_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_BOT_SPAWN );
REGISTER_SHARED_ACTIVITY( ACT_BOT_PANIC );
REGISTER_SHARED_ACTIVITY( ACT_BOT_PRIMARY_MOVEMENT );
REGISTER_SHARED_ACTIVITY( ACT_BOT_GESTURE_FLINCH );
REGISTER_SHARED_ACTIVITY( ACT_BOT_PANIC_START );
REGISTER_SHARED_ACTIVITY( ACT_BOT_PANIC_END );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_REVOLVER_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_REVOLVER_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_REVOLVER_PRIMARYATTACK );
REGISTER_SHARED_ACTIVITY( ACT_ENGINEER_REVOLVER_RELOAD );
REGISTER_SHARED_ACTIVITY( ACT_KART_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_KART_ACTION_SHOOT );
REGISTER_SHARED_ACTIVITY( ACT_KART_ACTION_DASH );
REGISTER_SHARED_ACTIVITY( ACT_KART_JUMP_START );
REGISTER_SHARED_ACTIVITY( ACT_KART_JUMP_FLOAT );
REGISTER_SHARED_ACTIVITY( ACT_KART_JUMP_LAND );
REGISTER_SHARED_ACTIVITY( ACT_KART_IMPACT );
REGISTER_SHARED_ACTIVITY( ACT_KART_IMPACT_BIG );
REGISTER_SHARED_ACTIVITY( ACT_KART_GESTURE_POSITIVE );
REGISTER_SHARED_ACTIVITY( ACT_KART_GESTURE_NEGATIVE );
REGISTER_SHARED_ACTIVITY( ACT_GRAPPLE_DRAW );
REGISTER_SHARED_ACTIVITY( ACT_GRAPPLE_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_GRAPPLE_FIRE_START );
REGISTER_SHARED_ACTIVITY( ACT_GRAPPLE_FIRE_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_GRAPPLE_PULL_START );
REGISTER_SHARED_ACTIVITY( ACT_GRAPPLE_PULL_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_GRAPPLE_PULL_END );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_INSPECT_START );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_INSPECT_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_PRIMARY_VM_INSPECT_END );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_INSPECT_START );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_INSPECT_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_SECONDARY_VM_INSPECT_END );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_INSPECT_START );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_INSPECT_IDLE );
REGISTER_SHARED_ACTIVITY( ACT_MELEE_VM_INSPECT_END );
REGISTER_SHARED_ACTIVITY( ACT_DEFUSE );
REGISTER_SHARED_ACTIVITY( ACT_DEFUSE_WITH_KIT );
REGISTER_SHARED_ACTIVITY( ACT_DEFUSE_CROUCH );
REGISTER_SHARED_ACTIVITY( ACT_DEFUSE_WITH_KIT_CROUCH );
AssertMsg( g_HighestActivity == LAST_SHARED_ACTIVITY - 1, "Not all activities from ai_activity.h registered in activitylist.cpp" );
}
// HACKHACK: Keep backwards compatibility on broken activities temporarily
#define ACTIVITY_FILE_TAG 0x80800000
class CActivityDataOps : public CDefSaveRestoreOps
{
public:
// save data type interface
virtual void Save( const SaveRestoreFieldInfo_t &fieldInfo, ISave *pSave )
{
int activityIndex = *((int *)fieldInfo.pField);
const char *pActivityName = ActivityList_NameForIndex( activityIndex );
if ( !pActivityName )
{
AssertOnce( activityIndex == -1 ); // FIXME: whatever activity this was, it's now being saved out as ACT_RESET
pActivityName = ActivityList_NameForIndex( 0 );
}
int len = strlen(pActivityName) + 1;
// Use the high 16-bits of this int to signify this file format
// this makes this backwards compatible.
// UNDONE: Remove after playtest save files are no longer needed
len |= ACTIVITY_FILE_TAG;
pSave->WriteInt( &len );
pSave->WriteString( pActivityName );
}
virtual void Restore( const SaveRestoreFieldInfo_t &fieldInfo, IRestore *pRestore )
{
char nameBuf[1024];
int *pActivityIndex = (int *)fieldInfo.pField;
int nameLen = pRestore->ReadInt();
if ( (nameLen & 0xFFFF0000) != ACTIVITY_FILE_TAG )
{
// old save file, this is an index, not a name
*pActivityIndex = nameLen;
return;
}
nameLen &= 0xFFFF;
pRestore->ReadString( nameBuf, sizeof(nameBuf), nameLen );
*pActivityIndex = ActivityList_IndexForName( nameBuf );
if ( *pActivityIndex < 0 )
{
*pActivityIndex = 0;
}
}
virtual bool IsEmpty( const SaveRestoreFieldInfo_t &fieldInfo )
{
int *pActivityIndex = (int *)fieldInfo.pField;
return (*pActivityIndex == 0);
}
virtual void MakeEmpty( const SaveRestoreFieldInfo_t &fieldInfo )
{
int *pActivityIndex = (int *)fieldInfo.pField;
*pActivityIndex = 0;
}
};
static CActivityDataOps g_ActivityDataOps;
ISaveRestoreOps* ActivityDataOps()
{
return &g_ActivityDataOps;
}
void UTIL_LoadActivityRemapFile( const char *filename, const char *section, CUtlVector <CActivityRemap> &entries )
{
int iIndex = m_ActivityRemapDatabase.Find( filename );
if ( iIndex != m_ActivityRemapDatabase.InvalidIndex() )
{
CActivityRemapCache *actRemap = &m_ActivityRemapDatabase[iIndex];
entries.AddVectorToTail( actRemap->m_cachedActivityRemaps );
return;
}
KeyValues *pkvFile = new KeyValues( section );
if ( pkvFile->LoadFromFile( filesystem, filename, NULL ) )
{
KeyValues *pTestKey = pkvFile->GetFirstSubKey();
CActivityRemapCache actRemap;
while ( pTestKey )
{
Activity ActBase = (Activity)ActivityList_IndexForName( pTestKey->GetName() );
if ( ActBase != ACT_INVALID )
{
KeyValues *pRemapKey = pTestKey->GetFirstSubKey();
CActivityRemap actMap;
actMap.activity = ActBase;
while ( pRemapKey )
{
const char *pKeyName = pRemapKey->GetName();
const char *pKeyValue = pRemapKey->GetString();
if ( !stricmp( pKeyName, "remapactivity" ) )
{
Activity Act = (Activity)ActivityList_IndexForName( pKeyValue );
if ( Act == ACT_INVALID )
{
actMap.mappedActivity = ActivityList_RegisterPrivateActivity( pKeyValue );
}
else
{
actMap.mappedActivity = Act;
}
}
else if ( !stricmp( pKeyName, "extra" ) )
{
actMap.SetExtraKeyValueBlock( pRemapKey->MakeCopy() );
}
pRemapKey = pRemapKey->GetNextKey();
}
entries.AddToTail( actMap );
}
pTestKey = pTestKey->GetNextKey();
}
actRemap.m_cachedActivityRemaps.AddVectorToTail( entries );
m_ActivityRemapDatabase.Insert( filename, actRemap );
}
}
int ActivityList_HighestIndex()
{
return g_HighestActivity;
}
|
dexueyang/trick-dup0 | trick_models/test/impexp/include/test.h | /********************************* TRICK HEADER *******************************
PURPOSE:
(Trick test)
REFERENCES:
(((Trick Simulation Environment) (NASA:JSC #37943)
(JSC/Engineering Directorate/Automation, Robotics and Simulation Division)
(Nov 2001)))
ASSUMPTIONS AND LIMITATIONS:
((None))
PROGRAMMERS:
((<NAME>) (LinCom) (November 2001))
*******************************************************************************/
#ifndef TEST_H
#define TEST_H
typedef struct { /* A ------------------------------------------------*/
double d ; /* -- A double */
int i ; /* -- An int */
int j ; /* -- An int */
} A ; /*--------------------------------------------------------------*/
typedef struct { /* B ------------------------------------------------*/
double d ; /* -- A double */
int i ; /* -- An int */
int j ; /* -- An int */
} B ; /*--------------------------------------------------------------*/
typedef struct { /* TEST ---------------------------------------------*/
A a ; /* -- A */
B b ; /* -- B */
} TEST ; /*------------------------------------------------------------*/
#endif
|
christopheranderson/azure-sdk-for-java | sdk/keyvault/azure-keyvault-secrets/src/main/java/com/azure/security/keyvault/secrets/models/Secret.java | <reponame>christopheranderson/azure-sdk-for-java
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
package com.azure.security.keyvault.secrets.models;
import com.azure.security.keyvault.secrets.SecretAsyncClient;
import com.azure.security.keyvault.secrets.SecretClient;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.time.OffsetDateTime;
import java.util.Map;
/**
* Secret is the resource consisting of name, value and its attributes inherited from {@link SecretBase}.
* It is managed by Secret Service.
*
* @see SecretClient
* @see SecretAsyncClient
*/
public class Secret extends SecretBase {
/**
* The value of the secret.
*/
@JsonProperty(value = "value")
private String value;
/**
* Creates an empty instance of the Secret.
*/
public Secret() {
}
/**
* Creates a Secret with {@code name} and {@code value}.
*
* @param name The name of the secret.
* @param value the value of the secret.
*/
public Secret(String name, String value) {
this.name = name;
this.value = value;
}
/**
* Get the value of the secret.
*
* @return the secret value
*/
public String value() {
return this.value;
}
/**
* Set enabled value.
*
* @param enabled The enabled value to set
* @return the Secret object itself.
*/
@Override
public Secret enabled(Boolean enabled) {
super.enabled(enabled);
return this;
}
/**
* Set the {@link OffsetDateTime notBefore} UTC time.
*
* @param notBefore The not before time value to set
* @return the Secret object itself.
*/
@Override
public Secret notBefore(OffsetDateTime notBefore) {
super.notBefore(notBefore);
return this;
}
/**
* Set the {@link OffsetDateTime expires} UTC time.
*
* @param expires The expiry time value to set
* @return the Secret object itself.
*/
@Override
public Secret expires(OffsetDateTime expires) {
super.expires(expires);
return this;
}
/**
* Set the secret identifier.
*
* @param id The secret identifier value to set
* @return the Secret object itself.
*/
@Override
public Secret id(String id) {
super.id(id);
return this;
}
/**
* Set the content type of the secret.
*
* @param contentType The content type value to set
* @return the Secret object itself.
*/
@Override
public Secret contentType(String contentType) {
super.contentType(contentType);
return this;
}
/**
* Set the tags.
*
* @param tags The tags value to set
* @return the Secret object itself.
*/
@Override
public Secret tags(Map<String, String> tags) {
super.tags(tags);
return this;
}
}
|
Giddius/Antistasi_Logbook | antistasi_logbook/gui/widgets/dock_widget.py | """
WiP.
Soon.
"""
# region [Imports]
# * Standard Library Imports ---------------------------------------------------------------------------->
from typing import TYPE_CHECKING, Union
from pathlib import Path
# * Qt Imports --------------------------------------------------------------------------------------->
from PySide6.QtCore import Qt, QSize
from PySide6.QtWidgets import QMenu, QWidget, QDockWidget, QMainWindow, QApplication, QStackedWidget
# * Gid Imports ----------------------------------------------------------------------------------------->
from gidapptools import get_logger
# * Type-Checking Imports --------------------------------------------------------------------------------->
if TYPE_CHECKING:
from gidapptools.gid_config.interface import GidIniConfig
from antistasi_logbook.backend import Backend
from antistasi_logbook.gui.application import AntistasiLogbookApplication
from antistasi_logbook.gui.main_window import AntistasiLogbookMainWindow
# endregion[Imports]
# region [TODO]
# endregion [TODO]
# region [Logging]
# endregion[Logging]
# region [Constants]
THIS_FILE_DIR = Path(__file__).parent.absolute()
log = get_logger(__name__)
# endregion[Constants]
class BaseDockWidget(QDockWidget):
def __init__(self,
parent: QMainWindow,
title: str,
start_floating: bool = False,
start_hidden: bool = False,
allowed_areas: Qt.DockWidgetArea = Qt.AllDockWidgetAreas,
features: QDockWidget.DockWidgetFeature = QDockWidget.DockWidgetMovable | QDockWidget.DockWidgetClosable | QDockWidget.DockWidgetFloatable,
add_to_menu: QMenu = None):
super().__init__(parent)
self.title = title
self.setWindowTitle(title)
self.first_shown: bool = False
self.setHidden(start_hidden)
self.setFloating(start_floating)
allowed_areas = Qt.DockWidgetAreas() | allowed_areas
self.setAllowedAreas(allowed_areas)
self.setFeatures(features)
if add_to_menu is not None:
self._add_to_menu_bar(add_to_menu)
def _add_to_menu_bar(self, add_to_menu: QMenu):
view_action = self.toggleViewAction()
view_action.setText(f"{self.title} Window")
add_to_menu.addAction(view_action)
add_to_menu.setEnabled(True)
@property
def app(self) -> "AntistasiLogbookApplication":
return QApplication.instance()
@property
def backend(self) -> "Backend":
return self.app.backend
@property
def config(self) -> "GidIniConfig":
return self.app.config
@property
def main_window(self) -> "AntistasiLogbookMainWindow":
return self.parentWidget()
def show_if_first(self):
if self.first_shown is False:
self.show()
def show(self) -> None:
super().show()
if self.first_shown is False:
self.first_shown = True
class QueryWidget(BaseDockWidget):
def __init__(self, parent: QMainWindow, add_to_menu: QMenu = None, start_floating: bool = False):
self.pages: dict[str, QWidget] = {}
super().__init__(parent, title="Query", start_floating=start_floating, add_to_menu=add_to_menu)
self.setWidget(QStackedWidget(self))
self.widget.setHidden(True)
def add_page(self, widget: QWidget, name: str = None):
if name is None:
for attr_name in ["name", "title"]:
if hasattr(widget, attr_name):
name = getattr(widget, attr_name)
break
if name is None:
raise AttributeError(f"missing parameter 'name' for {widget!r}")
page_index = self.widget.addWidget(widget)
widget.page_index = page_index
self.pages[name] = widget
self.widget.setHidden(False)
def set_current_index(self, target: Union[str, int, QWidget]):
if isinstance(target, int):
index = target
elif isinstance(target, str):
index = self.pages[target].page_index
elif isinstance(target, QWidget):
index = target.page_index
self.widget.setCurrentIndex(index)
@property
def widget(self) -> QStackedWidget:
return super().widget()
def sizeHint(self) -> QSize:
base_width = 500
base_height = 400
try:
size = self.widget.currentWidget().sizeHint()
max_width = max([base_width, size.width()])
max_height = max([base_height, size.height()])
except AttributeError:
max_width = base_width
max_height = base_height
return QSize(max_width, max_height)
# region[Main_Exec]
if __name__ == '__main__':
pass
# endregion[Main_Exec]
|
liumapp/simple-sdk-example | client-server/src/main/java/com/liumapp/demo/sdk/client/db/user/service/ShippingAddressService.java | package com.liumapp.demo.sdk.client.db.user.service;
import com.liumapp.demo.sdk.client.db.user.domain.ShippingAddress;
/**
* @author liumapp
* @file ShippingAddressService.java
* @email <EMAIL>
* @homepage http://www.liumapp.com
* @date 6/19/18
*/
public interface ShippingAddressService {
int insert (ShippingAddress shippingAddress);
ShippingAddress selectByUserId (Long userId);
}
|
danzel-py/Kattis-Problem-Archive | below2.1/halfacookie.cc | <reponame>danzel-py/Kattis-Problem-Archive
#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main(){
double r,x,y;
double smol;
double big;
while (cin>>r)
{
cin>>x>>y;
if(x*x + y*y > r*r){
cout<<"miss\n";
continue;
}
big = M_PI*r*r;
smol = acos(sqrt(x*x + y*y)/r) * r * r - sqrt(r*r - x*x - y*y) * sqrt(x*x + y*y);
cout<<fixed<<setprecision(4)<<big-smol<<' '<<smol<<'\n';
}
return 0;
} |
Clara19/SilverKing | src/com/ms/silverking/text/NonFatalExceptionResponse.java | package com.ms.silverking.text;
enum NonFatalExceptionResponse {
IGNORE_EXCEPTIONS, LOG_EXCEPTIONS, THROW_EXCEPTIONS
} |
hao-wang/Montage | js-test-suite/testsuite/6043d9521d2330ec8348797e9d024327.js | load("201224b0d1c296b45befd2285e95dd42.js");
// Don't hand out internal function objects via Debugger.Environment.prototype.getVariable.
// When the real scope chain object holding the binding for 'f' in 'function f()
// { ... }' is optimized out because it's never used, we whip up fake scope
// chain objects for Debugger to use, if it looks. However, the value of the
// variable f will be an internal function object, not a live function object,
// since the latter was not recorded. Internal function objects should not be
// exposed via Debugger.
var g = newGlobal();
var dbg = new Debugger(g);
dbg.onDebuggerStatement = function (frame) {
var g_call_env = frame.older.environment; // g's locals
var g_decl_env = g_call_env.parent; // 'function g' binding
var f_call_env = g_decl_env.parent; // f's locals
var f_decl_env = f_call_env.parent; // 'function f' binding
assertEq(f_decl_env.getVariable('f').optimizedOut, true);
}
g.evaluate(`
function h() { debugger; }
(function f() {
return function g() {
h();
return 1;
}
})()();
`);
|
irgiob/RippleDEX | src/__tests__/integration/userIntegration.test.js | <gh_stars>1-10
import React from "react"
import { render, fireEvent, act, waitFor } from "@testing-library/react"
import ProfileSettings from "../../components/settings/profileSettings"
import { updateMemberPosition } from "../../models/Organisation"
import { updateUser } from "../../models/User"
jest.mock("../../models/Organisation")
jest.mock("../../models/User")
const sampleUser = {
id: "123",
firstName: "Test",
lastName: "Test",
profilePicture: "",
signInMethod: "password",
}
const sampleOrg = {
members: [
{
userID: "123",
position: "test",
},
],
}
describe("Testing profile components", () => {
beforeEach(() => {
jest.resetAllMocks()
})
test("Edit profile", async () => {
const { getByTestId } = render(
<ProfileSettings
isOpen={true}
user={sampleUser}
org={sampleOrg}
setUser={() => {}}
/>
)
const firstName = getByTestId("firstName")
const lastName = getByTestId("lastName")
const position = getByTestId("position")
const saveChangesButton = getByTestId("saveChanges")
expect(firstName.value).toBe(sampleUser.firstName)
expect(lastName.value).toBe(sampleUser.lastName)
expect(position.value).toBe(sampleOrg.members[0].position)
fireEvent.change(firstName, { target: { value: "test" } })
fireEvent.change(lastName, { target: { value: "test" } })
fireEvent.change(position, { target: { value: "test" } })
expect(firstName.value).toBe("test")
expect(lastName.value).toBe("test")
expect(position.value).toBe("test")
fireEvent.click(saveChangesButton)
await waitFor(() => {
expect(updateUser).toBeCalledTimes(1)
})
})
test("Change Profile Picture shows upload box", async () => {
const { getByTestId } = render(
<ProfileSettings
isOpen={true}
user={sampleUser}
org={sampleOrg}
setUser={() => {}}
/>
)
const changePicture = getByTestId("changePicture")
fireEvent.click(changePicture)
await waitFor(() => {
getByTestId("uploadBox")
})
})
test("Reset password will show reset password box", async () => {
const { getByTestId } = render(
<ProfileSettings
isOpen={true}
user={sampleUser}
org={sampleOrg}
setUser={() => {}}
/>
)
const resetPasswordButton = getByTestId("resetPasswordButton")
fireEvent.click(resetPasswordButton)
await waitFor(() => {
getByTestId("resetPasswordBox")
})
})
})
|
CQCL/tket | tket/tests/Circuit/test_Boxes.cpp | <filename>tket/tests/Circuit/test_Boxes.cpp
// Copyright 2019-2022 Cambridge Quantum Computing
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <catch2/catch.hpp>
#include "../testutil.hpp"
#include "Circuit/CircUtils.hpp"
#include "Circuit/Circuit.hpp"
#include "Converters/PhasePoly.hpp"
#include "Eigen/src/Core/Matrix.h"
#include "Simulation/CircuitSimulator.hpp"
namespace tket {
namespace test_Boxes {
SCENARIO("Using Boxes", "[boxes]") {
GIVEN("CircBox manipulation") {
// Small box
Circuit u(2);
u.add_op<unsigned>(OpType::Ry, -0.75, {0});
u.add_op<unsigned>(OpType::CX, {0, 1});
const CircBox ubox(u);
Circuit v(2);
v.add_box(ubox, {0, 1});
{
const auto raw_u_unitary = tket_sim::get_unitary(u);
const auto v_unitary = tket_sim::get_unitary(v);
CHECK(raw_u_unitary.isApprox(v_unitary));
}
Circuit c0(3);
c0.add_op<unsigned>(OpType::Rx, 0.5, {0});
c0.add_op<unsigned>(OpType::Ry, 1.5, {1});
c0.add_op<unsigned>(OpType::Rz, 0.75, {2});
c0.add_box(ubox, {1, 0});
c0.add_op<unsigned>(OpType::CX, {1, 2});
REQUIRE(c0.n_gates() == 5);
CircBox c0box(c0);
// Put them in a bigger circuit
Circuit d(4, 3);
d.add_box(c0box, {1, 2, 0});
d.add_op<unsigned>(OpType::CX, {0, 3});
REQUIRE(d.n_gates() == 2);
d.add_box(c0box, {3, 2, 1});
REQUIRE(d.n_gates() == 3);
d.add_box(c0box, {2, 3, 1});
REQUIRE(d.n_gates() == 4);
// Box up the bigger circuit
CircBox dbox(d);
Circuit e(4, 3);
e.add_box(dbox, {/*qbs*/ 0, 1, 2, 3, /*cbs*/ 0, 1, 2});
e.add_box(dbox, {/*qbs*/ 1, 2, 3, 0, /*cbs*/ 1, 2, 0});
REQUIRE(e.n_gates() == 2);
REQUIRE(!e.is_symbolic());
// A circuit equivalent to c0 without boxes
Circuit c0a(3);
c0a.add_op<unsigned>(OpType::Rx, 0.5, {0});
c0a.add_op<unsigned>(OpType::Ry, 1.5, {1});
c0a.add_op<unsigned>(OpType::Rz, 0.75, {2});
c0a.add_op<unsigned>(OpType::Ry, -0.75, {1});
c0a.add_op<unsigned>(OpType::CX, {1, 0});
c0a.add_op<unsigned>(OpType::CX, {1, 2});
// Check c0 and c0a are equivalent
Eigen::MatrixXcd uc0 = tket_sim::get_unitary(c0);
Eigen::MatrixXcd uc0a = tket_sim::get_unitary(c0a);
REQUIRE((uc0 - uc0a).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("Unitary1qBox manipulation") {
// random 1qb gate
Circuit setup(1);
setup.add_op<unsigned>(OpType::TK1, {0.2374, 1.0353, 0.5372}, {0});
Eigen::Matrix2cd m = get_matrix_from_circ(setup);
Unitary1qBox mbox(m);
Circuit c(1);
c.add_box(mbox, qubit_vector_t{Qubit("q", 0)});
REQUIRE(c.n_gates() == 1);
// extract its circuit
std::shared_ptr<Circuit> excirc = mbox.to_circuit();
// check we extract the same circuit from the deserialized box
VertexSet vset = c.get_gates_of_type(OpType::Unitary1qBox);
REQUIRE(vset.size() == 1);
Vertex v = *vset.begin();
Op_ptr op = c.get_Op_ptr_from_Vertex(v);
std::shared_ptr<const Unitary1qBox> b =
std::dynamic_pointer_cast<const Unitary1qBox>(op);
std::shared_ptr<Circuit> excirc1 = b->to_circuit();
REQUIRE(*excirc1 == *excirc);
// compose with inverse of box
c.append(c.dagger());
Eigen::MatrixXcd c1m = tket_sim::get_unitary(c);
// check it's the identity
REQUIRE((c1m - Eigen::Matrix2cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("Unitary2qBox manipulation") {
// permutation matrix
Eigen::Matrix4cd m;
m << 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0;
Unitary2qBox mbox(m);
Circuit c(2);
c.add_box(mbox, {0, 1});
REQUIRE(c.n_gates() == 1);
// make a more complicated 2-qubit circuit
Circuit d(2);
d.add_op<unsigned>(OpType::Rx, 0.2, {0});
d.add_op<unsigned>(OpType::Ry, 1.2, {1});
d.add_op<unsigned>(OpType::CX, {0, 1});
d.add_op<unsigned>(OpType::Rz, 0.4, {1});
d.add_op<unsigned>(OpType::H, {0});
d.add_op<unsigned>(OpType::CX, {1, 0});
// get its unitary
Eigen::Matrix4cd dm = get_matrix_from_2qb_circ(d);
// make a box out of this
Unitary2qBox dbox(dm);
// make this into a new circuit
Circuit d1(2);
d1.add_box(dbox, {0, 1});
// compose with inverse of d
d1.append(d.dagger());
Eigen::MatrixXcd d1m = tket_sim::get_unitary(d1);
// check it's the identity
REQUIRE((d1m - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("little-endian representation") {
Eigen::Matrix4cd m0;
m0 << 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0;
Unitary2qBox m0box(m0);
Circuit c0(2);
c0.add_box(m0box, {0, 1});
Circuit c1(2);
c1.add_op<unsigned>(OpType::CX, {0, 1});
Eigen::Matrix4cd m1 = get_matrix_from_2qb_circ(c1);
REQUIRE((m0 - m1).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("ExpBox manipulation") {
// random hermitian matrix
Eigen::Matrix4cd A;
A << 0., 1., 2., 3., 1., 2., 3. * i_, 4., 2., -3. * i_, 3, 2. - 3. * i_, 3.,
4., 2. + 3. * i_, 5.;
ExpBox ebox(A, -0.5);
Circuit c(2);
c.add_box(ebox, {0, 1});
Eigen::Matrix4cd U = (+0.5 * i_ * A).exp(); // should be the inverse
Unitary2qBox ubox(U);
c.add_box(ubox, {0, 1}); // should act as the identity
Eigen::MatrixXcd uc = tket_sim::get_unitary(c);
REQUIRE((uc - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
}
SCENARIO("Pauli gadgets", "[boxes]") {
GIVEN("X") {
// ---PauliExpBox([X], t)----Rx(-t)--- should be the identity
double t = 1.687029013593215;
Circuit c(1);
PauliExpBox pbox({Pauli::X}, t);
c.add_box(pbox, uvec{0});
c.add_op<unsigned>(OpType::Rx, -t, {0});
Eigen::Matrix2Xcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix2cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("Y") {
// ---PauliExpBox([Y], t)----Ry(-t)--- should be the identity
double t = 1.6791969622440162;
Circuit c(1);
PauliExpBox pbox({Pauli::Y}, t);
c.add_box(pbox, uvec{0});
c.add_op<unsigned>(OpType::Ry, -t, {0});
Eigen::Matrix2Xcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix2cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("Z") {
// ---PauliExpBox([Z], t)----Rz(-t)--- should be the identity
double t = 1.7811410013115163;
Circuit c(1);
PauliExpBox pbox({Pauli::Z}, t);
c.add_box(pbox, uvec{0});
c.add_op<unsigned>(OpType::Rz, -t, {0});
Eigen::Matrix2Xcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix2cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("II") {
double t = 0.10154905537993009;
Eigen::Matrix4cd a;
a << 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::I, Pauli::I}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("IX") {
double t = -0.9124813027056411;
Eigen::Matrix4cd a;
a << 0., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., 1., 0., 0., 1., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::I, Pauli::X}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("IY") {
double t = 0.4906808577976969;
Eigen::Matrix4cd a;
a << 0., -i_, 0., 0., i_, 0., 0., 0., 0., 0., 0., -i_, 0., 0., i_, 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::I, Pauli::Y}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("IZ") {
double t = -0.9536579982905538;
Eigen::Matrix4cd a;
a << 1., 0., 0., 0., 0., -1., 0., 0., 0., 0., 1., 0., 0., 0., 0., -1.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::I, Pauli::Z}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("XI") {
double t = 0.9735728239081902;
Eigen::Matrix4cd a;
a << 0., 0., 1., 0., 0., 0., 0., 1., 1., 0., 0., 0., 0., 1., 0., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::X, Pauli::I}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("XX") {
double t = 0.27251750245844586;
Eigen::Matrix4cd a;
a << 0., 0., 0., 1., 0., 0., 1., 0., 0., 1., 0., 0., 1., 0., 0., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::X, Pauli::X}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("XY") {
double t = -0.7252139115522431;
Eigen::Matrix4cd a;
a << 0., 0., 0., -i_, 0., 0., i_, 0., 0., -i_, 0., 0., i_, 0., 0., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::X, Pauli::Y}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("XZ") {
double t = 0.7474044702065266;
Eigen::Matrix4cd a;
a << 0., 0., 1., 0., 0., 0., 0., -1., 1., 0., 0., 0., 0., -1., 0., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::X, Pauli::Z}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("YI") {
double t = 0.31314409051199577;
Eigen::Matrix4cd a;
a << 0., 0., -i_, 0., 0., 0., 0., -i_, i_, 0., 0., 0., 0., i_, 0., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::Y, Pauli::I}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("YX") {
double t = -0.4855765841278301;
Eigen::Matrix4cd a;
a << 0., 0., 0., -i_, 0., 0., -i_, 0., 0., i_, 0., 0., i_, 0., 0., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::Y, Pauli::X}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("YY") {
double t = 0.3103588880238326;
Eigen::Matrix4cd a;
a << 0., 0., 0., -1., 0., 0., 1., 0., 0., 1., 0., 0., -1., 0., 0., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::Y, Pauli::Y}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("YZ") {
double t = -0.1130806991828821;
Eigen::Matrix4cd a;
a << 0., 0., -i_, 0., 0., 0., 0., i_, i_, 0., 0., 0., 0., -i_, 0., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::Y, Pauli::Z}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("ZI") {
double t = -0.21235736398463878;
Eigen::Matrix4cd a;
a << 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., -1., 0., 0., 0., 0., -1.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::Z, Pauli::I}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("ZX") {
double t = 0.5841730428035412;
Eigen::Matrix4cd a;
a << 0., 1., 0., 0., 1., 0., 0., 0., 0., 0., 0., -1., 0., 0., -1., 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::Z, Pauli::X}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("ZY") {
double t = 0.4300676558283072;
Eigen::Matrix4cd a;
a << 0., -i_, 0., 0., i_, 0., 0., 0., 0., 0., 0., i_, 0., 0., -i_, 0.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::Z, Pauli::Y}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("ZZ") {
double t = -0.18497547540553927;
Eigen::Matrix4cd a;
a << 1., 0., 0., 0., 0., -1., 0., 0., 0., 0., -1., 0., 0., 0., 0., 1.;
ExpBox ebox(a, +0.5 * PI * t);
Circuit c(2);
c.add_box(ebox, {0, 1});
PauliExpBox pbox({Pauli::Z, Pauli::Z}, t);
c.add_box(pbox, {0, 1});
Eigen::MatrixXcd u = tket_sim::get_unitary(c);
REQUIRE((u - Eigen::Matrix4cd::Identity()).cwiseAbs().sum() < ERR_EPS);
}
GIVEN("complex coefficient") {
Expr ei{SymEngine::I};
PauliExpBox pebox({Pauli::Z}, ei);
Expr p = pebox.get_phase();
REQUIRE(p == ei);
}
}
SCENARIO("box daggers", "[boxes]") {
GIVEN("a circuit made of various boxes") {
// CircuitBox
Circuit c0(2);
c0.add_op<unsigned>(OpType::Ry, -0.75, {0});
c0.add_op<unsigned>(OpType::CX, {0, 1});
CircBox cbox(c0);
// Unitary2qBox
Eigen::Matrix4cd m;
m << 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0;
Unitary2qBox ubox(m);
// ExpBox
Eigen::Matrix4cd A;
A << 0., 1., 2., 3., 1., 2., 3. * i_, 4., 2., -3. * i_, 3, 2. - 3. * i_, 3.,
4., 2. + 3. * i_, 5.;
ExpBox ebox(A, -0.5);
// PauliExpBox
PauliExpBox pbox({Pauli::X, Pauli::Y, Pauli::Z}, 0.8);
// Put all these boxes into a circuit
Circuit w(3);
w.add_op<unsigned>(OpType::Rx, 0.5, {0});
w.add_op<unsigned>(OpType::CX, {0, 1});
w.add_box(cbox, {1, 2});
w.add_box(ubox, {1, 0});
w.add_box(ebox, {2, 1});
w.add_box(pbox, {1, 2, 0});
// Compute the dagger
Circuit wdag = w.dagger();
// Check dagger is correct
w.append(wdag);
Eigen::MatrixXcd u = tket_sim::get_unitary(w);
REQUIRE((u - Eigen::MatrixXcd::Identity(8, 8)).cwiseAbs().sum() < ERR_EPS);
}
}
SCENARIO("QControlBox", "[boxes]") {
GIVEN("controlled X") {
Op_ptr op = get_op_ptr(OpType::X);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
Circuit expected(2);
expected.add_op<unsigned>(OpType::CX, {0, 1});
REQUIRE(*c == expected);
}
GIVEN("controlled CX") {
Op_ptr op = get_op_ptr(OpType::CX);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
Circuit expected(3);
expected.add_op<unsigned>(OpType::CCX, {0, 1, 2});
REQUIRE(*c == expected);
}
GIVEN("controlled CCX") {
Op_ptr op = get_op_ptr(OpType::CCX);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
Circuit expected(4);
expected.add_op<unsigned>(OpType::CnX, {0, 1, 2, 3});
REQUIRE(*c == expected);
}
GIVEN("controlled CnX") {
Circuit c0(4);
c0.add_op<unsigned>(OpType::CnX, {0, 1, 2, 3});
Op_ptr op = c0.get_commands()[0].get_op_ptr();
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
Circuit expected(5);
expected.add_op<unsigned>(OpType::CnX, {0, 1, 2, 3, 4});
REQUIRE(*c == expected);
}
GIVEN("controlled Rz") {
double a = 0.125;
Circuit c0(1);
c0.add_op<unsigned>(OpType::Rz, a, {0});
Op_ptr op = c0.get_commands()[0].get_op_ptr();
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(4, 4);
V(2, 2) = exp(-0.5 * i_ * PI * a);
V(3, 3) = exp(0.5 * i_ * PI * a);
REQUIRE(U.isApprox(V));
}
GIVEN("controlled Rx") {
double a = 0.125;
Circuit c0(1);
c0.add_op<unsigned>(OpType::Rx, a, {0});
Op_ptr op = c0.get_commands()[0].get_op_ptr();
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(4, 4);
V(2, 2) = std::cos(0.5 * PI * a);
V(2, 3) = i_ * std::sin(-0.5 * PI * a);
V(3, 2) = i_ * std::sin(-0.5 * PI * a);
V(3, 3) = std::cos(0.5 * PI * a);
REQUIRE(U.isApprox(V));
}
GIVEN("controlled Ry") {
double a = 0.125;
Circuit c0(1);
c0.add_op<unsigned>(OpType::Ry, a, {0});
Op_ptr op = c0.get_commands()[0].get_op_ptr();
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(4, 4);
V(2, 2) = std::cos(0.5 * PI * a);
V(2, 3) = std::sin(-0.5 * PI * a);
V(3, 2) = std::sin(0.5 * PI * a);
V(3, 3) = std::cos(0.5 * PI * a);
REQUIRE(U.isApprox(V));
}
GIVEN("controlled S") {
Op_ptr op = get_op_ptr(OpType::S);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(4, 4);
V(2, 2) = 1;
V(3, 3) = i_;
REQUIRE(U.isApprox(V));
}
GIVEN("controlled V") {
const double sq = 1 / std::sqrt(2.);
Op_ptr op = get_op_ptr(OpType::V);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(4, 4);
V(2, 2) = sq;
V(2, 3) = sq * -i_;
V(3, 2) = sq * -i_;
V(3, 3) = sq;
REQUIRE(U.isApprox(V));
}
GIVEN("controlled SX") {
Op_ptr op = get_op_ptr(OpType::SX);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(4, 4);
V(2, 2) = 0.5 * (1. + i_);
V(2, 3) = 0.5 * (1. - i_);
V(3, 2) = 0.5 * (1. - i_);
V(3, 3) = 0.5 * (1. + i_);
REQUIRE(U.isApprox(V));
}
GIVEN("controlled Sycamore") {
Op_ptr op = get_op_ptr(OpType::Sycamore);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(8, 8);
V(5, 5) = V(6, 6) = 0;
V(5, 6) = V(6, 5) = -i_;
V(7, 7) = exp(-i_ * PI / 6.);
REQUIRE(U.isApprox(V));
}
GIVEN("2-controlled X") {
Op_ptr op = get_op_ptr(OpType::X);
QControlBox qcbox(op, 2);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
Circuit expected(3);
expected.add_op<unsigned>(OpType::CCX, {0, 1, 2});
REQUIRE(*c == expected);
}
GIVEN("controlled CircBox") {
Circuit c0(2);
c0.add_op<unsigned>(OpType::H, {0});
c0.add_op<unsigned>(OpType::CX, {0, 1});
const Eigen::MatrixXcd U0 = tket_sim::get_unitary(c0);
CircBox cbox(c0);
Op_ptr op = std::make_shared<CircBox>(cbox);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(8, 8);
for (unsigned i = 0; i < 4; i++) {
for (unsigned j = 0; j < 4; j++) {
V(4 + i, 4 + j) = U0(i, j);
}
}
REQUIRE(U.isApprox(V));
}
GIVEN("controlled Unitary1qBox") {
Circuit c0(1);
c0.add_op<unsigned>(OpType::TK1, {0.6, 0.7, 0.8}, {0});
c0.add_phase(0.9);
Eigen::Matrix2cd m0 = get_matrix_from_circ(c0);
Unitary1qBox mbox(m0);
Op_ptr op = std::make_shared<Unitary1qBox>(mbox);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(4, 4);
for (unsigned i = 0; i < 2; i++) {
for (unsigned j = 0; j < 2; j++) {
V(2 + i, 2 + j) = m0(i, j);
}
}
REQUIRE(U.isApprox(V));
}
GIVEN("controlled Unitary2qBox") {
Circuit c0(2);
c0.add_op<unsigned>(OpType::Rx, 0.2, {0});
c0.add_op<unsigned>(OpType::Ry, 1.2, {1});
c0.add_op<unsigned>(OpType::CX, {0, 1});
c0.add_op<unsigned>(OpType::Rz, 0.4, {1});
c0.add_op<unsigned>(OpType::H, {0});
c0.add_op<unsigned>(OpType::CX, {1, 0});
Eigen::Matrix4cd m0 = get_matrix_from_2qb_circ(c0);
Unitary2qBox ubox(m0);
Op_ptr op = std::make_shared<Unitary2qBox>(ubox);
QControlBox qcbox(op);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
const Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(8, 8);
for (unsigned i = 0; i < 4; i++) {
for (unsigned j = 0; j < 4; j++) {
V(4 + i, 4 + j) = m0(i, j);
}
}
REQUIRE(U.isApprox(V));
}
GIVEN("2-controlled Unitary2qBox") {
// https://cqc.atlassian.net/browse/TKET-1651
Eigen::Matrix4cd M{{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, -1}};
Unitary2qBox ubox(M);
Op_ptr op = std::make_shared<Unitary2qBox>(ubox);
QControlBox qcbox(op, 2);
std::shared_ptr<Circuit> c = qcbox.to_circuit();
Eigen::MatrixXcd U = tket_sim::get_unitary(*c);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(16, 16);
V(15, 15) = -1;
REQUIRE(U.isApprox(V));
}
GIVEN("controlled symbolic operation") {
Sym s = SymEngine::symbol("a");
Expr a = Expr(s);
Op_ptr op = get_op_ptr(OpType::Rx, a);
QControlBox qcbox(op);
Circuit c(*qcbox.to_circuit());
double v = 0.125;
double x = std::cos(0.5 * PI * v), y = std::sin(0.5 * PI * v);
symbol_map_t map = {{s, v}};
c.symbol_substitution(map);
const Eigen::MatrixXcd U = tket_sim::get_unitary(c);
Eigen::Matrix4cd V = Eigen::Matrix4cd::Identity();
V(2, 2) = V(3, 3) = x;
V(2, 3) = V(3, 2) = -i_ * y;
REQUIRE(U.isApprox(V));
}
GIVEN("nested QControlBox") {
Op_ptr op = get_op_ptr(OpType::S);
QControlBox qcbox(op);
Circuit c(2);
c.add_op<unsigned>(OpType::H, {0});
c.add_box(qcbox, {0, 1});
const Eigen::MatrixXcd U = tket_sim::get_unitary(c);
CircBox cbox(c);
Op_ptr op1 = std::make_shared<CircBox>(cbox);
QControlBox qcbox1(op1);
std::shared_ptr<Circuit> c1 = qcbox1.to_circuit();
const Eigen::MatrixXcd U1 = tket_sim::get_unitary(*c1);
Eigen::MatrixXcd V = Eigen::MatrixXcd::Identity(8, 8);
for (unsigned i = 0; i < 4; i++) {
for (unsigned j = 0; j < 4; j++) {
V(4 + i, 4 + j) = U(i, j);
}
}
REQUIRE(U1.isApprox(V));
}
}
SCENARIO("Unitary3qBox", "[boxes]") {
GIVEN("An 8x8 permutation matrix") {
Eigen::MatrixXcd U = Eigen::MatrixXcd::Zero(8, 8);
U(0, 3) = 1;
U(1, 1) = 1;
U(2, 7) = 1;
U(3, 5) = 1;
U(4, 0) = 1;
U(5, 4) = 1;
U(6, 2) = 1;
U(7, 6) = 1;
Unitary3qBox ubox(U);
std::shared_ptr<const Circuit> c = ubox.to_circuit();
REQUIRE(c->count_gates(OpType::CX) <= 24);
Eigen::MatrixXcd U1 = tket_sim::get_unitary(*c);
REQUIRE(U1.isApprox(U));
}
}
SCENARIO("Checking equality", "[boxes]") {
GIVEN("Some different types") {
Circuit u(2);
u.add_op<unsigned>(OpType::Rz, -0.75, {0});
u.add_op<unsigned>(OpType::CX, {0, 1});
const CircBox ubox(u);
Eigen::Matrix4cd m = tket_sim::get_unitary(u);
Unitary2qBox mbox(m);
REQUIRE(ubox != mbox);
Op_ptr op1 = get_op_ptr(OpType::X);
Op_ptr op2 = get_op_ptr(OpType::Z);
REQUIRE(op1 == op1);
REQUIRE(op1 != op2);
Eigen::Matrix4cd A;
A << 0., 1., 2., 3., 1., 2., 3. * i_, 4., 2., -3. * i_, 3, 2. - 3. * i_, 3.,
4., 2. + 3. * i_, 5.;
ExpBox ebox(A, -0.5);
REQUIRE(ebox != mbox);
PhasePolyBox ppbox(u);
REQUIRE(ppbox != mbox);
}
GIVEN("CircBoxes") {
Circuit u(2);
u.add_op<unsigned>(OpType::Ry, -0.75, {0});
u.add_op<unsigned>(OpType::CX, {0, 1});
const CircBox ubox(u);
WHEN("both arguments are equal") { REQUIRE(ubox == ubox); }
WHEN("both arguments are different") { REQUIRE(ubox != CircBox(u)); }
}
GIVEN("Unitary1qBox") {
Circuit setup(1);
setup.add_op<unsigned>(OpType::TK1, {0.2374, 1.0353, 0.5372}, {0});
Eigen::Matrix2cd m = tket_sim::get_unitary(setup);
Unitary1qBox mbox(m);
WHEN("both arguments are equal") { REQUIRE(mbox == mbox); }
WHEN("both arguments are different") {
setup.add_op<unsigned>(OpType::TK1, {0.2374, 1.0353, 0.5372}, {0});
Eigen::Matrix2cd m2 = tket_sim::get_unitary(setup);
Unitary1qBox mbox2(m2);
REQUIRE(mbox != mbox2);
}
}
GIVEN("Unitary2qBox") {
Circuit setup(2);
setup.add_op<unsigned>(OpType::TK1, {0.2374, 1.0353, 0.5372}, {0});
setup.add_op<unsigned>(OpType::CX, {0, 1});
Eigen::Matrix4cd m = tket_sim::get_unitary(setup);
Unitary2qBox mbox(m);
WHEN("both arguments are equal") { REQUIRE(mbox == mbox); }
WHEN("both arguments are different") {
setup.add_op<unsigned>(OpType::CX, {1, 0});
Eigen::Matrix4cd m2 = tket_sim::get_unitary(setup);
Unitary2qBox mbox2(m2);
REQUIRE(mbox != mbox2);
}
}
GIVEN("Unitary3qBox") {
Circuit setup(3);
setup.add_op<unsigned>(OpType::TK1, {0.2374, 1.0353, 0.5372}, {0});
setup.add_op<unsigned>(OpType::CX, {0, 1});
setup.add_op<unsigned>(OpType::CX, {1, 2});
Eigen::MatrixXcd m = tket_sim::get_unitary(setup);
Unitary3qBox mbox(m);
WHEN("both arguments are equal") { REQUIRE(mbox == mbox); }
WHEN("both arguments are different") {
setup.add_op<unsigned>(OpType::CX, {0, 2});
Eigen::MatrixXcd m2 = tket_sim::get_unitary(setup);
Unitary3qBox mbox2(m2);
REQUIRE(mbox != mbox2);
}
}
GIVEN("ExpBox") {
// random hermitian matrix
Eigen::Matrix4cd A;
A << 0., 1., 2., 3., 1., 2., 3. * i_, 4., 2., -3. * i_, 3, 2. - 3. * i_, 3.,
4., 2. + 3. * i_, 5.;
ExpBox ebox(A, -0.5);
WHEN("both arguments are equal") { REQUIRE(ebox == ebox); }
WHEN("both arguments are different") {
ExpBox ebox2(A, -0.2);
REQUIRE(ebox != ebox2);
}
}
GIVEN("<NAME>") {
double t = 1.687029013593215;
PauliExpBox pbox({Pauli::X}, t);
WHEN("both arguments are equal") { REQUIRE(pbox == pbox); }
WHEN("both arguments are different") {
PauliExpBox pbox2({Pauli::Y}, t);
REQUIRE(pbox != pbox2);
}
}
GIVEN("QControlBox") {
Op_ptr op = get_op_ptr(OpType::X);
QControlBox qcbox(op);
WHEN("both arguments are equal") { REQUIRE(qcbox == qcbox); }
WHEN("both arguments are different") {
Op_ptr op2 = get_op_ptr(OpType::Y);
QControlBox qcbox2(op2);
REQUIRE(qcbox != qcbox2);
}
}
GIVEN("PhasePolyBox") {
Circuit u(2);
u.add_op<unsigned>(OpType::Rz, -0.75, {0});
u.add_op<unsigned>(OpType::CX, {0, 1});
PhasePolyBox ppbox(u);
WHEN("both arguments are equal") { REQUIRE(ppbox == ppbox); }
WHEN("both arguments are different") {
u.add_op<unsigned>(OpType::CX, {1, 0});
PhasePolyBox ppbox2(u);
REQUIRE(ppbox != ppbox2);
}
}
}
} // namespace test_Boxes
} // namespace tket
|
Ennosigaeon/scipy | scipy/io/_fortran.py | """
Module to read / write Fortran unformatted sequential files.
This is in the spirit of code written by <NAME> and <NAME>.
"""
import warnings
import numpy as np
__all__ = ['FortranFile', 'FortranEOFError', 'FortranFormattingError']
class FortranEOFError(TypeError, IOError):
"""Indicates that the file ended properly.
This error descends from TypeError because the code used to raise
TypeError (and this was the only way to know that the file had
ended) so users might have ``except TypeError:``.
"""
pass
class FortranFormattingError(TypeError, IOError):
"""Indicates that the file ended mid-record.
Descends from TypeError for backward compatibility.
"""
pass
class FortranFile:
"""
A file object for unformatted sequential files from Fortran code.
Parameters
----------
filename : file or str
Open file object or filename.
mode : {'r', 'w'}, optional
Read-write mode, default is 'r'.
header_dtype : dtype, optional
Data type of the header. Size and endiness must match the input/output file.
Notes
-----
These files are broken up into records of unspecified types. The size of
each record is given at the start (although the size of this header is not
standard) and the data is written onto disk without any formatting. Fortran
compilers supporting the BACKSPACE statement will write a second copy of
the size to facilitate backwards seeking.
This class only supports files written with both sizes for the record.
It also does not support the subrecords used in Intel and gfortran compilers
for records which are greater than 2GB with a 4-byte header.
An example of an unformatted sequential file in Fortran would be written as::
OPEN(1, FILE=myfilename, FORM='unformatted')
WRITE(1) myvariable
Since this is a non-standard file format, whose contents depend on the
compiler and the endianness of the machine, caution is advised. Files from
gfortran 4.8.0 and gfortran 4.1.2 on x86_64 are known to work.
Consider using Fortran direct-access files or files from the newer Stream
I/O, which can be easily read by `numpy.fromfile`.
Examples
--------
To create an unformatted sequential Fortran file:
>>> from scipy.io import FortranFile
>>> f = FortranFile('test.unf', 'w')
>>> f.write_record(np.array([1,2,3,4,5], dtype=np.int32))
>>> f.write_record(np.linspace(0,1,20).reshape((5,4)).T)
>>> f.close()
To read this file:
>>> f = FortranFile('test.unf', 'r')
>>> print(f.read_ints(np.int32))
[1 2 3 4 5]
>>> print(f.read_reals(float).reshape((5,4), order="F"))
[[0. 0.05263158 0.10526316 0.15789474]
[0.21052632 0.26315789 0.31578947 0.36842105]
[0.42105263 0.47368421 0.52631579 0.57894737]
[0.63157895 0.68421053 0.73684211 0.78947368]
[0.84210526 0.89473684 0.94736842 1. ]]
>>> f.close()
Or, in Fortran::
integer :: a(5), i
double precision :: b(5,4)
open(1, file='test.unf', form='unformatted')
read(1) a
read(1) b
close(1)
write(*,*) a
do i = 1, 5
write(*,*) b(i,:)
end do
"""
def __init__(self, filename, mode='r', header_dtype=np.uint32):
if header_dtype is None:
raise ValueError('Must specify dtype')
header_dtype = np.dtype(header_dtype)
if header_dtype.kind != 'u':
warnings.warn("Given a dtype which is not unsigned.")
if mode not in 'rw' or len(mode) != 1:
raise ValueError('mode must be either r or w')
if hasattr(filename, 'seek'):
self._fp = filename
else:
self._fp = open(filename, '%sb' % mode)
self._header_dtype = header_dtype
def _read_size(self, eof_ok=False):
n = self._header_dtype.itemsize
b = self._fp.read(n)
if (not b) and eof_ok:
raise FortranEOFError("End of file occurred at end of record")
elif len(b) < n:
raise FortranFormattingError(
"End of file in the middle of the record size")
return int(np.frombuffer(b, dtype=self._header_dtype, count=1))
def write_record(self, *items):
"""
Write a record (including sizes) to the file.
Parameters
----------
*items : array_like
The data arrays to write.
Notes
-----
Writes data items to a file::
write_record(a.T, b.T, c.T, ...)
write(1) a, b, c, ...
Note that data in multidimensional arrays is written in
row-major order --- to make them read correctly by Fortran
programs, you need to transpose the arrays yourself when
writing them.
"""
items = tuple(np.asarray(item) for item in items)
total_size = sum(item.nbytes for item in items)
nb = np.array([total_size], dtype=self._header_dtype)
nb.tofile(self._fp)
for item in items:
item.tofile(self._fp)
nb.tofile(self._fp)
def read_record(self, *dtypes, **kwargs):
"""
Reads a record of a given type from the file.
Parameters
----------
*dtypes : dtypes, optional
Data type(s) specifying the size and endiness of the data.
Returns
-------
data : ndarray
A 1-D array object.
Raises
------
FortranEOFError
To signal that no further records are available
FortranFormattingError
To signal that the end of the file was encountered
part-way through a record
Notes
-----
If the record contains a multidimensional array, you can specify
the size in the dtype. For example::
INTEGER var(5,4)
can be read with::
read_record('(4,5)i4').T
Note that this function does **not** assume the file data is in Fortran
column major order, so you need to (i) swap the order of dimensions
when reading and (ii) transpose the resulting array.
Alternatively, you can read the data as a 1-D array and handle the
ordering yourself. For example::
read_record('i4').reshape(5, 4, order='F')
For records that contain several variables or mixed types (as opposed
to single scalar or array types), give them as separate arguments::
double precision :: a
integer :: b
write(1) a, b
record = f.read_record('<f4', '<i4')
a = record[0] # first number
b = record[1] # second number
and if any of the variables are arrays, the shape can be specified as
the third item in the relevant dtype::
double precision :: a
integer :: b(3,4)
write(1) a, b
record = f.read_record('<f4', np.dtype(('<i4', (4, 3))))
a = record[0]
b = record[1].T
NumPy also supports a short syntax for this kind of type::
record = f.read_record('<f4', '(3,3)<i4')
See Also
--------
read_reals
read_ints
"""
dtype = kwargs.pop('dtype', None)
if kwargs:
raise ValueError("Unknown keyword arguments {}".format(tuple(kwargs.keys())))
if dtype is not None:
dtypes = dtypes + (dtype,)
elif not dtypes:
raise ValueError('Must specify at least one dtype')
first_size = self._read_size(eof_ok=True)
dtypes = tuple(np.dtype(dtype) for dtype in dtypes)
block_size = sum(dtype.itemsize for dtype in dtypes)
num_blocks, remainder = divmod(first_size, block_size)
if remainder != 0:
raise ValueError('Size obtained ({0}) is not a multiple of the '
'dtypes given ({1}).'.format(first_size, block_size))
if len(dtypes) != 1 and first_size != block_size:
# Fortran does not write mixed type array items in interleaved order,
# and it's not possible to guess the sizes of the arrays that were written.
# The user must specify the exact sizes of each of the arrays.
raise ValueError('Size obtained ({0}) does not match with the expected '
'size ({1}) of multi-item record'.format(first_size, block_size))
data = []
for dtype in dtypes:
r = np.fromfile(self._fp, dtype=dtype, count=num_blocks)
if len(r) != num_blocks:
raise FortranFormattingError(
"End of file in the middle of a record")
if dtype.shape != ():
# Squeeze outmost block dimension for array items
if num_blocks == 1:
assert r.shape == (1,) + dtype.shape
r = r[0]
data.append(r)
second_size = self._read_size()
if first_size != second_size:
raise IOError('Sizes do not agree in the header and footer for '
'this record - check header dtype')
# Unpack result
if len(dtypes) == 1:
return data[0]
else:
return tuple(data)
def read_ints(self, dtype='i4'):
"""
Reads a record of a given type from the file, defaulting to an integer
type (``INTEGER*4`` in Fortran).
Parameters
----------
dtype : dtype, optional
Data type specifying the size and endiness of the data.
Returns
-------
data : ndarray
A 1-D array object.
See Also
--------
read_reals
read_record
"""
return self.read_record(dtype)
def read_reals(self, dtype='f8'):
"""
Reads a record of a given type from the file, defaulting to a floating
point number (``real*8`` in Fortran).
Parameters
----------
dtype : dtype, optional
Data type specifying the size and endiness of the data.
Returns
-------
data : ndarray
A 1-D array object.
See Also
--------
read_ints
read_record
"""
return self.read_record(dtype)
def close(self):
"""
Closes the file. It is unsupported to call any other methods off this
object after closing it. Note that this class supports the 'with'
statement in modern versions of Python, to call this automatically
"""
self._fp.close()
def __enter__(self):
return self
def __exit__(self, type, value, tb):
self.close()
|
yinchengtsinghua/RippleCPPChinese | src/ripple/protocol/tokens.h | <gh_stars>1-10
//此源码被清华学神尹成大魔王专业翻译分析并修改
//尹成QQ77025077
//尹成微信18510341407
//尹成所在QQ群721929980
//尹成邮箱 <EMAIL>
//尹成毕业于清华大学,微软区块链领域全球最有价值专家
//https://mvp.microsoft.com/zh-cn/PublicProfile/4033620
//————————————————————————————————————————————————————————————————————————————————————————————————————————————————
/*
此文件是Rippled的一部分：https://github.com/ripple/rippled
版权所有（c）2012，2013 Ripple Labs Inc.
使用、复制、修改和/或分发本软件的权限
特此授予免费或不收费的目的，前提是
版权声明和本许可声明出现在所有副本中。
本软件按“原样”提供，作者不作任何保证。
关于本软件，包括
适销性和适用性。在任何情况下，作者都不对
任何特殊、直接、间接或后果性损害或任何损害
因使用、数据或利润损失而导致的任何情况，无论是在
合同行为、疏忽或其他侵权行为
或与本软件的使用或性能有关。
**/
//==============================================================
#ifndef RIPPLE_PROTOCOL_TOKENS_H_INCLUDED
#define RIPPLE_PROTOCOL_TOKENS_H_INCLUDED
#include <boost/optional.hpp>
#include <cstdint>
#include <string>
namespace ripple {
enum class TokenType : std::uint8_t
{
None = 1, //未使用的
NodePublic = 28,
NodePrivate = 32,
AccountID = 0,
AccountPublic = 35,
AccountSecret = 34,
FamilyGenerator = 41, //未使用的
FamilySeed = 33
};
template <class T>
boost::optional<T>
parseBase58 (std::string const& s);
template<class T>
boost::optional<T>
parseBase58 (TokenType type, std::string const& s);
template <class T>
boost::optional<T>
parseHex (std::string const& s);
template <class T>
boost::optional<T>
parseHexOrBase58 (std::string const& s);
//用于转换Ripple令牌的工具
//从人类可读的字符串
/*Base-58编码纹波令牌
Ripple标记有一个单字节前缀，表示
标记的类型，后跟
令牌，最后是4字节校验和。
令牌包括以下内容：
钱包种子
帐户公钥
账号标识
@param type表示标记类型的单个字节
@param token指向存储非的指针
小于2*（大小+6）字节
@param size令牌缓冲区的大小（以字节为单位）
**/
std::string
base58EncodeToken (TokenType type, void const* token, std::size_t size);
/*Base-58编码比特币代币
*
*这里提供对称，但不应需要
*测试除外。
*
*@有关格式说明，请参阅base58encodetoken。
*
**/
std::string
base58EncodeTokenBitcoin (TokenType type, void const* token, std::size_t size);
/*解码base58令牌
类型和校验和必须匹配或
返回空字符串。
**/
std::string
decodeBase58Token(std::string const& s, TokenType type);
/*使用比特币字母解码base58令牌
类型和校验和必须匹配或
返回空字符串。
用于检测用户错误。明确地，
当使用错误的
以58为基数的字母表，以便更好地显示错误信息
可以退回。
**/
std::string
decodeBase58TokenBitcoin(std::string const& s, TokenType type);
} //涟漪
#endif
|
BALL-Contrib/contrib_boost_1.66.0 | libs/unordered/test/unordered/load_factor_tests.cpp | <filename>libs/unordered/test/unordered/load_factor_tests.cpp
// Copyright 2006-2009 <NAME>.
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
// clang-format off
#include "../helpers/prefix.hpp"
#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
#include "../helpers/postfix.hpp"
// clang-format on
#include "../helpers/test.hpp"
#include <boost/limits.hpp>
#include "../helpers/random_values.hpp"
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable : 4127) // conditional expression is constant
#endif
namespace load_factor_tests {
test::seed_t initialize_seed(783656);
template <class X> void set_load_factor_tests(X*)
{
X x;
BOOST_TEST(x.max_load_factor() == 1.0);
BOOST_TEST(x.load_factor() == 0);
// A valid implementation could fail these tests, but I think they're
// reasonable.
x.max_load_factor(2.0);
BOOST_TEST(x.max_load_factor() == 2.0);
x.max_load_factor(0.5);
BOOST_TEST(x.max_load_factor() == 0.5);
}
template <class X>
void insert_test(X*, float mlf, test::random_generator generator)
{
X x;
x.max_load_factor(mlf);
float b = x.max_load_factor();
test::random_values<X> values(1000, generator);
for (BOOST_DEDUCED_TYPENAME test::random_values<X>::const_iterator
it = values.begin(),
end = values.end();
it != end; ++it) {
BOOST_DEDUCED_TYPENAME X::size_type old_size = x.size(),
old_bucket_count = x.bucket_count();
x.insert(*it);
if (static_cast<double>(old_size + 1) <=
b * static_cast<double>(old_bucket_count))
BOOST_TEST(x.bucket_count() == old_bucket_count);
}
}
template <class X>
void load_factor_insert_tests(X* ptr, test::random_generator generator)
{
insert_test(ptr, 1.0f, generator);
insert_test(ptr, 0.1f, generator);
insert_test(ptr, 100.0f, generator);
insert_test(ptr, (std::numeric_limits<float>::min)(), generator);
if (std::numeric_limits<float>::has_infinity)
insert_test(ptr, std::numeric_limits<float>::infinity(), generator);
}
boost::unordered_set<int>* int_set_ptr;
boost::unordered_multiset<int>* int_multiset_ptr;
boost::unordered_map<int, int>* int_map_ptr;
boost::unordered_multimap<int, int>* int_multimap_ptr;
using test::default_generator;
using test::generate_collisions;
using test::limited_range;
UNORDERED_TEST(set_load_factor_tests,
((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr)))
UNORDERED_TEST(load_factor_insert_tests,
((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))(
(default_generator)(generate_collisions)(limited_range)))
}
RUN_TESTS()
#if defined(BOOST_MSVC)
#pragma warning(pop)
#pragma warning(disable : 4127) // conditional expression is constant
#endif
|
yingyueshi/journalkeeper | journalkeeper-core/src/main/java/io/journalkeeper/core/state/Snapshot.java | <reponame>yingyueshi/journalkeeper
package io.journalkeeper.core.state;
import io.journalkeeper.base.Replicable;
import io.journalkeeper.base.ReplicableIterator;
import io.journalkeeper.core.api.EntryFuture;
import io.journalkeeper.core.api.JournalEntry;
import io.journalkeeper.core.api.RaftJournal;
import io.journalkeeper.core.api.StateFactory;
import io.journalkeeper.core.api.StateResult;
import io.journalkeeper.core.journal.Journal;
import io.journalkeeper.exceptions.StateQueryException;
import io.journalkeeper.exceptions.StateRecoverException;
import io.journalkeeper.persistence.MetadataPersistence;
import io.journalkeeper.utils.files.FileUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
/**
* @author LiYue
* Date: 2020/4/17
*/
public class Snapshot extends JournalKeeperState implements Replicable {
private static final Logger logger = LoggerFactory.getLogger(Snapshot.class);
private static final String SNAPSHOT_FILE = "snapshot";
private AtomicBoolean isUserStateAvailable = new AtomicBoolean(false);
private static final int MAX_TRUNK_SIZE = 1024 * 1024;
public Snapshot(StateFactory userStateFactory, MetadataPersistence metadataPersistence) {
super(userStateFactory, metadataPersistence);
}
@Override
public void recover(Path path, Properties properties) {
File snapshotFile = path.resolve(SNAPSHOT_FILE).toFile();
if (!snapshotFile.isFile()) {
throw new StateRecoverException(
String.format("Incomplete snapshot: %s!", path.toString())
);
}
super.recover(path, properties, false);
}
public void createSnapshot(Journal journal) throws IOException {
internalState.setSnapshotTimestamp(System.currentTimeMillis());
internalState.setMinOffset(
journal.maxIndex() == internalState.minIndex() ? journal.maxOffset() :
journal.readOffset(internalState.minIndex())
);
Map<Integer, Long> partitionIndices = journal.calcPartitionIndices(internalState.minOffset());
internalState.setPartitionIndices(partitionIndices);
flushInternalState();
}
public void createFirstSnapshot(Set<Integer> partitions) throws IOException{
internalState.setSnapshotTimestamp(System.currentTimeMillis());
internalState.setMinOffset(0L);
Map<Integer, Long> partitionIndices = partitions.stream().collect(Collectors.toMap(p -> p, p -> 0L));
internalState.setPartitionIndices(partitionIndices);
flushInternalState();
}
public long timestamp() {
return internalState.getSnapshotTimestamp();
}
private void maybeRecoverUserState() throws IOException {
if(isUserStateAvailable.compareAndSet(false, true)) {
recoverUserState();
}
isUserStateAvailable.set(true);
}
@Override
public StateResult applyEntry(JournalEntry entryHeader, EntryFuture entryFuture, RaftJournal journal) {
throw new UnsupportedOperationException("Apply entry on a snapshot is now allowed!");
}
@Override
public StateQueryResult query(byte[] query, RaftJournal journal) {
try {
maybeRecoverUserState();
return super.query(query, journal);
} catch (IOException e) {
throw new StateQueryException(e);
}
}
public void dumpUserState(Path destPath) throws IOException {
FileUtils.dump(path.resolve(USER_STATE_PATH), destPath.resolve(USER_STATE_PATH));
}
public static void markComplete(Path path) throws IOException {
FileUtils.createIfNotExists(path.resolve(SNAPSHOT_FILE));
}
@Override
public ReplicableIterator iterator() throws IOException {
return new FolderTrunkIterator(path, listAllFiles(path), MAX_TRUNK_SIZE, lastIncludedIndex(), lastIncludedTerm());
}
/**
* 列出所有复制时需要拷贝的文件。
* @return 所有需要复制的文件的Path
*/
private List<Path> listAllFiles(Path path) throws IOException {
List<Path> allFiles = new ArrayList<>(FileUtils.listAllFiles(path));
if (allFiles.remove(path.resolve(SNAPSHOT_FILE))) {
allFiles.add(path.resolve(SNAPSHOT_FILE));
}
return allFiles;
}
}
|
navikt/arxaas | src/test/java/no/nav/arxaas/GenerateEdgeCaseData.java | package no.nav.arxaas;
import com.fasterxml.jackson.databind.ObjectMapper;
import no.nav.arxaas.model.Attribute;
import no.nav.arxaas.model.anonymity.PrivacyCriterionModel;
import no.nav.arxaas.model.Request;
import org.springframework.mock.web.MockMultipartFile;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static no.nav.arxaas.model.AttributeTypeModel.*;
public class GenerateEdgeCaseData {
public static Request NullPayload(){
return new Request(null,null,null,null);
}
public static Request zipcodeRequestPayloadWithSuppressionLimitGreaterThan1(){
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = zipcodeHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = 2.0;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayloadWithSuppressionLimitLessserThan0(){
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = zipcodeHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = -1.0;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayloadWithoutData() {
List<String[]> listHierarchy = zipcodeHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = 0.02;
return new Request(null, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayloadWithoutAttributes() {
List<String[]> testData = ageGenderZipcodeData();
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = 0.02;
return new Request(testData, null, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayloadWithoutPrivacyModels() {
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = zipcodeHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, null,suppressionLimit);
}
public static Request zipcodeRequestPayload_wrong_data_format() {
List<String[]> testData = wrongFromatData();
List<String[]> listHierarchy = zipcodeHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayload_wrong_hierarchy(){
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = ageHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayload_privacy_model_on_non_sensitive_data(){
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = zipcodeHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes2Quasi(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayload_wrong_privacy_model_format(){
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = zipcodeHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcode_wrong_PrivacyModels();
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayload_wrong_ldiv_column_key_name(){
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = zipcodeHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcode_wrong_LDivColumnKey();
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayload_wrong_hierarchy_format(){
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = zipcodeHierarchy_wrong_format();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayload_wrong_attribute_format(){
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = zipcodeHierarchy();
List<Attribute> testAttributes = ageGenderZipcodeAttributes_wrong_format(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayload_all_format_wrong(){
List<String[]> testData = wrongFromatData();
List<String[]> listHierarchy = zipcodeHierarchy_wrong_format();
List<Attribute> testAttributes = ageGenderZipcodeAttributes_wrong_format(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcode_wrong_PrivacyModels();
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
public static Request zipcodeRequestPayload3QuasiNoHierarchies(){
List<String[]> testData = ageGenderZipcodeData();
List<String []> listZipHierarchy = zipcodeHierarchy();
//Defining attribute types(sensitive, identifying, quasi-identifying, insensitive, etc)
List<Attribute> testAttributes = new ArrayList<>();
testAttributes.add(new Attribute("age",QUASIIDENTIFYING, null));
testAttributes.add(new Attribute("gender",QUASIIDENTIFYING, null));
testAttributes.add(new Attribute("zipcode",QUASIIDENTIFYING, listZipHierarchy));
//Define K-anonymity
List<PrivacyCriterionModel> privacyCriterionModelList = new ArrayList<>();
Map<String,String> kMapValue = new HashMap<>();
kMapValue.put("k","2");
privacyCriterionModelList.add(new PrivacyCriterionModel(PrivacyCriterionModel.PrivacyModel.KANONYMITY, kMapValue));
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModelList,suppressionLimit);
}
public static Request zipcodeRequestPaylaod_hierarchy_having_data_not_included_in_dataset(){
List<String[]> testData = ageGenderZipcodeData();
List<String[]> listHierarchy = zipcodeHierarchy_having_data_not_existing_in_dataset();
List<Attribute> testAttributes = ageGenderZipcodeAttributes(listHierarchy);
List<PrivacyCriterionModel> privacyCriterionModels = ageGenderZipcodePrivacyModels();
Double suppressionLimit = 0.02;
return new Request(testData, testAttributes, privacyCriterionModels,suppressionLimit);
}
private static List<String[]> wrongFromatData() {
String[][] rawData = {{"age, gender, zipcode" },
{"34, male, 81667"},
{"35, female, 81668"},
{"36, male, 81669"},
{"37, female, 81670"},
{"38, male, 81671"},
{"39, female, 81672"},
{"40, male, 81673"},
{"41, female, 81674"},
{"42, male, 81675"},
{"43, female, 81676"},
{"44, male, 81677"}};
return List.of(rawData);
}
private static List<String[]> ageGenderZipcodeData() {
String[][] rawData = {{"age", "gender", "zipcode" },
{"34", "male", "81667"},
{"35", "female", "81668"},
{"36", "male", "81669"},
{"37", "female", "81670"},
{"38", "male", "81671"},
{"39", "female", "81672"},
{"40", "male", "81673"},
{"41", "female", "81674"},
{"42", "male", "81675"},
{"43", "female", "81676"},
{"44", "male", "81677"}};
return List.of(rawData);
}
public static List<String[]> ageGenderZipcodeDataAfterAnonymization(){
String[][] rawData = {{"age", "gender", "zipcode" },
{"*", "male", "816**"},
{"*", "female", "816**"},
{"*", "male", "816**"},
{"*", "female", "816**"},
{"*", "male", "816**"},
{"*", "female", "816**"},
{"*", "male", "816**"},
{"*", "female", "816**"},
{"*", "male", "816**"},
{"*", "female", "816**"},
{"*", "male", "816**"}};
return List.of(rawData);
}
private static List<String[]> ageHierarchy() {
String[][] newAgeHiarchy = {
{"34", "<50", "*"},
{"35", "<50", "*"},
{"36", "<50", "*"},
{"37", "<50", "*"},
{"38", "<50", "*"},
{"39", "<50", "*"},
{"40", "<50", "*"},
{"41", "<50", "*"},
{"42", "<50", "*"},
{"43", "<50", "*"},
{"44", "<50", "*"}};
return List.of(newAgeHiarchy);
}
private static List<String[]> zipcodeHierarchy() {
//Defining Hierarchy for a give column name
String[][] testHeirarchy = {
{"81667", "8166*", "816**", "81***", "8****", "*****"}
, {"81668", "8166*", "816**", "81***", "8****", "*****"}
, {"81669", "8166*", "816**", "81***", "8****", "*****"}
, {"81670", "8167*", "816**", "81***", "8****", "*****"}
, {"81671", "8167*", "816**", "81***", "8****", "*****"}
, {"81672", "8167*", "816**", "81***", "8****", "*****"}
, {"81673", "8167*", "816**", "81***", "8****", "*****"}
, {"81674", "8167*", "816**", "81***", "8****", "*****"}
, {"81675", "8167*", "816**", "81***", "8****", "*****"}
, {"81676", "8167*", "816**", "81***", "8****", "*****"}
, {"81677", "8167*", "816**", "81***", "8****", "*****"}};
return List.of(testHeirarchy);
}
private static List<String[]> zipcodeHierarchy_wrong_format() {
//Defining Hierarchy for a give column name
String[][] testHeirarchy = {
{"81667, 8166*, 816**, 81***, 8****, *****"}
, {"81668, 8166*, 816**, 81***, 8****, *****"}
, {"81669, 8166*, 816**, 81***, 8****, *****"}
, {"81670, 8167*, 816**, 81***, 8****, *****"}
, {"81671, 8167*, 816**, 81***, 8****, *****"}
, {"81672, 8167*, 816**, 81***, 8****, *****"}
, {"81673, 8167*, 816**, 81***, 8****, *****"}
, {"81674, 8167*, 816**, 81***, 8****, *****"}
, {"81675, 8167*, 816**, 81***, 8****, *****"}
, {"81676, 8167*, 816**, 81***, 8****, *****"}
, {"81677, 8167*, 816**, 81***, 8****, *****"}};
return List.of(testHeirarchy);
}
private static List<String[]> zipcodeHierarchy_having_data_not_existing_in_dataset() {
//Defining Hierarchy for a give column name
String[][] testHeirarchy = {
{"81667", "8166*", "816**", "81***", "8****", "*****"}
, {"81668", "8166*", "816**", "81***", "8****", "*****"}
, {"81669", "8166*", "816**", "81***", "8****", "*****"}
, {"81670", "8167*", "816**", "81***", "8****", "*****"}
, {"81671", "8167*", "816**", "81***", "8****", "*****"}
, {"81672", "8167*", "816**", "81***", "8****", "*****"}
, {"81673", "8167*", "816**", "81***", "8****", "*****"}
, {"81674", "8167*", "816**", "81***", "8****", "*****"}
, {"81675", "8167*", "816**", "81***", "8****", "*****"}
, {"81676", "8167*", "816**", "81***", "8****", "*****"}
, {"81677", "8167*", "816**", "81***", "8****", "*****"}
, {"81678", "8167*", "816**", "81***", "8****", "*****"}
, {"81679", "8167*", "816**", "81***", "8****", "*****"}
, {"81680", "8168*", "816**", "81***", "8****", "*****"}
, {"81681", "8168*", "816**", "81***", "8****", "*****"}
, {"81682", "8168*", "816**", "81***", "8****", "*****"}};
return List.of(testHeirarchy);
}
private static List<Attribute> ageGenderZipcodeAttributes(List<String[]> listHierarchy) {
//Defining attribute types(sensitive, identifying, quasi-identifying, insensitive, etc)
List<Attribute> testAttributes = new ArrayList<>();
testAttributes.add(new Attribute("age",IDENTIFYING, null));
testAttributes.add(new Attribute("gender",SENSITIVE, null));
testAttributes.add(new Attribute("zipcode",QUASIIDENTIFYING, listHierarchy));
return testAttributes;
}
private static List<Attribute> ageGenderZipcodeAttributes2Quasi(List<String[]> listHierarchy) {
//Defining attribute types(sensitive, identifying, quasi-identifying, insensitive, etc)
List<Attribute> testAttributes = new ArrayList<>();
testAttributes.add(new Attribute("age",IDENTIFYING, null));
testAttributes.add(new Attribute("gender",QUASIIDENTIFYING, null));
testAttributes.add(new Attribute("zipcode",QUASIIDENTIFYING, listHierarchy));
return testAttributes;
}
private static List<Attribute> ageGenderZipcodeAttributes_wrong_format(List<String[]> listHierarchy) {
//Defining attribute types(sensitive, identifying, quasi-identifying, insensitive, etc)
List<Attribute> testAttributes = new ArrayList<>();
testAttributes.add(new Attribute("ageE",IDENTIFYING, null));
testAttributes.add(new Attribute("geNder",QUASIIDENTIFYING, null));
testAttributes.add(new Attribute("Zipcode",QUASIIDENTIFYING, listHierarchy));
return testAttributes;
}
private static List<PrivacyCriterionModel> ageGenderZipcodePrivacyModels() {
//Define K-anonymity
List<PrivacyCriterionModel> privacyCriterionModelList = new ArrayList<>();
Map<String,String> kMapValue = new HashMap<>();
kMapValue.put("k","5");
privacyCriterionModelList.add(new PrivacyCriterionModel(PrivacyCriterionModel.PrivacyModel.KANONYMITY, kMapValue));
Map<String,String> lMapValue = new HashMap<>();
lMapValue.put("l", "2");
lMapValue.put("column_name", "gender");
privacyCriterionModelList.add(new PrivacyCriterionModel(PrivacyCriterionModel.PrivacyModel.LDIVERSITY_DISTINCT, lMapValue));
return privacyCriterionModelList;
}
private static List<PrivacyCriterionModel> ageGenderZipcode_wrong_PrivacyModels() {
//Define K-anonymity
List<PrivacyCriterionModel> privacyCriterionModelList = new ArrayList<>();
Map<String,String> kMapValue = new HashMap<>();
kMapValue.put("kl","5");
privacyCriterionModelList.add(new PrivacyCriterionModel(PrivacyCriterionModel.PrivacyModel.KANONYMITY, kMapValue));
Map<String,String> lMapValue = new HashMap<>();
lMapValue.put("t", "2");
lMapValue.put("column_names", "gender");
lMapValue.put("k", "gender");
privacyCriterionModelList.add(new PrivacyCriterionModel(PrivacyCriterionModel.PrivacyModel.LDIVERSITY_DISTINCT, lMapValue));
return privacyCriterionModelList;
}
private static List<PrivacyCriterionModel> ageGenderZipcode_wrong_LDivColumnKey() {
List<PrivacyCriterionModel> privacyCriterionModelList = new ArrayList<>();
Map<String,String> kMapValue = new HashMap<>();
kMapValue.put("k","5");
privacyCriterionModelList.add(new PrivacyCriterionModel(PrivacyCriterionModel.PrivacyModel.KANONYMITY, kMapValue));
Map<String,String> lMapValue = new HashMap<>();
lMapValue.put("l", "2");
lMapValue.put("label", "gender");
privacyCriterionModelList.add(new PrivacyCriterionModel(PrivacyCriterionModel.PrivacyModel.LDIVERSITY_DISTINCT, lMapValue));
return privacyCriterionModelList;
}
public static MockMultipartFile testDatasetComma(){
return (MockMultipartFile) GenerateTestData.makeMockMultipartFile("./src/test/resources/testDatasetComma.csv", "file", "text/csv");
}
public static MockMultipartFile testDatasetSpecialFormat(){
return (MockMultipartFile) GenerateTestData.makeMockMultipartFile("./src/test/resources/testDatasetSpecialFormat.csv", "file", "text/csv");
}
public static MockMultipartFile testDatasetWrongFormat(){
return (MockMultipartFile) GenerateTestData.makeMockMultipartFile("./src/test/resources/testDatasetWrongFormat.csv", "file", "text/csv");
}
public static MockMultipartFile testMetaDataWrongFormat() {
return new MockMultipartFile("metadata", "","application/json", testFormData_metadata_two_quasi_attribute_wrong_format().getBytes());
}
public static MockMultipartFile testMetaDataThreeQuasiAttribute() {
return new MockMultipartFile("metadata", "","application/json", testFormData_metadata_three_quasi_attribute().getBytes());
}
public static MockMultipartFile testMetaDataMissingPrivacyModel() {
return new MockMultipartFile("metadata", "","application/json", testFormData_metadata_missing_privacy_models().getBytes());
}
public static MockMultipartFile testMetaDataPrivacyModelOnNonExistingAttribute() {
return new MockMultipartFile("metadata", "","application/json", testFormData_metadata_privacy_models_for_non_existing_attribute().getBytes());
}
public static MockMultipartFile testMetaDataWrongPrivacyFormat(){
return new MockMultipartFile("metadata", "","application/json", testFormData_metadata_wrong_privacy_model_format().getBytes());
}
public static MockMultipartFile testMetaDataSuppressionHigherThanOne(){
return new MockMultipartFile("metadata", "","application/json", testFormData_metadata_two_quasi_supression_higher_than_one().getBytes());
}
public static MockMultipartFile testMetaDataSuppressionLowerThanZero(){
return new MockMultipartFile("metadata", "","application/json", testFormData_metadata_two_quasi_supression_lower_than_zero().getBytes());
}
public static MockMultipartFile testMetaDataOneSensitiveAttribute(){
return new MockMultipartFile("metadata", "","application/json", testFormData_metadata_one_sensitive_attribute().getBytes());
}
public static MockMultipartFile testZipcodeHierarchyWrongFormat() {
return (MockMultipartFile) GenerateTestData.makeMockMultipartFile("./src/test/resources/testZipcodeHierarchyWrongFormat.csv","hierarchies","text/csv");
}
public static MockMultipartFile testZipcodeHierarchyMoreData() {
return (MockMultipartFile) GenerateTestData.makeMockMultipartFile("./src/test/resources/testZipcodeHierarchyMore.csv","hierarchies","text/csv");
}
private static String testFormData_metadata_two_quasi_attribute_wrong_format(){
return "{\"attributes\":[{\"field\":\"aGe\",\"attributeTypeModel\":\"IDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"GendEr\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"ZiPcoDe\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":1}]," +
"\"privacyModels\":[{\"privacyModel\":\"KANONYMITY\",\"params\":{\"k\":5}}]," +
"\"suppressionLimit\":0.02}";
}
private static String testFormData_metadata_three_quasi_attribute(){
return "{\"attributes\":[{\"field\":\"age\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"gender\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"zipcode\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":1}]," +
"\"privacyModels\":[{\"privacyModel\":\"KANONYMITY\",\"params\":{\"k\":5}}]," +
"\"suppressionLimit\":0.02}";
}
private static String testFormData_metadata_missing_privacy_models(){
return "{\"attributes\":[{\"field\":\"age\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"gender\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"zipcode\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":1}]}";
}
private static String testFormData_metadata_privacy_models_for_non_existing_attribute(){
return "{\"attributes\":[{\"field\":\"age\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"gender\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"zipcode\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":1}]," +
"\"privacyModels\":[{\"privacyModel\":\"KANONYMITY\",\"params\":{\"k\":5}}," +
"{\"privacyModel\":\"LDIVERSITY_DISTINCT\",\"params\":{\"l\":2,\"column_name\":\"Medisinsk forhold\"}}]," +
"\"suppressionLimit\":0.02}";
}
private static String testFormData_metadata_wrong_privacy_model_format(){
return "{\"attributes\":[{\"field\":\"age\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"gender\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"zipcode\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":1}]," +
"\"privacyModels\":[{\"privacyModel\":\"LDIVERSITY_DISTINCT\",\"params\":{\"kl\":5}}," +
"{\"privacyModel\":\"KANONYMITY\",\"params\":{\"l\":2,\"column_name\":\"Medisinsk forhold\"}}]," +
"\"suppressionLimit\":0.02}";
}
private static String testFormData_metadata_two_quasi_supression_higher_than_one(){
return "{\"attributes\":[{\"field\":\"age\",\"attributeTypeModel\":\"IDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"gender\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"zipcode\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":1}]," +
"\"privacyModels\":[{\"privacyModel\":\"KANONYMITY\",\"params\":{\"k\":5}}]," +
"\"suppressionLimit\":10000}";
}
private static String testFormData_metadata_two_quasi_supression_lower_than_zero(){
return "{\"attributes\":[{\"field\":\"age\",\"attributeTypeModel\":\"IDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"gender\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"zipcode\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":1}]," +
"\"privacyModels\":[{\"privacyModel\":\"KANONYMITY\",\"params\":{\"k\":5}}]," +
"\"suppressionLimit\":-10000}";
}
private static String testFormData_metadata_one_sensitive_attribute(){
return "{\"attributes\":[{\"field\":\"age\",\"attributeTypeModel\":\"IDENTIFYING\",\"hierarchy\":null}," +
"{\"field\":\"gender\",\"attributeTypeModel\":\"SENSITIVE\",\"hierarchy\":null}," +
"{\"field\":\"zipcode\",\"attributeTypeModel\":\"QUASIIDENTIFYING\",\"hierarchy\":0}]," +
"\"privacyModels\":[{\"privacyModel\":\"KANONYMITY\",\"params\":{\"k\":5}}," +
"{\"privacyModel\":\"LDIVERSITY_DISTINCT\",\"params\":{\"column_name\":\"gender\",\"l\":2}}]," +
"\"suppressionLimit\":0.02}";
}
} |
FatihBozik/ocp8-study-guide | advanced-class-design/src/main/java/io/github/fatihbozik/ch1/objectmethods/tostring/example3/ApacheToString.java | <filename>advanced-class-design/src/main/java/io/github/fatihbozik/ch1/objectmethods/tostring/example3/ApacheToString.java
package io.github.fatihbozik.ch1.objectmethods.tostring.example3;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
/**
* @author <NAME>
*/
class Hippo {
private String name;
private double weight;
public Hippo(String name, double weight) {
this.name = name;
this.weight = weight;
}
public String toString() {
return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
// return ToStringBuilder.reflectionToString(this);
// return new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE)
// .append("name", name)
// .append("weight", weight)
// .toString();
}
}
public class ApacheToString {
public static void main(String[] args) {
Hippo hippo = new Hippo("John", 86869);
System.out.println(hippo); // Hippo[name=John,weight=86869.0]
}
}
|
leslie-qiwa/box | builder/command/commands.go | // Package command - command for the box builder
//
// Documentation is deliberately simple here, it maps directly to the verbs and
// functions in the box builder documentation:
// https://box-builder.github.io/box. Duplicating it here seems pointless.
//
package command
import (
"github.com/box-builder/box/builder/executor"
"github.com/box-builder/box/types"
)
// Interpreter is a set of statements combined with an executor used to compose
// images. It is driven by an evaluator.
type Interpreter struct {
CacheKey string // if set to "", does not consider cache next step
globals *types.Global
exec executor.Executor
vars map[string]string
}
// NewInterpreter contypes a new *Interpreter.
func NewInterpreter(globals *types.Global, exec executor.Executor, vars map[string]string) *Interpreter {
return &Interpreter{
globals: globals,
exec: exec,
vars: vars,
}
}
func (i *Interpreter) makeLayer(useHook bool) error {
hook := i.exec.RunHook
if !useHook {
hook = nil
}
return i.exec.Commit(i.CacheKey, hook)
}
|
metaplus/Gallery | core/config.h | <reponame>metaplus/Gallery
#pragma once
// Visual Studio
#define _CRT_SECURE_NO_WARNINGS
#define _SCL_SECURE_NO_WARNINGS
#define _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS
#define _ENABLE_EXTENDED_ALIGNED_STORAGE
#define STRING_IMPL(x) #x
#define STRING(x) STRING_IMPL(x)
// Boost
#define BOOST_CONFIG_SUPPRESS_OUTDATED_MESSAGE
#define BOOST_THREAD_VERSION 4
#define BOOST_FILESYSTEM_NO_DEPRECATED
#define BOOST_ASIO_NO_DEPRECATED
#define BOOST_ASIO_USE_FUTURE_HPP
// Spdlog
#define SPDLOG_FMT_EXTERNAL
// Folly
#define GLOG_NO_ABBREVIATED_SEVERITIES
#pragma warning(disable: 4005) |
paulograbin/AdventofCode | src/main/java/day3/firstHalf/Movements/MovementLeft.java | package day3.firstHalf.Movements;
import day3.firstHalf.Position;
/**
* Created by paulograbin on 28/04/16.
*/
public class MovementLeft implements Movement {
public Position move(Position p) {
return new Position(p.getX()-1, p.getY());
}
@Override
public boolean equals(Object obj) {
return getClass() == obj.getClass();
}
}
|
ubidreams/wisdom | extensions/wisdom-monitor/src/main/java/org/wisdom/monitor/extensions/terminal/WisitSession.java | /*
* #%L
* Wisdom-Framework
* %%
* Copyright (C) 2013 - 2014 Wisdom Framework
* %%
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* #L%
*/
package org.wisdom.monitor.extensions.terminal;
import org.apache.felix.service.command.CommandProcessor;
import org.apache.felix.service.command.CommandSession;
import org.apache.felix.service.command.Converter;
import org.wisdom.api.http.websockets.Publisher;
import java.io.PrintStream;
import static org.wisdom.monitor.extensions.terminal.OutputType.ERR;
import static org.wisdom.monitor.extensions.terminal.OutputType.RESULT;
/**
* A Wrapper around a CommandSession in order to execute command from a web client and send back the result through
* a web-socket.
*/
public class WisitSession {
/**
* Gogo shell session.
*/
private final CommandSession shellSession;
/**
* Create a new WisitSession.
* @param processor The CommandProcessor used in order to create the commandSession.
* @param publisher The websocket publisher on which the asynchronous commandResult will be broadcast.
* @param topic The websocket topic.
*/
public WisitSession(final CommandProcessor processor,final Publisher publisher,final String topic) {
WisitOutputStream resultStream = new WisitOutputStream(publisher,topic);
WisitOutputStream errorStream = new WisitOutputStream(publisher,topic, ERR);
shellSession = processor.createSession(null, new PrintStream(resultStream,true),
new PrintStream(errorStream,true));
}
/**
* Close the session.
*/
public void close(){
shellSession.close();
}
/**
* Execute a command on the gogo shell.
*
* @param commandLine The command to be executed.
* @return The CommandResult
*/
public CommandResult exec(String commandLine) {
CommandResult result = new CommandResult(RESULT);
try {
Object raw = shellSession.execute(commandLine);
if(raw != null){
result.setContent(format(raw));
}
} catch (Exception e) { //NOSONAR
//the result is an error
result.setType(ERR);
result.setContent(e.getMessage());
}
return result;
}
/**
* Format the given object as a String.
* @param o The raw object to be formatted
* @return The formatted string version of the raw object.
*/
private String format(Object o) {
return shellSession.format(o, Converter.INSPECT).toString();
}
}
|
talyaron/fullstack-int-aug20 | mongoose/01-basic/hillel/public/js.js | <gh_stars>1-10
innerhtmlarray()
const boxi = document.querySelector(".boxi")
setInterval(() => {
innerhtmlarray()
}, 100)
function mysubmit(event) {
event.preventDefault()
const name = event.target.children.name.value
const Family = event.target.children.Family.value
const tel = event.target.children.tel.value
fetch("/getserver", {
method: "post",
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
name,
Family,
tel
})
})
.then(a => a.json())
.then(data => {
document.querySelector('.VALU1').value = ''
document.querySelector('.VALU2').value = ''
document.querySelector('.VALU3').value = ''
innerhtmlarray()
})
}
function innerhtmlarray() {
fetch("/get")
.then(e => e.json())
.then(data => {
const datafor = data.tt
boxi.innerHTML = ''
for (i = 0; i < datafor.length; i++) {
if (datafor[i].tel == null) {
boxi.innerHTML +=
`<div class="box"><div class="text">${datafor[i].name}</div> <div class="text">${datafor[i].Family}</div><div class="text"></div></div>`
}
else {
boxi.innerHTML +=
`<div class="box"><div class="text">${datafor[i].name}</div> <div class="text">${datafor[i].Family}</div><div class="text">0${datafor[i].tel}</div></div>`
}
}
})
} |
exosite/libcql | src/libcql/internal/cql_socket.cpp | <reponame>exosite/libcql
/*
Copyright (c) 2013 <NAME>
This file is part of libcql.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include "libcql/internal/cql_socket.hpp"
cql::cql_socket_t::cql_socket_t(boost::asio::io_service& io_service) :
_socket(new boost::asio::ip::tcp::socket(io_service))
{
}
boost::asio::io_service&
cql::cql_socket_t::get_io_service()
{
return _socket->get_io_service();
}
bool
cql::cql_socket_t::requires_handshake()
{
return false;
}
boost::asio::ip::tcp::socket&
cql::cql_socket_t::lowest_layer()
{
return *_socket;
}
void
cql::cql_socket_t::reset()
{
_socket.reset(new boost::asio::ip::tcp::socket(_socket->get_io_service()));
}
|
SuperV1234/vrm_core | include/vrm/core/config/detection/stdlib/impl/stdlib.inl | <reponame>SuperV1234/vrm_core
// Copyright (c) 2015-2020 <NAME>
// License: Academic Free License ("AFL") v. 3.0
// AFL License page: http://opensource.org/licenses/AFL-3.0
// http://vittorioromeo.info | <EMAIL>
#pragma once
#include <vrm/core/config/detection/stdlib/impl/stdlib.hpp>
#include <vrm/core/config/detection/stdlib/impl/stdlib_macros.hpp>
namespace vrm::core::detection
{
[[nodiscard]] inline constexpr stdlib current_stdlib() noexcept
{
#if defined(VRM_CORE_STDLIB_LIBCXX)
return stdlib::libcxx;
#elif defined(VRM_CORE_STDLIB_LIBSTDCXX)
return stdlib::libstdcxx;
#else
return stdlib::unknown;
#endif
}
} // namespace vrm::core::detection
|
Sunrisepeak/AC-Online-Judge | PTA/PAT(Basic-level)/c++/B1012.cpp | <reponame>Sunrisepeak/AC-Online-Judge
#include <iostream>
using namespace std;
void print(int ans)
{
printf(ans ? "%d " : "N ", ans);
}
int main()
{
int A1{0}, A2{0}, A3{A1}, A4{0}, A5{0};
int x, A4_count{ 0 };
int single = -1;
cin >> x; //delete first number
bool isExsit = false;
while(cin >> x)
{
// cout << x << endl;
switch(x % 5)
{
case 0 :
if(x % 2 == 0)
A1 += x;
break;
case 1 : single = -single; A2 += single * x; isExsit = true; break;
case 2 : A3++; break;
case 3 : A4_count++; A4 += x; break;
case 4 :
if(x > A5)
A5 = x;
}
}
/* //error because of "N"
cout << (A1 ? A1 : "N") << " ";
cout << (A2 ? A2 : "N") << " ";
cout << (A3 ? A3 : "N") << " ";
cout << (A4_count ? static_cast<double>(A4)/ A4_count : "N") << " ";
cout << (A5 ? A5 : "N");
*/
/*
cout << (A1 ? A1 : 'N') << " ";
cout << (A2 ? A2 : 'N') << " ";
cout << (A3 ? A3 : 'N') << " ";
cout << (A4_count ? static_cast<double>(A4)/ A4_count : 'N') << " ";
cout << (A5 ? A5 : 'N');
*/
print(A1);
printf(isExsit ? "%d " : "N ", A2);
print(A3);
printf(A4_count ? "%.1lf ": "N ", ((double)A4)/(A4_count * 1.0));
printf(A5 ? "%d" : "N", A5);
return 0;
}
/*
*because of the programe,I would not to use "cout" in oj.
*please look at problem to use your heart.
*
*Presentation Error is deal with space key problem in the end of line
*/
|
kagarner/AliRoot | HLT/TPCLib/tracking-standalone/cmodules/qmalloc.cpp | #include "qmalloc.h"
#include <stdio.h>
#include <string.h>
#ifdef _WIN32
#include <windows.h>
#include <winbase.h>
#else //_WIN32
#include <unistd.h>
#include <sys/mman.h>
#include <syscall.h>
#ifdef _NUMAIF_H
#include <numaif.h>
#endif
#ifndef MAP_HUGETLB
#define MAP_HUGETLB 0x40000 /* arch specific */
#endif
#ifndef MPOL_DEFAULT
#define MPOL_DEFAULT 0
#endif
#ifndef MPOL_PREFERRED
#define MPOL_PREFERRED 1
#endif
#ifndef MPOL_BIND
#define MPOL_BIND 2
#endif
#ifndef MPOL_INTERLEAVE
#define MPOL_INTERLEAVE 3
#endif
#endif //!_WIN32
#ifndef STD_OUT
#define STD_OUT stdout
#endif
int qmalloc::qMallocCount = 0;
int qmalloc::qMallocUsed = 0;
qmalloc::qMallocData* qmalloc::qMallocs = NULL;
#ifdef _WIN32
static void Privilege(TCHAR* pszPrivilege, BOOL bEnable)
{
HANDLE hToken;
TOKEN_PRIVILEGES tp;
BOOL status;
DWORD error;
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &hToken))
{
fprintf(STD_OUT, "Error obtaining process token\n");
}
if (!LookupPrivilegeValue(NULL, pszPrivilege, &tp.Privileges[0].Luid))
{
fprintf(STD_OUT, "Error looking up priviledge value\n");
}
tp.PrivilegeCount = 1;
tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
status = AdjustTokenPrivileges(hToken, FALSE, &tp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
error = GetLastError();
if (!status || (error != ERROR_SUCCESS))
{
fprintf(STD_OUT, "Error obtaining Priviledge %d\n", GetLastError());
}
CloseHandle(hToken);
}
#endif
void* qmalloc::qMalloc(size_t size, bool huge, bool executable, bool locked, void* alloc_addr, int interleave)
{
int pagesize;
void* addr;
if (huge)
{
#ifdef _WIN32
static int tokenObtained = 0;
#ifdef _AMD64_
pagesize = GetLargePageMinimum();
#else
pagesize = 1024 * 2048;
#endif
if (tokenObtained == 0)
{
fprintf(STD_OUT, "Obtaining security token\n");
Privilege(TEXT("SeLockMemoryPrivilege"), TRUE);
tokenObtained = 1;
}
#else
pagesize = 1024 * 2048;
#endif
}
else
{
#ifdef _WIN32
SYSTEM_INFO si;
GetSystemInfo(&si);
pagesize = si.dwPageSize;
#else
pagesize = sysconf(_SC_PAGESIZE);
#endif
}
if (size % pagesize) size += pagesize - size % pagesize;
#ifdef _WIN32
DWORD flags = MEM_COMMIT;
if (huge)
{
flags |= MEM_LARGE_PAGES;
}
DWORD protect = PAGE_READWRITE;
if (executable)
{
protect = PAGE_EXECUTE_READWRITE;
}
if (interleave)
{
fprintf(stderr, "Interleaved allocation not supported on Windows\n");
return(NULL);
}
if (alloc_addr != NULL)
{
if (VirtualAlloc(alloc_addr, size, (flags & ~MEM_COMMIT) | MEM_RESERVE, protect) != alloc_addr)
{
return(NULL);
}
}
addr = VirtualAlloc(alloc_addr, size, flags, protect);
#else
int flags = MAP_ANONYMOUS | MAP_PRIVATE;
int prot = PROT_READ | PROT_WRITE;
if (huge) flags |= MAP_HUGETLB;
if (executable) prot |= PROT_EXEC;
if (locked) flags |= MAP_LOCKED;
//unsigned long oldnodemask;
//int oldpolicy;
if (interleave && locked) //mmap will perform a memory lock, so we have to change memory policy beforehand
{
/* if (syscall(SYS_get_mempolicy, &oldpolicy, &oldnodemask, sizeof(oldnodemask) * 8, NULL, 0) != 0)
{
fprintf(stderr, "Error obtaining memory policy\n");
exit(1);
}*/
unsigned long nodemask = 0xffffff;
if (syscall(SYS_set_mempolicy, MPOL_INTERLEAVE, &nodemask, sizeof(nodemask) * 8) != 0)
{
fprintf(stderr, "Error setting memory policy\n");
}
}
addr = mmap(alloc_addr, size, prot, flags, 0, 0);
if (addr == MAP_FAILED) addr = NULL;
if (interleave)
{
if (locked) //Restore old memory policy
{
//syscall(SYS_set_mempolicy, oldpolicy, &oldnodemask, sizeof(oldnodemask) * 8);
if (syscall(SYS_set_mempolicy, MPOL_DEFAULT, NULL) != 0)
{
fprintf(stderr, "Error setting memory policy\n");
}
}
else if (addr) //Set memory policy for region
{
#ifndef _NUMAIF_H
fprintf(stderr, "Interleaved memory can only be used with non-locked memory if numaif.h is present\n");
exit(1);
#else
unsigned long nodemask = 0xffffff;
mbind(addr, size, MPOL_INTERLEAVE, &nodemask, sizeof(nodemask) * 8, 0);
#endif
}
}
#endif
if (alloc_addr != NULL && addr != alloc_addr)
{
fprintf(stderr, "Could not allocate memory at desired address\n");
#ifdef _WIN32
VirtualFree(addr, 0, MEM_RELEASE);
#else
munmap(addr, size);
#endif
return(NULL);
}
if (addr == NULL)
{
#ifdef _WIN32
DWORD error = GetLastError();
#endif
fprintf(stderr, "Failed to allocate memory\n");
return(NULL);
}
if (qMallocCount == qMallocUsed)
{
if (qMallocCount == 0) qMallocCount = 8;
else if (qMallocCount < 1024) qMallocCount *= 2;
else qMallocCount += 1024;
if (qMallocUsed == 0)
{
qMallocs = (qMallocData*) malloc(qMallocCount * sizeof(qMallocData));
}
else
{
qMallocs = (qMallocData*) realloc(qMallocs, qMallocCount * sizeof(qMallocData));
}
}
qMallocs[qMallocUsed].addr = addr;
qMallocs[qMallocUsed].size = size;
qMallocUsed++;
#ifdef _WIN32
if (locked)
{
size_t minp, maxp;
HANDLE pid = GetCurrentProcess();
if (GetProcessWorkingSetSize(pid, (PSIZE_T) &minp, (PSIZE_T) &maxp) == 0) fprintf(STD_OUT, "Error getting minimum working set size\n");
if (SetProcessWorkingSetSize(pid, minp + size, maxp + size) == 0) fprintf(STD_OUT, "Error settings maximum working set size\n");
if (VirtualLock(addr, size) == 0)
{
fprintf(STD_OUT, "Error locking memory\n");
DWORD error = GetLastError();
VirtualFree(addr, 0, MEM_RELEASE);
if (SetProcessWorkingSetSize(pid, minp, maxp) == 0) fprintf(STD_OUT, "Error settings maximum working set size\n");
addr = NULL;
}
}
#endif
return(addr);
}
int qmalloc::qFree(void* ptr)
{
for (int i = 0;i < qMallocUsed;i++)
{
if (qMallocs[i].addr == ptr)
{
#ifdef _WIN32
if (VirtualFree(ptr, 0, MEM_RELEASE) == 0) return(1);
#else
if (munmap(ptr, qMallocs[i].size)) return(1);
#endif
qMallocUsed--;
if (i < qMallocUsed) memcpy(&qMallocs[i], &qMallocs[qMallocUsed], sizeof(qMallocData));
if (qMallocUsed == 0)
{
free(qMallocs);
qMallocCount = 0;
}
return(0);
}
}
return(1);
}
|
linea-it/tno | frontend/src/services/api/SearchSsso.js | import axios from 'axios';
export const getSkybotLists = ({ page, pageSize, search, filters }) => {
const params = { page, pageSize, search };
filters.forEach((el) => {
params[el.property] = el.value;
});
return axios.get('/skybotoutput/', { params });
};
export const getSkybotRecord = ({ id }) => axios.get(`/skybotoutput/${id}/`);
|
rocketstation/skin | src/alias/box-must-break-words/index.test.js | <filename>src/alias/box-must-break-words/index.test.js
const v = require('./index.js')
test('boxMustBreakWords', () => {
expect(v(true)).toEqual({ overflowWrap: 'break-word' })
expect(v(false)).toEqual({ overflowWrap: 'normal' })
})
|
heyingquan13/kafka | streams/src/main/java/org/apache/kafka/streams/kstream/internals/KTableProcessorSupplier.java | <reponame>heyingquan13/kafka
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.kafka.streams.kstream.internals;
import org.apache.kafka.streams.processor.api.ProcessorSupplier;
public interface KTableProcessorSupplier<KIn, VIn, KOut, VOut> extends ProcessorSupplier<KIn, Change<VIn>, KOut, Change<VOut>> {
KTableValueGetterSupplier<KOut, VOut> view();
/**
* Potentially enables sending old values.
* <p>
* If {@code forceMaterialization} is {@code true}, the method will force the materialization of upstream nodes to
* enable sending old values.
* <p>
* If {@code forceMaterialization} is {@code false}, the method will only enable the sending of old values <i>if</i>
* an upstream node is already materialized.
*
* @param forceMaterialization indicates if an upstream node should be forced to materialize to enable sending old
* values.
* @return {@code true} if sending old values is enabled, i.e. either because {@code forceMaterialization} was
* {@code true} or some upstream node is materialized.
*/
boolean enableSendingOldValues(boolean forceMaterialization);
}
|
freight-trust/carbon | packages/icons/es/unknown/24.js | <gh_stars>0
/**
* Copyright IBM Corp. 2016, 2020
*
* This source code is licensed under the Apache-2.0 license found in the
* LICENSE file in the root directory of this source tree.
*
* Code generated by @carbon/icon-build-helpers. DO NOT EDIT.
*/
var _24 = {
"elem": "svg",
"attrs": {
"xmlns": "http://www.w3.org/2000/svg",
"viewBox": "0 0 32 32",
"fill": "currentColor",
"width": 24,
"height": 24
},
"content": [{
"elem": "circle",
"attrs": {
"cx": "16",
"cy": "22.5",
"r": "1.5"
}
}, {
"elem": "path",
"attrs": {
"d": "M17,19H15V15h2a2,2,0,0,0,0-4H15a2.0023,2.0023,0,0,0-2,2v.5H11V13a4.0045,4.0045,0,0,1,4-4h2a4,4,0,0,1,0,8Z"
}
}, {
"elem": "path",
"attrs": {
"d": "M16,30a2.0763,2.0763,0,0,1-1.4732-.6094L2.6094,17.4732a2.0855,2.0855,0,0,1,0-2.9464L14.5268,2.6094a2.0855,2.0855,0,0,1,2.9464,0L29.3906,14.5268a2.0855,2.0855,0,0,1,0,2.9464L17.4732,29.3906A2.0763,2.0763,0,0,1,16,30ZM16,3.9992a.0841.0841,0,0,0-.0591.0244L4.0236,15.9409a.0838.0838,0,0,0,0,.1182L15.9409,27.9764a.0842.0842,0,0,0,.1182,0L27.9764,16.0591a.0838.0838,0,0,0,0-.1182L16.0591,4.0236A.0841.0841,0,0,0,16,3.9992Z"
}
}],
"name": "unknown",
"size": 24
};
export default _24;
|
darlyhellen/oto | DLClent_A/src/com/darly/im/ui/chatting/ChattingListAdapter.java | package com.darly.im.ui.chatting;
///*
// * Copyright (c) 2013 The CCP project authors. All Rights Reserved.
// *
// * Use of this source code is governed by a Beijing Speedtong Information Technology Co.,Ltd license
// * that can be found in the LICENSE file in the root of the web site.
// *
// * http://www.yuntongxun.com
// *
// * An additional intellectual property rights grant can be found
// * in the file PATENTS. All contributing project authors may
// * be found in the AUTHORS file in the root of the source tree.
// */
//package com.yuntongxun.ecdemo.ui.chatting;
//
//import android.content.res.ColorStateList;
//import android.view.LayoutInflater;
//import android.view.View;
//import android.view.ViewGroup;
//import android.widget.BaseAdapter;
//
//import com.nostra13.universalimageloader.core.ImageLoader;
//import com.yuntongxun.ecdemo.R;
//import com.yuntongxun.ecdemo.common.utils.DateUtil;
//import com.yuntongxun.ecdemo.common.utils.LogUtil;
//import com.yuntongxun.ecdemo.common.utils.MediaPlayTools;
//import com.yuntongxun.ecdemo.ui.chatting.holder.BaseHolder;
//import com.yuntongxun.ecdemo.ui.chatting.model.BaseChattingRow;
//import com.yuntongxun.ecdemo.ui.chatting.model.ChattingRowType;
//import com.yuntongxun.ecdemo.ui.chatting.model.DescriptionRxRow;
//import com.yuntongxun.ecdemo.ui.chatting.model.DescriptionTxRow;
//import com.yuntongxun.ecdemo.ui.chatting.model.FileRxRow;
//import com.yuntongxun.ecdemo.ui.chatting.model.FileTxRow;
//import com.yuntongxun.ecdemo.ui.chatting.model.IChattingRow;
//import com.yuntongxun.ecdemo.ui.chatting.model.ImageRxRow;
//import com.yuntongxun.ecdemo.ui.chatting.model.ImageTxRow;
//import com.yuntongxun.ecdemo.ui.chatting.model.VoiceRxRow;
//import com.yuntongxun.ecdemo.ui.chatting.model.VoiceTxRow;
//import com.yuntongxun.ecsdk.ECMessage;
//
//import java.util.ArrayList;
//import java.util.HashMap;
//import java.util.List;
//
//
///**
// * @author 容联•云通讯
// * @date 2014-12-9
// * @version 4.0
// */
//public class ChattingListAdapter extends BaseAdapter {
//
// private List<ECMessage> details;
// protected View.OnClickListener mOnClickListener;
// /**当前语音播放的Item*/
// public int mVoicePosition = -1;
// /**聊天所在的Activity*/
// private ChattingActivity mContext;
// /**需要显示时间的Item position*/
// private ArrayList<String> mShowTimePosition;
// /**初始化所有类型的聊天Item 集合*/
// private HashMap<Integer, IChattingRow> mRowItems ;
// /**时间显示控件的垂直Padding*/
// private int mVerticalPadding;
// /**时间显示控件的横向Padding*/
// private int mHorizontalPadding;
// /**消息联系人名称显示颜色*/
// private ColorStateList[] mChatNameColor;
//
// /**
// * @param ctx
// */
// public ChattingListAdapter(ChattingActivity ctx) {
// mContext = ctx;
// mRowItems = new HashMap<Integer, IChattingRow>();
// mShowTimePosition = new ArrayList<String>();
// initRowItems();
// details = new ArrayList<ECMessage>();
//
// // 初始化聊天消息点击事件回调
// mOnClickListener = new ChattingListClickListener(mContext , null);
// mVerticalPadding = mContext.getResources().getDimensionPixelSize(R.dimen.SmallestPadding);
// mHorizontalPadding = mContext.getResources().getDimensionPixelSize(R.dimen.LittlePadding);
// mChatNameColor = new ColorStateList[]{
// mContext.getResources().getColorStateList(R.color.white),
// mContext.getResources().getColorStateList(R.color.chatroom_user_displayname_color)};
//
// }
//
// public void setData(List<ECMessage> data) {
// details.clear();
// if(data != null) {
// for(ECMessage iMessage : data){
// initRowType(iMessage);
// }
// }
// notifyDataSetChanged();
//
// }
//
// /**
// * 初始化不同的聊天Item View
// */
// void initRowItems() {
// mRowItems.put(Integer.valueOf(1), new ImageRxRow(1));
// mRowItems.put(Integer.valueOf(2), new ImageTxRow(2));
// mRowItems.put(Integer.valueOf(3), new FileRxRow(3));
// mRowItems.put(Integer.valueOf(4), new FileTxRow(4));
// mRowItems.put(Integer.valueOf(5), new VoiceRxRow(5));
// mRowItems.put(Integer.valueOf(6), new VoiceTxRow(6));
// mRowItems.put(Integer.valueOf(7), new DescriptionRxRow(7));
// mRowItems.put(Integer.valueOf(8), new DescriptionTxRow(8));
// // mRowItems.put(Integer.valueOf(9), new ChattingSystemRow(9));
// }
//
//
// @Override
// public int getCount() {
// if(details == null) {
// return 0;
// }
// return details.size();
// }
//
// @Override
// public ECMessage getItem(int position) {
// if(getCount() == 0) {
// return null;
// }
// return details.get(position);
// }
//
// @Override
// public long getItemId(int position) {
// if(getCount() == 0) {
// return 0L;
// }
// return details.get(position).getId();
// }
//
// @Override
// public View getView(int position, View convertView, ViewGroup parent) {
// ECMessage item = getItem(position);
// if(item == null) {
// return null;
// }
// boolean showTimer = false;
// if(position == 0) {
// showTimer = true;
// }
// if(position != 0) {
// ECMessage previousItem = getItem(position - 1);
// if(mShowTimePosition.contains(item.getMsgId())
// || (item.getMsgTime() - previousItem.getMsgTime() >= 180000L)) {
// showTimer = true;
//
// }
// }
//
// int messageType = ChattingsRowUtils.getChattingMessageType(item.getType());
// BaseChattingRow chattingRow = getBaseChattingRow(messageType, item.getDirection() == ECMessage.Direction.SEND);
// View chatView = chattingRow.buildChatView(LayoutInflater.from(mContext), convertView);
// BaseHolder baseHolder = (BaseHolder) chatView.getTag();
//
// if(showTimer) {
// baseHolder.getChattingTime().setVisibility(View.VISIBLE);
// baseHolder.getChattingTime().setBackgroundResource(R.drawable.chat_tips_bg);
// baseHolder.getChattingTime().setText(DateUtil.getDateString(item.getMsgTime(), DateUtil.SHOW_TYPE_CALL_LOG).trim());
// baseHolder.getChattingTime().setTextColor(mChatNameColor[0]);
// baseHolder.getChattingTime().setPadding(mHorizontalPadding, mVerticalPadding, mHorizontalPadding, mVerticalPadding);
// } else {
// baseHolder.getChattingTime().setVisibility(View.GONE);
// baseHolder.getChattingTime().setShadowLayer(0.0F, 0.0F, 0.0F, 0);
// baseHolder.getChattingTime().setBackgroundResource(0);
// }
//
// chattingRow.buildChattingBaseData(mContext, baseHolder, item, position);
//
// if(baseHolder.getChattingUser() != null && baseHolder.getChattingUser().getVisibility() == View.VISIBLE) {
// baseHolder.getChattingUser().setTextColor(mChatNameColor[1]);
// baseHolder.getChattingUser().setShadowLayer(0.0F, 0.0F, 0.0F, 0);
// }
// return chatView;
// }
//
// /**
// * 消息类型数
// */
// @Override
// public int getViewTypeCount() {
// return ChattingRowType.values().length;
// }
//
// /**
// * 返回消息的类型ID
// */
// @Override
// public int getItemViewType(int position) {
// ECMessage message = getItem(position);
// return getBaseChattingRow(ChattingsRowUtils.getChattingMessageType(message.getType()),message.getDirection() == ECMessage.Direction.SEND).getChatViewType();
// }
//
// /**
// * 根据消息类型返回相对应的消息Item
// * @param rowType
// * @param isSend
// * @return
// */
// public BaseChattingRow getBaseChattingRow(int rowType , boolean isSend) {
// StringBuilder builder = new StringBuilder("C").append(rowType);
//
// if(isSend) {
// builder.append("T");
// } else {
// builder.append("R");
// }
//
// LogUtil.d("ChattingListAdapter" , "builder.toString() = " + builder.toString());
// ChattingRowType fromValue = ChattingRowType.fromValue(builder.toString());
// LogUtil.d("ChattingListAdapter" , "fromValue = " + fromValue);
// IChattingRow iChattingRow = mRowItems.get(fromValue.getId().intValue());
// return (BaseChattingRow) iChattingRow;
// }
//
// public void checkTimeShower() {
// if(getCount() > 0) {
// ECMessage item = getItem(0);
// if(item != null) {
// mShowTimePosition.add(item.getMsgId());
// }
// }
// }
//
// /**
// * 下拉刷新
// * @param data
// */
// public void insertDataArrays(List<ECMessage> data) {
// if(data != null) {
// if(getCount() > 0) {
// ECMessage item = getItem(0);
// if(item != null) {
// mShowTimePosition.add(item.getMsgId());
// }
// }
// for(int i = data.size() -1 ; i >=0 ; i --) {
// insertData(data.get(i) , 0);
//
// }
// }
// }
//
// public void insertDataArraysAfter(List<ECMessage> data) {
// if(data != null) {
// for(int i = data.size() -1 ; i >=0 ; i --) {
// insertData(data.get(i) , (getCount() - 1) == 0 ?getCount() : getCount() - 1);
//
// }
// }
// }
//
// /**
// * @param data
// */
// public void insertData(ECMessage data) {
// if(getCount() > 0) {
// if(getCount() == 1) {
// insertData(data, getCount());
// return;
// }
// insertData(data, getCount() - 1);
// return;
// }
// insertData(data , 0);
// }
//
// private void insertData(ECMessage data , int index) {
// if(data != null) {
//
// if(index < 0) {
// index = 0;
// }
//
// initRowType(data ,index);
// notifyDataSetChanged();
// }
// }
//
// /**
// * @param iMessage
// */
// private void initRowType(ECMessage iMessage) {
// initRowType(iMessage, details.size());
// }
//
// /**
// * Gets the message type row
// * @param iMessage
// */
// private void initRowType(ECMessage iMessage , int index) {
// if(iMessage == null) {
// return ;
// }
// if(details == null) {
// details = new ArrayList<ECMessage>();
// }
// if(index != 0) {
// index = details.size();
// }
// details.add(index , iMessage);
//
// }
//
// /**
// * @param detail
// */
// public void removeMsg(ECMessage detail) {
// if(detail != null) {
// int removeIndex = -1;
// //details.
// for(int i = 0 ; details != null && i < details.size() ; i++) {
// ECMessage iMessageDetail = details.get(i);
// if(iMessageDetail.getId() != detail.getId()) {
// continue;
// }
// removeIndex = i;
// break;
// }
//
// if(removeIndex != -1) {
// details.remove(removeIndex);
// notifyDataSetChanged();
// }
// }
// }
//
// public Integer getMessageRowType(ECMessage iMessage) {
// return ChattingsRowUtils.getMessageRowType(iMessage);
// }
//
// /**
// * 当前语音播放的位置
// * @param position
// */
// public void setVoicePosition(int position) {
// mVoicePosition = position;
// }
//
// /**
// * @return the mOnClickListener
// */
// public View.OnClickListener getOnClickListener() {
// return mOnClickListener;
// }
//
// /**
// *
// */
// public void onPause() {
// mVoicePosition = -1;
// MediaPlayTools.getInstance().stop();
// }
//
// public void onResume() {
// notifyDataSetChanged();
// }
//
//
// /**
// *
// */
// public void onDestory() {
// if(details != null) {
// details.clear();
// details = null;
// }
// ImageLoader.getInstance().clearMemoryCache();
// if(mShowTimePosition != null) {
// mShowTimePosition.clear();
// mShowTimePosition = null;
// }
// if(mRowItems != null) {
// mRowItems.clear();
// mRowItems = null;
// }
// mOnClickListener = null;
// }
//
//
//}
|
norikuro/vmcjp-slack-service | vmcjp/utils/slack_post.py | <reponame>norikuro/vmcjp-slack-service<gh_stars>0
import json
import urllib2
def post(url, data, bot_oauth_token=None):
headers = {
"Content-Type": "application/json"
}
if bot_oauth_token is not None:
headers.update(
{
"Authorization": "Bearer {}".format(
bot_oauth_token
)
}
)
request = urllib2.Request(
url,
data=json.dumps(data).encode("utf-8"),
headers=headers
)
return urllib2.urlopen(request)
def post_text(
url,
slack_token,
channel,
data,
bot_token=None
):
post_data = {
"token": slack_token,
"channel": channel,
}
post_data.update(data)
response = post(url, post_data, bot_token)
return response
def post_option(
url,
slack_token,
channel,
button,
option_list,
bot_token=None
):
button_set = json.load(open(button, 'r'))
button_set["attachments"][0]["actions"][0].update(
{"options": option_list}
)
response = post_text(
url,
slack_token,
channel,
button_set,
bot_token
)
return response
def post_button(
url,
slack_token,
channel,
button,
bot_token=None
):
button_set = json.load(open(button, 'r'))
response = post_text(
url,
slack_token,
channel,
button_set,
bot_token
)
return response
def create_button(field_dics, button):
button_set = json.load(open(button, 'r'))
attachments = button_set.get("attachments")
for attachment in attachments:
fields = attachment.get("fields")
# attachment.update(
# {
# "fields": None
# if fields is None
# else [
# {
# "value": event.get(field.get("value"))
# }
# for field in fields
# ]
# }
# )
if fields is not None:
for field in fields:
field.update({"value": field_dics.get(field.get("value"))})
return button_set
def post_field_button(
url,
slack_token,
channel,
button,
field_dics,
bot_token=None
):
button_set = create_button(field_dics, button)
response = post_text(
url,
slack_token,
channel,
button_set,
bot_token
)
return response
|
macintoshhelper/explorer | src/components/Annotations/footer.js | import React, { Component } from 'react';
import Obstruction from 'obstruction';
import PropTypes from 'prop-types';
import document from 'global/document';
import { timeout } from 'thyming';
import { partial } from 'ap';
import raf from 'raf';
import qs from 'querystringify';
import { withStyles } from '@material-ui/core/styles';
import Paper from '@material-ui/core/Paper';
import Typography from '@material-ui/core/Typography';
import Snackbar from '@material-ui/core/Snackbar';
import { raw as RawApi } from '@commaai/comma-api';
import TimelineWorker from '../../timeline';
const styles = theme => {
return {
root: {
width: '100%',
height: '100%',
paddingTop: theme.spacing.unit,
background: 'transparent',
textAlign: 'right'
},
footerButton: {
display: 'inline-block',
border: '1px solid ' + theme.palette.grey[800],
color: theme.palette.grey[50],
textDecoration: 'none',
borderRadius: 20,
padding: '10px 20px',
margin: '0px 10px',
cursor: 'pointer'
}
}
};
class AnnotationsFooter extends Component {
static propTypes = {
segment: PropTypes.object.isRequired,
};
constructor (props) {
super(props);
this.copySegmentName = this.copySegmentName.bind(this);
this.handleClose = this.handleClose.bind(this);
this.downloadSegmentFile = this.downloadSegmentFile.bind(this);
this.openInCabana = this.openInCabana.bind(this);
this.openWayInOsmEditor = this.openWayInOsmEditor.bind(this);
this.updateWayId = this.updateWayId.bind(this);
this.state = {
showCopiedSnack: false,
wayId: 0,
}
}
componentDidMount() {
raf(this.updateWayId);
}
updateWayId() {
raf(this.updateWayId);
var event = TimelineWorker.currentLiveMapData();
if (event && event.LiveMapData) {
var wayId = parseInt(event.LiveMapData.WayId);
if (wayId !== this.state.wayId) {
this.setState({ wayId });
}
} else if (this.state.wayId) {
this.setState({ wayId: 0 });
}
}
copySegmentName (e) {
const el = document.createElement('textarea');
el.value = this.props.segment.route + '--' + this.props.segment.segment;
el.setAttribute('readonly', '');
el.style.position = 'absolute';
el.style.left = '-9999px';
document.body.appendChild(el);
el.select();
document.execCommand('copy');
document.body.removeChild(el);
this.setState({
showCopiedSnack: true
});
this.snackTimer = timeout(this.handleClose, 1000);
}
async downloadSegmentFile(type) {
if (!this.props.segment) {
return;
}
let seg = this.props.segment;
let segmentKeyPath = seg.route.replace('|', '/') + '/' + seg.segment;
let files = (await RawApi.getRouteFiles(this.props.segment.route));
let url = files[type].find(function(url) {
return url.indexOf(segmentKeyPath) !== -1;
})
if (url) {
window.location.href = url;
}
}
handleClose () {
this.setState({
showCopiedSnack: false
});
this.snackTimer();
}
openInCabana () {
var params = {
'route': this.props.segment.route,
'url': this.props.segment.url,
'seekTime': Math.floor((TimelineWorker.currentOffset() - this.props.segment.routeOffset) / 1000)
};
var win = window.open('https://my.comma.ai/cabana/' + qs.stringify(params, true) , '_blank');
if (win.focus) {
win.focus();
}
}
openWayInOsmEditor () {
var { wayId } = this.state;
if (!wayId) {
return;
}
var win = window.open(`https://www.openstreetmap.org/way/${wayId}`, '_blank');
if (win.focus) {
win.focus();
}
}
render () {
return (
<Paper className={ this.props.classes.root } >
{ this.props.segment && this.props.segment.hasVideo &&
<a className={ this.props.classes.footerButton } onClick={ partial(this.downloadSegmentFile, 'cameras') }>
Download Camera Segment
</a>
}
{ this.props.segment && this.props.segment.hasDriverCamera &&
<a className={ this.props.classes.footerButton } onClick={ partial(this.downloadSegmentFile, 'dcameras') }>
Download Front Camera Segment
</a>
}
{ this.props.segment &&
<a className={ this.props.classes.footerButton } onClick={ partial(this.downloadSegmentFile, 'logs') }>
Download Log Segment
</a>
}
<a className={ this.props.classes.footerButton } onClick={ this.openWayInOsmEditor } href='#'>
Edit OpenStreetMap Here
</a>
<a className={ this.props.classes.footerButton } onClick={ this.openInCabana } href='#'>
View CAN Data in Cabana
</a>
<a className={ this.props.classes.footerButton } onClick={ this.copySegmentName } target='_blank'>
Copy Current Segment
</a>
<Snackbar
anchorOrigin={{
vertical: 'bottom',
horizontal: 'center'
}}
open={this.state.showCopiedSnack}
onClose={this.handleClose}
ContentProps={{
'aria-describedby': 'message-id',
}}
variant="success"
message={<span id="message-id">Copied segment name!</span>}
/>
</Paper>
);
}
}
export default withStyles(styles)(AnnotationsFooter);
|
stanleyyong/go | exp/crypto/derivation/doc.go | <reponame>stanleyyong/go
// Package derivation provides functions for ed25519 key derivation as described in:
// https://github.com/satoshilabs/slips/blob/master/slip-0010.md
package derivation
|
denis-trapeznikov/ledger | libs/settings/tests/unit/setting_collection_tests.cpp | <filename>libs/settings/tests/unit/setting_collection_tests.cpp<gh_stars>10-100
//------------------------------------------------------------------------------
//
// Copyright 2018-2020 Fetch.AI Limited
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//------------------------------------------------------------------------------
#include "mock_environment.hpp"
#include "settings/setting.hpp"
#include "settings/setting_collection.hpp"
#include "gmock/gmock.h"
#include <cstddef>
#include <cstdint>
#include <string>
#include <utility>
#include <vector>
namespace {
using fetch::settings::Setting;
using fetch::settings::SettingCollection;
using testing::Return;
using testing::StrEq;
class SystemArgAdapter
{
public:
explicit SystemArgAdapter(std::vector<std::string> args)
: args_{std::move(args)}
{
argv_.resize(args_.size(), nullptr);
for (std::size_t idx = 0; idx < args_.size(); ++idx)
{
argv_[idx] = const_cast<char *>(args_[idx].c_str());
}
}
int argc()
{
return static_cast<int>(argv_.size());
}
char **argv()
{
return argv_.data();
}
private:
std::vector<std::string> args_;
std::vector<char *> argv_;
};
class SettingCollectionTests : public ::testing::Test
{
protected:
::testing::StrictMock<MockEnvironment> environment_;
};
TEST_F(SettingCollectionTests, SimpleCheck)
{
SettingCollection collection{};
Setting<uint32_t> lanes{collection, "lanes", 0, ""};
Setting<std::string> name{collection, "name", "default", ""};
SystemArgAdapter arguments({"-lanes", "256", "-name", "foo-bar-baz"});
collection.UpdateFromArgs(arguments.argc(), arguments.argv());
EXPECT_EQ(lanes.value(), 256);
EXPECT_EQ(name.value(), "foo-bar-baz");
}
TEST_F(SettingCollectionTests, CheckMispelt)
{
SettingCollection collection{};
Setting<uint32_t> lanes{collection, "lanes", 0, ""};
Setting<std::string> name{collection, "name", "default", ""};
SystemArgAdapter arguments({"-lanex", "256", "-name", "foo-bar-baz"});
collection.UpdateFromArgs(arguments.argc(), arguments.argv());
EXPECT_EQ(lanes.value(), 0);
EXPECT_EQ(name.value(), "foo-bar-baz");
}
TEST_F(SettingCollectionTests, CheckEmpty)
{
SettingCollection collection{};
SystemArgAdapter arguments({"-lanex", "256", "-name", "foo-bar-baz"});
ASSERT_NO_THROW(collection.UpdateFromArgs(arguments.argc(), arguments.argv()));
}
TEST_F(SettingCollectionTests, CheckPrecedence)
{
SettingCollection collection{};
Setting<uint32_t> lanes{collection, "lanes", 0, ""};
Setting<std::string> name{collection, "name", "default", ""};
SystemArgAdapter arguments({"-lanes", "256", "-name", "foo-bar-baz"});
collection.UpdateFromArgs(arguments.argc(), arguments.argv());
EXPECT_EQ(lanes.value(), 256);
EXPECT_EQ(name.value(), "foo-bar-baz");
// null environment
{
EXPECT_CALL(environment_, GetEnvironmentVariable(StrEq("FOO_LANES")))
.Times(1)
.WillOnce(Return(nullptr));
EXPECT_CALL(environment_, GetEnvironmentVariable(StrEq("FOO_NAME")))
.Times(1)
.WillOnce(Return(nullptr));
collection.UpdateFromEnv("FOO_", environment_);
EXPECT_EQ(lanes.value(), 256);
EXPECT_EQ(name.value(), "foo-bar-baz");
}
// only lanes
{
EXPECT_CALL(environment_, GetEnvironmentVariable(StrEq("BAR_LANES")))
.Times(1)
.WillOnce(Return("512"));
EXPECT_CALL(environment_, GetEnvironmentVariable(StrEq("BAR_NAME")))
.Times(1)
.WillOnce(Return(nullptr));
collection.UpdateFromEnv("BAR_", environment_);
EXPECT_EQ(lanes.value(), 512);
EXPECT_EQ(name.value(), "foo-bar-baz");
}
// only name
{
EXPECT_CALL(environment_, GetEnvironmentVariable(StrEq("BAZ_LANES")))
.Times(1)
.WillOnce(Return(nullptr));
EXPECT_CALL(environment_, GetEnvironmentVariable(StrEq("BAZ_NAME")))
.Times(1)
.WillOnce(Return("awesome"));
collection.UpdateFromEnv("BAZ_", environment_);
EXPECT_EQ(lanes.value(), 512);
EXPECT_EQ(name.value(), "awesome");
}
// both
{
EXPECT_CALL(environment_, GetEnvironmentVariable(StrEq("FOO_LANES")))
.Times(1)
.WillOnce(Return("1024"));
EXPECT_CALL(environment_, GetEnvironmentVariable(StrEq("FOO_NAME")))
.Times(1)
.WillOnce(Return("great"));
collection.UpdateFromEnv("FOO_", environment_);
EXPECT_EQ(lanes.value(), 1024);
EXPECT_EQ(name.value(), "great");
}
}
} // namespace
|
entityc/ec-sb-tutorial-service | src/main/java/org/entityc/tutorial/dto/SessionDto.java | <filename>src/main/java/org/entityc/tutorial/dto/SessionDto.java<gh_stars>1-10
//
// This is the DTO class for entity:
//
// Entity
// Name: Session
// Description: Represents a session within a module. A session typically tries to
// teach a single concept.
//
// THIS FILE IS GENERATED. DO NOT EDIT!!
//
package org.entityc.tutorial.dto;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.ArrayList;
import java.util.UUID;
import org.entityc.tutorial.model.Role;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import lombok.Data;
@Data
@JsonIgnoreProperties(ignoreUnknown = true)
public class SessionDto
{
// PRIMARY KEY
private UUID id;
// When the object was created.
private Date createdOn;
// The discussion section of the session.
private String discussion;
// When the object was last modified.
private Date modifiedOn;
// The session number.
private Integer number;
// The objective of the session.
private String objective;
// The title of the session.
private String title;
// RELATIONSHIPS
// The exercises of this session.
private Set<ExerciseDto> exercises;
// The module to which this session belongs.
private ModuleDto module;
public void adjustUpdateForRoles(Set<Role> roles) {
this.createdOn = null;
this.modifiedOn = null;
}
}
|
jhonatasrm/chromium-android | app/src/main/java/org/chromium/components/gcm_driver/GoogleCloudMessagingV2.java | <gh_stars>1-10
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package org.chromium.components.gcm_driver;
import android.app.PendingIntent;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.Messenger;
import android.support.annotation.Nullable;
import org.chromium.base.ContextUtils;
import org.chromium.base.PackageUtils;
import java.io.IOException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
/**
* Temporary code for sending subtypes when (un)subscribing with GCM.
* Subtypes are experimental and may change without notice!
* TODO(johnme): Remove this file, once we switch to the GMS client library.
*/
public class GoogleCloudMessagingV2 implements GoogleCloudMessagingSubscriber {
private static final String GOOGLE_PLAY_SERVICES_PACKAGE = "com.google.android.gms";
private static final long REGISTER_TIMEOUT = 5000;
private static final String ACTION_C2DM_REGISTER = "com.google.android.c2dm.intent.REGISTER";
private static final String C2DM_EXTRA_ERROR = "error";
private static final String INTENT_PARAM_APP = "app";
private static final String ERROR_MAIN_THREAD = "MAIN_THREAD";
private static final String ERROR_SERVICE_NOT_AVAILABLE = "SERVICE_NOT_AVAILABLE";
private static final String EXTRA_DELETE = "delete";
private static final String EXTRA_REGISTRATION_ID = "registration_id";
private static final String EXTRA_SENDER = "sender";
private static final String EXTRA_MESSENGER = "google.messenger";
private static final String EXTRA_SUBTYPE = "subtype";
private static final String EXTRA_SUBSCRIPTION = "subscription";
private PendingIntent mAppPendingIntent;
private final Object mAppPendingIntentLock = new Object();
public GoogleCloudMessagingV2() {}
@Override
public String subscribe(String source, String subtype, @Nullable Bundle data)
throws IOException {
if (data == null) {
data = new Bundle();
}
data.putString(EXTRA_SUBTYPE, subtype);
Bundle result = subscribe(source, data);
return result.getString(EXTRA_REGISTRATION_ID);
}
@Override
public void unsubscribe(String source, String subtype, @Nullable Bundle data)
throws IOException {
if (data == null) {
data = new Bundle();
}
data.putString(EXTRA_SUBTYPE, subtype);
unsubscribe(source, data);
return;
}
/**
* Subscribe to receive GCM messages from a specific source.
* <p>
* Source Types:
* <ul>
* <li>Sender ID - if you have multiple senders you can call this method
* for each additional sender. Each sender can use the corresponding
* {@link #REGISTRATION_ID} returned in the bundle to send messages
* from the server.</li>
* <li>Cloud Pub/Sub topic - You can subscribe to a topic and receive
* notifications from the owner of that topic, when something changes.
* For more information see
* <a href="https://cloud.google.com/pubsub">Cloud Pub/Sub</a>.</li>
* </ul>
* This function is blocking and should not be called on the main thread.
*
* @param source of the desired notifications.
* @param data (optional) additional information.
* @return Bundle containing subscription information including {@link #REGISTRATION_ID}
* @throws IOException if the request fails.
*/
public Bundle subscribe(String source, Bundle data) throws IOException {
if (data == null) {
data = new Bundle();
}
// Expected by older versions of GMS and servlet
data.putString(EXTRA_SENDER, source);
// New name of the sender parameter
data.putString(EXTRA_SUBSCRIPTION, source);
// DB buster for older versions of GCM.
if (data.getString(EXTRA_SUBTYPE) == null) {
data.putString(EXTRA_SUBTYPE, source);
}
Intent resultIntent = registerRpc(data);
getExtraOrThrow(resultIntent, EXTRA_REGISTRATION_ID);
return resultIntent.getExtras();
}
/**
* Unsubscribe from a source to stop receiving messages from it.
* <p>
* This function is blocking and should not be called on the main thread.
*
* @param source to unsubscribe
* @param data (optional) additional information.
* @throws IOException if the request fails.
*/
public void unsubscribe(String source, Bundle data) throws IOException {
if (data == null) {
data = new Bundle();
}
// Use the register servlet, with 'delete=true'.
// Registration service returns a registration_id on success - or an error code.
data.putString(EXTRA_DELETE, "1");
subscribe(source, data);
}
private Intent registerRpc(Bundle data) throws IOException {
if (Looper.getMainLooper() == Looper.myLooper()) {
throw new IOException(ERROR_MAIN_THREAD);
}
if (PackageUtils.getPackageVersion(
ContextUtils.getApplicationContext(), GOOGLE_PLAY_SERVICES_PACKAGE)
< 0) {
throw new IOException("Google Play Services missing");
}
if (data == null) {
data = new Bundle();
}
final BlockingQueue<Intent> responseResult = new LinkedBlockingQueue<Intent>();
Handler responseHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
Intent res = (Intent) msg.obj;
responseResult.add(res);
}
};
Messenger responseMessenger = new Messenger(responseHandler);
Intent intent = new Intent(ACTION_C2DM_REGISTER);
intent.setPackage(GOOGLE_PLAY_SERVICES_PACKAGE);
setPackageNameExtra(intent);
intent.putExtras(data);
intent.putExtra(EXTRA_MESSENGER, responseMessenger);
ContextUtils.getApplicationContext().startService(intent);
try {
return responseResult.poll(REGISTER_TIMEOUT, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
throw new IOException(e.getMessage());
}
}
private String getExtraOrThrow(Intent intent, String extraKey) throws IOException {
if (intent == null) {
throw new IOException(ERROR_SERVICE_NOT_AVAILABLE);
}
String extraValue = intent.getStringExtra(extraKey);
if (extraValue != null) {
return extraValue;
}
String err = intent.getStringExtra(C2DM_EXTRA_ERROR);
if (err != null) {
throw new IOException(err);
} else {
throw new IOException(ERROR_SERVICE_NOT_AVAILABLE);
}
}
private void setPackageNameExtra(Intent intent) {
synchronized (mAppPendingIntentLock) {
if (mAppPendingIntent == null) {
Intent target = new Intent();
// Fill in the package, to prevent the intent from being used.
target.setPackage("com.google.example.invalidpackage");
mAppPendingIntent = PendingIntent.getBroadcast(
ContextUtils.getApplicationContext(), 0, target, 0);
}
}
intent.putExtra(INTENT_PARAM_APP, mAppPendingIntent);
}
}
|
robabram/raw-data-repository-v2 | rdr_server/tests/__init__.py | <reponame>robabram/raw-data-repository-v2
#
# This file is subject to the terms and conditions defined in the
# file 'LICENSE', which is part of this source code package.
#
from flask import Flask
from flask_restplus import Api, Resource
# import api namespaces
from rdr_server.api.hello_world import api as ns1
# If `entrypoint` is not defined in app.yaml, App Engine will look for an app
# called `app` in `main.py`.
app = Flask(__name__)
api = Api(app)
# Add name spaces
api.add_namespace(ns1)
@api.route('/_ah/warmup')
class HelloWorld(Resource):
def get(self):
return '{ "success": "true" }'
|
tpayne86/react-monorepo | packages/package-generator/src/templates/react/src/App/Layout/styles.js | import s from 'styled-components';
import { marginCenter } from '@healthifyme/styles/lib/box';
export const Content = s.div`
background: #fff;
padding: 24px;
min-height: 90vh;
max-width:80%;
${marginCenter};
`;
export const Logo = s.p`
height: 31px;
float: left;
font-size: 30px;
text-decoration: none;
color: white;
margin-right: 20px;
margin-bottom:0px;
`;
|
milador/jacdac | dist/c/winddirection.h | // Autogenerated C header file for Wind direction
#ifndef _JACDAC_SPEC_WIND_DIRECTION_H
#define _JACDAC_SPEC_WIND_DIRECTION_H 1
#define JD_SERVICE_CLASS_WIND_DIRECTION 0x186be92b
/**
* Read-only ° uint16_t. The direction of the wind.
*/
#define JD_WIND_DIRECTION_REG_WIND_DIRECTION JD_REG_READING
/**
* Read-only ° uint16_t. Error on the wind direction reading
*/
#define JD_WIND_DIRECTION_REG_WIND_DIRECTION_ERROR JD_REG_READING_ERROR
#endif
|
rju/peething | workbench/src/de/peerthing/workbench/resourcetreeview/ResourceViewPopupMenuListener.java | package de.peerthing.workbench.resourcetreeview;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.jface.action.Action;
import org.eclipse.jface.action.IMenuListener;
import org.eclipse.jface.action.IMenuManager;
import org.eclipse.jface.action.MenuManager;
import org.eclipse.jface.action.Separator;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.TreeViewer;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.actions.ActionFactory;
import de.peerthing.workbench.filetyperegistration.IFileTypeRegistration;
/**
* The method menuAboutToShow is called when the popup menu in the resource view
* is about to show. This class registers new menu entries depending on the
* current context and the registered filetype registrations. Checks if the
* selected elements are files and adds "open with..." entries to the popup menu
* where appropriate. Furthermore, New File entries are added to a submenu.
*
* @author <NAME>
*
*/
public class ResourceViewPopupMenuListener implements IMenuListener {
private TreeViewer viewer;
private ArrayList<IFileTypeRegistration> fileTypeRegistration;
private Hashtable<String, ArrayList<IFileTypeRegistration>> filetypes;
/**
* Creates a new popup menu listener.
*
* @param viewer The resource tree viewer
* @param fileTypeRegistration The filetype registration
* @param filetypes The filetype registrations ordered by
* filetype names.
*/
public ResourceViewPopupMenuListener(TreeViewer viewer,
ArrayList<IFileTypeRegistration> fileTypeRegistration,
Hashtable<String, ArrayList<IFileTypeRegistration>> filetypes) {
this.viewer = viewer;
this.fileTypeRegistration = fileTypeRegistration;
this.filetypes = filetypes;
}
public void menuAboutToShow(IMenuManager manager) {
manager.add(new Separator(ActionFactory.NEW.getId()));
manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
IStructuredSelection sel = (IStructuredSelection) viewer.getSelection();
if (sel == null) {
return;
}
// For IContainers, create a New submenu...
boolean isFolders = true;
List<IContainer> containers = new ArrayList<IContainer>();
for (Object selected : sel.toList()) {
if (!(selected instanceof IContainer)) {
isFolders = false;
break;
}
containers.add((IContainer) selected);
}
if (isFolders) {
MenuManager newMenu = new MenuManager("New",
"de.peerthing.workbench.NewMenu");
newMenu.setParent(manager);
manager.insertBefore(ActionFactory.NEW.getId(), newMenu);
for (IFileTypeRegistration reg : fileTypeRegistration) {
if (reg.getNewFileDefinition() != null) {
newMenu.add(new NewFileAction(reg, containers));
}
}
return;
}
ArrayList<IFileTypeRegistration> allRegs = null;
IFile[] files = new IFile[sel.size()];
int fileNo = 0;
// only if all selected elements are files,
// the open with... entries must be shown
for (Object selected : sel.toList()) {
if (!(selected instanceof IFile)) {
return;
}
IFile file = (IFile) selected;
files[fileNo++] = file;
ArrayList<IFileTypeRegistration> regs = filetypes.get(file
.getFileExtension());
if (regs == null) {
// If a file is not supported by any
// component, then no component
// can be used to open the files.
allRegs = null;
break;
} else if (allRegs == null) {
allRegs = new ArrayList<IFileTypeRegistration>(regs);
} else {
// check if all entries in allRegs are also
// in regs. Remove all entries in allRegs
// that are not in regs.
for (int i = 0; i < allRegs.size(); i++) {
if (!regs.contains(allRegs.get(i))) {
allRegs.remove(i);
}
}
}
}
if (allRegs != null) {
for (IFileTypeRegistration reg : allRegs) {
manager.insertBefore(IWorkbenchActionConstants.MB_ADDITIONS,
new CallComponentAction(reg, files));
}
}
}
}
/**
*
* An action that calls the component given in the constructor in its run
* action.
*
*
*/
class CallComponentAction extends Action {
IFileTypeRegistration reg;
IFile[] inputFiles;
public CallComponentAction(IFileTypeRegistration reg, IFile[] inputfiles) {
this.reg = reg;
this.inputFiles = inputfiles;
}
@Override
public String getText() {
return "Open with " + reg.getComponentName();
}
@Override
public void run() {
reg.showComponent(inputFiles);
}
} |
johanssl/EnfuserMIT | EnfuserMIT/src/main/java/org/fmi/aq/enfuser/ftools/FuserTools.java | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package org.fmi.aq.enfuser.ftools;
import org.fmi.aq.enfuser.datapack.main.Observation;
import org.fmi.aq.essentials.date.Dtime;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.URL;
import java.net.URLConnection;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
import org.apache.commons.io.FileUtils;
import ucar.nc2.Attribute;
import org.fmi.aq.enfuser.logging.EnfuserLogger;
import java.util.logging.Level;
import org.fmi.aq.enfuser.core.DataCore;
import org.fmi.aq.enfuser.mining.feeds.Feed;
import org.fmi.aq.enfuser.mining.feeds.FeedFetch;
import org.fmi.aq.enfuser.options.ERCFarguments;
import org.fmi.aq.enfuser.options.FusionOptions;
import org.fmi.aq.enfuser.options.GlobOptions;
/**
*
* @author johanssl
*/
public class FuserTools {
public static final String EMPTY_STRING = "";
/**
* Checks data time range validity with respect a timespan of interest.This
is a brute-force check, iterating one hour at a time. If any hour matched
within the span this returns true.
*
* @param start start time for domain of interest
* @param end end time for domain of interest
* @param sysHours_data [start,end] in terms of data date system hours.
* @return true if an overlap of the time spans was observed, signaling that
* the dataset is time-wise applicable. Otherwise, returns false.
*/
public static boolean evaluateSpan(Dtime start, Dtime end, int[] sysHours_data) {
for (int dh = sysHours_data[0]; dh <= sysHours_data[1]; dh++) {
if (dh >= start.systemHours() && dh <= end.systemHours()) {
return true;
}
}
return false;
}
/**
* A simple test method to check if the given h-w index would
* cause on OutOfBoundsException in the pbject grid.
* @param dat the grid
* @param h h index
* @param w w index
* @return true if OutOfBounds.
*/
public static boolean ObjectGridOobs(Object[][] dat, int h, int w) {
if (h<0 || h > dat.length-1) return true;
if (w<0 || w > dat[0].length-1) return true;
return false;
}
public static String getUrlContent_old(String address) throws IOException {
URL hirlam = new URL(address);
EnfuserLogger.log(Level.FINER,FuserTools.class,"Opening connection to " + address);
URLConnection yc = hirlam.openConnection();
InputStream aa = yc.getInputStream();
BufferedReader in = new BufferedReader(new InputStreamReader(aa));
String inputLine;
String currContent = "";
int counter = 0;
while ((inputLine = in.readLine()) != null) {
//EnfuserLogger.log(Level.FINER,FuserTools.class,inputLine);
counter++;
currContent += inputLine;
}
in.close();
EnfuserLogger.log(Level.FINER,FuserTools.class,
"Read successfully" + counter + " lines from url.\n\n" + currContent);
return currContent;
}
public static String correctDir(String dir) {
//could it be that the wrong file separator is being used?
String original = dir + "";
String other = "/";
if (FileOps.Z.equals(other)) {
other = "\\";
}
if (dir.contains(other + "")) {
dir = dir.replace(other + "", FileOps.Z);
}
if (!dir.startsWith(FileOps.Z + FileOps.Z)) {// it is safe to remove double file separators
dir = dir.replace(FileOps.Z + FileOps.Z, FileOps.Z);
}
String finalDir;
if (dir.endsWith(FileOps.Z)) {
finalDir = dir;//all ok
} else {
finalDir = dir + FileOps.Z;
}
if (!original.equals(finalDir)) {
EnfuserLogger.log(Level.FINER,FuserTools.class,
"correctDir: a correction has been made: " + original + " => " + finalDir);
}
return finalDir;
}
/**
* Recursive delete method to clear a directory with sub-directories.
* Deletion will occur only for the given file types (for safety)
* @param directoryToBeDeleted
* @param delTypes
* @return
*/
public static boolean deleteDirectoryContents(File directoryToBeDeleted, String[] delTypes) {
File[] allContents = directoryToBeDeleted.listFiles();
if (allContents != null) {
for (File file : allContents) {
deleteDirectoryContents(file, delTypes);
}
}
boolean ok = false;
for (String s:delTypes) {
if (directoryToBeDeleted.getName().endsWith(s)) ok = true;
}
if (directoryToBeDeleted.isDirectory())ok=true;
if (ok) {
EnfuserLogger.log(Level.FINE, FuserTools.class,
"Deleting: "+ directoryToBeDeleted.getAbsolutePath());
return directoryToBeDeleted.delete();
} else {
return false;
}
}
/**
* Check the given directory for files and return the age of the most recent
* file of them in hours.
* @param dir the directory
* @return the age of the most recent file in hours. If there are no files
* returns null.
*/
public static Integer getMostRecentFileAge(String dir) {
int smallestH = Integer.MAX_VALUE;
try {
long secsNow = System.currentTimeMillis() / 1000;
File f = new File(dir);
File[] ff = f.listFiles();
if (ff == null) {
return null;
}
for (File file : ff) {
long secsFile = file.lastModified() / 1000;
//check maturity
long hours = (secsNow - secsFile) / 3600;
if (hours < smallestH) {
smallestH = (int)hours;
}
}//for files in dir
} catch (Exception e) {
EnfuserLogger.log(e,Level.WARNING, FileCleaner.class,
"File age assessment process encountered an Exception for "+dir);
}
return smallestH;
}
public static File findFileThatContains(String rootdir, String[] contains) {
File f = null;
File root = new File(rootdir);
int k = 0;
EnfuserLogger.log(Level.FINER,FuserTools.class,
"Finding files with '"+contains[0] +"' from all subdirectories of "+ rootdir);
try {
boolean recursive = true;
Collection files = FileUtils.listFiles(root, null, recursive);
for (Iterator iterator = files.iterator(); iterator.hasNext();) {
File file = (File) iterator.next();
boolean containsAll = true;
for (String test : contains) {
if (!file.getName().contains(test)) {
containsAll = false;
}
}
k++;
if (containsAll) {
EnfuserLogger.log(Level.FINER,FuserTools.class,
"Found the file matching description, k = " + k);
return file;
}
}
} catch (Exception e) {
EnfuserLogger.log(e,Level.SEVERE,FuserTools.class,
"File search encountered an error from "+ rootdir);
}
EnfuserLogger.log(Level.FINER,FuserTools.class,"Searched " + k + " files without match.");
return f;
}
public static void clearDirContent(String dir) {
EnfuserLogger.log(Level.FINER,FuserTools.class,"Clearing content of " + dir);
File f = new File(dir);
File[] files = f.listFiles();
EnfuserLogger.log(Level.FINER,FuserTools.class,files.length + " files inside.");
for (File ff : files) {
if (!ff.isDirectory()) {
ff.delete();
} else if (ff.getName().contains("QC_locs")) {
ff.delete();
}
}
}
public static float[][] transform_byteFloat(byte[][] dat) {
float[][] ndat = new float[dat.length][dat[0].length];
for (int h = 0; h < dat.length; h++) {
for (int w = 0; w < dat[0].length; w++) {
ndat[h][w] = (float) dat[h][w];
}
}
return ndat;
}
private static int getFinnishTermicSeason(Dtime dt) {
int month = dt.month_011;
if (month == Calendar.JANUARY || month == Calendar.FEBRUARY || month == Calendar.DECEMBER) {
return 0; //WINTER
} else if (month == Calendar.MARCH || month == Calendar.APRIL || month == Calendar.MAY) {
return 1; //SPRING
} else if (month == Calendar.JUNE || month == Calendar.JULY || month == Calendar.AUGUST) {
return 2; //SUMMER {
} else {
return 3;
//AUTUMN
}
}
public static String getTermicSeasonAverages(ArrayList<Observation> obs) {
float[] aves = new float[7];
float[] n = new float[7];
aves[5] = obs.get(0).lat;
aves[6] = obs.get(0).lon;
for (Observation o : obs) {
int season = getFinnishTermicSeason(o.dt);
aves[0] += o.value;
aves[season + 1] += o.value;
n[season + 1]++;
n[0]++;
}
for (int i = 0; i < 5; i++) {
aves[i] /= n[i];
}
String s = "";
for (int i = 0; i < aves.length; i++) {
s += aves[i] + ";";
}
return s;
}
public static double getAverage(ArrayList<Observation> obs) {
double ave = 0;
for (Observation o : obs) {
ave += o.value;
}
ave /= obs.size();
return ave;
}
public static float editPrecisionF(double value, int precision) {
if (precision >= 0) {
long prec = (long) Math.pow(10, precision);
long temp = (long) (prec * value);
float result = (float) temp / prec;
return result;
} else {
// reduction in precision, e.g. 12345 => 12000
int divisor = (int) Math.pow(10, Math.abs(precision));
int temp = (int) (value / divisor);
float result = temp * divisor;
return result;
}
}
public static void copyfile(String srFile, String dtFile)
throws FileNotFoundException, IOException {
File f1 = new File(srFile);
File f2 = new File(dtFile);
InputStream in = new FileInputStream(f1);
OutputStream out = new FileOutputStream(f2);
byte[] buf = new byte[1024];
int len;
while ((len = in.read(buf)) > 0) {
out.write(buf, 0, len);
}
in.close();
out.close();
EnfuserLogger.log(Level.FINER,FuserTools.class,"File copied.");
}
public static void deleteFile(String fileName) {
// A File object to represent the filename
boolean doIt = true;
File f = new File(fileName);
// Make sure the file or directory exists and isn't write protected
if (!f.exists()) {
doIt = false;
EnfuserLogger.log(Level.WARNING,FuserTools.class,
"Delete: no such file or directory: " + fileName);
}
if (!f.canWrite()) {
doIt = false;
EnfuserLogger.log(Level.WARNING,FuserTools.class,
"Delete: write protected: " + fileName);
}
// Attempt to delete it
boolean success = false;
if (doIt) {
success = f.delete();
}
if (!success) {
throw new IllegalArgumentException("Delete: deletion failed");
}
}
public static final void unzip(String file, String rootdir) {
Enumeration entries;
ZipFile zipFile;
try {
zipFile = new ZipFile(file);
entries = zipFile.entries();
while (entries.hasMoreElements()) {
ZipEntry entry = (ZipEntry) entries.nextElement();
if (entry.isDirectory()) {
// Assume directories are stored parents first then children.
EnfuserLogger.log(Level.FINE,FuserTools.class,"Extracting directory: " + entry.getName());
// This is not robust, just for demonstration purposes.
(new File(entry.getName())).mkdir();
continue;
}
EnfuserLogger.log(Level.FINE,FuserTools.class,"Extracting file: " + entry.getName());
String outFile = rootdir + entry.getName();
OutputStream out = new BufferedOutputStream(new FileOutputStream(outFile));
InputStream in = zipFile.getInputStream(entry);
byte[] buffer = new byte[1024];
int len;
while ((len = in.read(buffer)) >= 0) {
out.write(buffer, 0, len);
}
in.close();
out.close();
}
zipFile.close();
} catch (IOException ioe) {
EnfuserLogger.log(Level.WARNING,FuserTools.class,
"File unzip unsuccessful: "+ file +" => "+ rootdir);
}
}
/**
* Returns a FilenameFilter which accepts files with the given extension.
*
* @param extension The file extension (e.g. "csv"). Not case sensitive.
* @return FilenameFilter accepting files with the extension.
*/
public static FilenameFilter getFileExtensionFilter(String extension) {
return new FilenameFilter() {
public boolean accept(File file, String name) {
return name.toLowerCase().endsWith("." + extension.replace(".", "")); // some tolerance for usage
}
};
}
public static String tab(String s, int len) {
while (s.length() < len) {
s += " ";
}
return s;
}
public static String tab(String s) {
while (s.length() < 15) {
s += " ";
}
return s;
}
// parent folders of dest must exist before calling this function
public static void copyTo(File src, File dest) throws IOException {
FileInputStream fileInputStream = new FileInputStream(src);
FileOutputStream fileOutputStream = new FileOutputStream(dest);
int bufferSize;
byte[] bufffer = new byte[512];
while ((bufferSize = fileInputStream.read(bufffer)) > 0) {
fileOutputStream.write(bufffer, 0, bufferSize);
}
fileInputStream.close();
fileOutputStream.close();
}
public static ArrayList<Attribute> getNetCDF_attributes(Dtime lastObservationTime) {
ArrayList<Attribute> netAttr = new ArrayList<>();
Dtime sysDt = Dtime.getSystemDate_utc(false, Dtime.STAMP_NOZONE);
netAttr.add(new Attribute("Conventions", "CF-1.0"));
netAttr.add(new Attribute("institution", "Finnish Meteorological Institute"));
netAttr.add(new Attribute("creator", "<NAME>, email <EMAIL>"));
netAttr.add(new Attribute("history", "model version: " + DataCore.VERSION_INFO + ", file produced " + sysDt.getStringDate(Dtime.STAMP_NOZONE) + "Z"));
if (lastObservationTime != null) {
netAttr.add(new Attribute("info", "last observed datapoint: " + lastObservationTime.getStringDate(Dtime.STAMP_NOZONE) + "Z"));
}
//netAttr.add(new Attribute("references", "<NAME>, <NAME>, <NAME>, <NAME>, <NAME>," + " <NAME>, <NAME>, <NAME> and <NAME>, Fusion of meteorological and air quality data" + " extracted from the web for personalized environmental information services, Environmental Modelling & Software," + "Volume 64, February 2015, Pages 143\u2013155, Elsevier, 2014."));
netAttr.add(new Attribute("title", "Modelled pollutant concentrations and supplemental data according to FMI-ENFUSER"));
return netAttr;
}
public static ArrayList<Integer> arrayConvert(ArrayList<Byte> arr) {
ArrayList<Integer> ar2 = new ArrayList<>();
for (byte b : arr) {
ar2.add((int) b);
}
return ar2;
}
public static ArrayList<Byte> arrayConvert2(ArrayList<Integer> arr) {
ArrayList<Byte> ar2 = new ArrayList<>();
for (int b : arr) {
ar2.add((byte) b);
}
return ar2;
}
/**
* Wait for the given amount of seconds and return a manually specified system
* input line.
* This method can be used to query user input in cases where a user is present
* and manual input is required to proceed further.
* @param waitSeconds amount of time in seconds allowed for input typing.
* @return manually types input String. Returns null if none was given.
*/
public static String readSystemInput(int waitSeconds) {
String resp =null;
int x = waitSeconds; // wait 20 seconds at most
BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
long startTime = System.currentTimeMillis();
try {
while ((System.currentTimeMillis() - startTime) < x * 1000
&& !in.ready()) {
}
if (in.ready()) {
resp = in.readLine();
EnfuserLogger.log(Level.INFO,FuserTools.class,"Input given: " + resp);
} else {
//rule 3: if manual and no input has been defined, assume 'flex'
EnfuserLogger.log(Level.INFO,FuserTools.class,"Input was not given.");
return null;
}
} catch (IOException ex) {
EnfuserLogger.log(ex,Level.WARNING,FuserTools.class,"Input read failure!");
}
return resp;
}
public static Dtime[] fullpreviousMonth(Dtime dt) {
Dtime end = dt.clone();
end.addSeconds(-1*(end.sec + end.min*60 + end.hour*3600 + (end.day-1)*24*3600));
end.addSeconds(-3600);
System.out.println("last month's last hour (END): "
+end.getStringDate_noTS());
Dtime start = end.clone();
start.addSeconds(-1*(start.sec + start.min*60 + start.hour*3600 + (start.day-1)*24*3600));
System.out.println("last month's first hour (START): "
+ start.getStringDate_noTS());
return new Dtime[]{start,end};
}
private final static String CONCAT_NAME ="concat.csv";
public static void concatenateCSVFiles(String dir, boolean headerRem, String[] replacements) {
ArrayList<String> lines = new ArrayList<>();
File f = new File(dir);
int k =0;
for (File test:f.listFiles()) {
String name = test.getName();
if (!name.endsWith(".csv")) continue;
if (name.equals(CONCAT_NAME)) continue;
k++;
System.out.println("Added as "+ k+": "+ name);
ArrayList<String> arr = FileOps.readStringArrayFromFile(test);
if (!lines.isEmpty() && headerRem) {
arr.remove(0);//remove header, it has been added once.
}
if (replacements!=null) {
ArrayList<String> temp = new ArrayList<>();
for (String line:arr) {
for (int i =0;i<replacements.length;i+=2) {
String target = replacements[i];
String rep = replacements[i+1];
line = line.replace(target, rep);
}//for mods
temp.add(line);
}//for lines
arr = temp;
}//if mods
lines.addAll(arr);
}
FileOps.printOutALtoFile2(dir, lines, CONCAT_NAME, false);
System.out.println("Concat Done.");
}
public static void main(String[] args) {
concatenateCSVFiles("E:\\Dropbox\\UTO_ICOS_wind_2020\\", true, new String[]{" ","T",",",";"});
}
public static void mkMissingDirsFiles(FusionOptions ops) {
//first check feed directories
File f;
ERCFarguments rargs = ops.getArguments();
String mdir = rargs.getMinerDir();
String[] cdirs = {GlobOptions.get().enfuserArchiveDir(null), //EnfuserArchive
rargs.getMinerDir(true), //global
rargs.getMinerDir(false)};
for (String cdir : cdirs) {
f = new File(cdir);
if (!f.exists()) {
EnfuserLogger.log(Level.FINER, " Creating non-existing directory: " + f.getAbsolutePath());
f.mkdirs();
}
}
ArrayList<Feed> feeds = FeedFetch.getFeeds(ops, FeedFetch.MUST_ACT);
for (Feed feed : feeds) {
if (feed == null || feed.primaryMinerDir == null) {
continue;
}
String feedDir = feed.primaryMinerDir;
f = new File(feedDir);
if (!f.exists()) {
EnfuserLogger.log(Level.FINER, "\t Creating non-existing directory: " + f.getAbsolutePath());
f.mkdirs();
}
} //for ind
String root = GlobOptions.get().getRootDir();
String logs = root + "logs" + FileOps.Z;
f = new File(logs);
if (!f.exists()) {
EnfuserLogger.log(Level.FINER, "\t Creating non-existing directory: " + f.getAbsolutePath());
f.mkdirs();
}
//results dirs ==============
String res = root + "Results" + FileOps.Z;
f = new File(res);
if (!f.exists()) {
EnfuserLogger.log(Level.FINER, "\t Creating non-existing directory: " + f.getAbsolutePath());
f.mkdirs();
}
String resCT = root + "Results" + FileOps.Z + "COMMON_TEMP" + FileOps.Z;
f = new File(resCT);
if (!f.exists()) {
EnfuserLogger.log(Level.FINER, "\t Creating non-existing directory: " + f.getAbsolutePath());
f.mkdirs();
}
String resSC = root + "Results" + FileOps.Z + "statCrunch" + FileOps.Z;
f = new File(resSC);
if (!f.exists()) {
EnfuserLogger.log(Level.FINER, "\t Creating non-existing directory: " + f.getAbsolutePath());
f.mkdirs();
}
}
public static float sum(float[] ex) {
if (ex==null) return 0;
float sum =0;
for (float f:ex) {
sum+=f;
}
return sum;
}
}
|
jovanbulck/SGX-Shield | llvm/tools/clang/test/CodeGen/fma4-builtins.c | // RUN: %clang_cc1 %s -triple=x86_64-apple-darwin -target-feature +fma4 -emit-llvm -o - -Wall -Werror | FileCheck %s
// Don't include mm_malloc.h, it's system specific.
#define __MM_MALLOC_H
#include <x86intrin.h>
__m128 test_mm_macc_ps(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_macc_ps
// CHECK: @llvm.x86.fma.vfmadd.ps
return _mm_macc_ps(a, b, c);
}
__m128d test_mm_macc_pd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_macc_pd
// CHECK: @llvm.x86.fma.vfmadd.pd
return _mm_macc_pd(a, b, c);
}
__m128 test_mm_macc_ss(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_macc_ss
// CHECK: @llvm.x86.fma.vfmadd.ss
return _mm_macc_ss(a, b, c);
}
__m128d test_mm_macc_sd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_macc_sd
// CHECK: @llvm.x86.fma.vfmadd.sd
return _mm_macc_sd(a, b, c);
}
__m128 test_mm_msub_ps(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_msub_ps
// CHECK: @llvm.x86.fma.vfmsub.ps
return _mm_msub_ps(a, b, c);
}
__m128d test_mm_msub_pd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_msub_pd
// CHECK: @llvm.x86.fma.vfmsub.pd
return _mm_msub_pd(a, b, c);
}
__m128 test_mm_msub_ss(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_msub_ss
// CHECK: @llvm.x86.fma.vfmsub.ss
return _mm_msub_ss(a, b, c);
}
__m128d test_mm_msub_sd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_msub_sd
// CHECK: @llvm.x86.fma.vfmsub.sd
return _mm_msub_sd(a, b, c);
}
__m128 test_mm_nmacc_ps(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_nmacc_ps
// CHECK: @llvm.x86.fma.vfnmadd.ps
return _mm_nmacc_ps(a, b, c);
}
__m128d test_mm_nmacc_pd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_nmacc_pd
// CHECK: @llvm.x86.fma.vfnmadd.pd
return _mm_nmacc_pd(a, b, c);
}
__m128 test_mm_nmacc_ss(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_nmacc_ss
// CHECK: @llvm.x86.fma.vfnmadd.ss
return _mm_nmacc_ss(a, b, c);
}
__m128d test_mm_nmacc_sd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_nmacc_sd
// CHECK: @llvm.x86.fma.vfnmadd.sd
return _mm_nmacc_sd(a, b, c);
}
__m128 test_mm_nmsub_ps(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_nmsub_ps
// CHECK: @llvm.x86.fma.vfnmsub.ps
return _mm_nmsub_ps(a, b, c);
}
__m128d test_mm_nmsub_pd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_nmsub_pd
// CHECK: @llvm.x86.fma.vfnmsub.pd
return _mm_nmsub_pd(a, b, c);
}
__m128 test_mm_nmsub_ss(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_nmsub_ss
// CHECK: @llvm.x86.fma.vfnmsub.ss
return _mm_nmsub_ss(a, b, c);
}
__m128d test_mm_nmsub_sd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_nmsub_sd
// CHECK: @llvm.x86.fma.vfnmsub.sd
return _mm_nmsub_sd(a, b, c);
}
__m128 test_mm_maddsub_ps(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_maddsub_ps
// CHECK: @llvm.x86.fma.vfmaddsub.ps
return _mm_maddsub_ps(a, b, c);
}
__m128d test_mm_maddsub_pd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_maddsub_pd
// CHECK: @llvm.x86.fma.vfmaddsub.pd
return _mm_maddsub_pd(a, b, c);
}
__m128 test_mm_msubadd_ps(__m128 a, __m128 b, __m128 c) {
// CHECK-LABEL: test_mm_msubadd_ps
// CHECK: @llvm.x86.fma.vfmsubadd.ps
return _mm_msubadd_ps(a, b, c);
}
__m128d test_mm_msubadd_pd(__m128d a, __m128d b, __m128d c) {
// CHECK-LABEL: test_mm_msubadd_pd
// CHECK: @llvm.x86.fma.vfmsubadd.pd
return _mm_msubadd_pd(a, b, c);
}
__m256 test_mm256_macc_ps(__m256 a, __m256 b, __m256 c) {
// CHECK-LABEL: test_mm256_macc_ps
// CHECK: @llvm.x86.fma.vfmadd.ps.256
return _mm256_macc_ps(a, b, c);
}
__m256d test_mm256_macc_pd(__m256d a, __m256d b, __m256d c) {
// CHECK-LABEL: test_mm256_macc_pd
// CHECK: @llvm.x86.fma.vfmadd.pd.256
return _mm256_macc_pd(a, b, c);
}
__m256 test_mm256_msub_ps(__m256 a, __m256 b, __m256 c) {
// CHECK-LABEL: test_mm256_msub_ps
// CHECK: @llvm.x86.fma.vfmsub.ps.256
return _mm256_msub_ps(a, b, c);
}
__m256d test_mm256_msub_pd(__m256d a, __m256d b, __m256d c) {
// CHECK-LABEL: test_mm256_msub_pd
// CHECK: @llvm.x86.fma.vfmsub.pd.256
return _mm256_msub_pd(a, b, c);
}
__m256 test_mm256_nmacc_ps(__m256 a, __m256 b, __m256 c) {
// CHECK-LABEL: test_mm256_nmacc_ps
// CHECK: @llvm.x86.fma.vfnmadd.ps.256
return _mm256_nmacc_ps(a, b, c);
}
__m256d test_mm256_nmacc_pd(__m256d a, __m256d b, __m256d c) {
// CHECK-LABEL: test_mm256_nmacc_pd
// CHECK: @llvm.x86.fma.vfnmadd.pd.256
return _mm256_nmacc_pd(a, b, c);
}
__m256 test_mm256_nmsub_ps(__m256 a, __m256 b, __m256 c) {
// CHECK-LABEL: test_mm256_nmsub_ps
// CHECK: @llvm.x86.fma.vfnmsub.ps.256
return _mm256_nmsub_ps(a, b, c);
}
__m256d test_mm256_nmsub_pd(__m256d a, __m256d b, __m256d c) {
// CHECK-LABEL: test_mm256_nmsub_pd
// CHECK: @llvm.x86.fma.vfnmsub.pd.256
return _mm256_nmsub_pd(a, b, c);
}
__m256 test_mm256_maddsub_ps(__m256 a, __m256 b, __m256 c) {
// CHECK-LABEL: test_mm256_maddsub_ps
// CHECK: @llvm.x86.fma.vfmaddsub.ps.256
return _mm256_maddsub_ps(a, b, c);
}
__m256d test_mm256_maddsub_pd(__m256d a, __m256d b, __m256d c) {
// CHECK-LABEL: test_mm256_maddsub_pd
// CHECK: @llvm.x86.fma.vfmaddsub.pd.256
return _mm256_maddsub_pd(a, b, c);
}
__m256 test_mm256_msubadd_ps(__m256 a, __m256 b, __m256 c) {
// CHECK-LABEL: test_mm256_msubadd_ps
// CHECK: @llvm.x86.fma.vfmsubadd.ps.256
return _mm256_msubadd_ps(a, b, c);
}
__m256d test_mm256_msubadd_pd(__m256d a, __m256d b, __m256d c) {
// CHECK-LABEL: test_mm256_msubadd_pd
// CHECK: @llvm.x86.fma.vfmsubadd.pd.256
return _mm256_msubadd_pd(a, b, c);
}
|
lcrownover/bolt | spec/bolt/outputter/json_spec.rb | <reponame>lcrownover/bolt<gh_stars>0
# frozen_string_literal: true
require 'spec_helper'
require 'bolt/outputter'
require 'bolt/cli'
describe "Bolt::Outputter::JSON" do
let(:output) { StringIO.new }
let(:outputter) { Bolt::Outputter::JSON.new(false, false, false, false, output) }
let(:inventory) { Bolt::Inventory.empty }
let(:target1) { inventory.get_target('target1') }
let(:target2) { inventory.get_target('target2') }
let(:results) { { node1: Bolt::Result.new(target1, value: { 'msg' => "ok" }) } }
it "starts items in head" do
outputter.print_head
expect(output.string).to match(/"items": \[\w*\Z/)
end
it "allows empty items" do
outputter.print_head
outputter.print_summary(results, 10.0)
parsed = JSON.parse(output.string)
expect(parsed['items']).to eq([])
end
it "prints multiple items" do
outputter.print_head
outputter.print_result(Bolt::Result.new(target1))
outputter.print_result(Bolt::Result.new(target2, error: { 'msg' => 'oops' }))
outputter.print_summary(results, 10.0)
parsed = JSON.parse(output.string)
expect(parsed['items'].size).to eq(2)
expect(parsed['items'][0]['status']).to eq('success')
expect(parsed['items'][1]['status']).to eq('failure')
end
it "formats a table" do
table = [%w[a b], %w[c1 d]]
outputter.print_table(table)
expect(JSON.parse(output.string)).to eq(table)
end
it "formats a task" do
name = 'cinnamon roll'
files = [{ 'name' => 'cinnamon.rb',
'path' => '/path/to/cinnamony/goodness/tasks/cinnamon.rb' },
{ 'name' => 'roll.sh',
'path' => '/path/to/wrong/module/tasks/roll.sh' }]
metadata = {
'description' => 'A delicious sweet bun',
'parameters' => {
'icing' => {
'type' => 'Cream cheese',
'description' => 'Rich, tangy, sweet'
}
}
}
result = {
'name' => name,
'files' => files,
'metadata' => metadata,
'module_dir' => '/path/to/cinnamony/goodness'
}
outputter.print_task_info(Bolt::Task.new(name, metadata, files))
expect(JSON.parse(output.string)).to eq(result)
end
it "prints builtin for builtin modules" do
name = 'monkey bread'
files = [{ 'name' => 'monkey_bread.rb',
'path' => "#{Bolt::Config::Modulepath::MODULES_PATH}/monkey/bread" }]
metadata = {}
result = {
'name' => name,
'files' => files,
'metadata' => metadata,
'module_dir' => 'built-in module'
}
outputter.print_task_info(Bolt::Task.new(name, metadata, files))
expect(JSON.parse(output.string)).to eq(result)
end
it "formats a plan" do
plan = {
'name' => 'planity_plan',
'module' => 'plan/plan/plan',
'files' => [{ 'name' => 'planity',
'path' => 'plan/plan' }],
'parameters' => [
{
'name' => 'foo',
'type' => 'Bar'
},
{
'name' => 'baz',
'type' => 'Bar',
'default_value' => nil
}
]
}
outputter.print_plan_info(plan)
expect(JSON.parse(output.string)).to eq(plan)
end
it "formats ExecutionResult from a plan" do
result = [
{ 'node' => 'node1', 'status' => 'finished', 'result' => { '_output' => 'yes' } },
{ 'node' => 'node2', 'status' => 'failed', 'result' =>
{ '_error' => { 'message' => 'The command failed with exit code 2',
'kind' => 'puppetlabs.tasks/command-error',
'issue_code' => 'COMMAND_ERROR',
'partial_result' => { 'stdout' => 'no', 'stderr' => '', 'exit_code' => 2 },
'details' => { 'exit_code' => 2 } } } }
]
outputter.print_plan_result(result)
result_hash = JSON.parse(output.string)
expect(result_hash).to eq(result)
end
it "prints non-ExecutionResult from a plan" do
result = "some data"
outputter.print_plan_result(result)
expect(output.string.strip).to eq('"' + result + '"')
end
it "prints the result of installing a Puppetfile" do
outputter.print_puppetfile_result(true, '/path/to/Puppetfile', '/path/to/modules')
parsed = JSON.parse(output.string)
expect(parsed['success']).to eq(true)
expect(parsed['puppetfile']).to eq('/path/to/Puppetfile')
expect(parsed['moduledir']).to eq('/path/to/modules')
end
it "handles fatal errors" do
outputter.print_head
outputter.print_result(Bolt::Result.new(target1, value: { 'msg' => "ok" }))
outputter.print_result(Bolt::Result.new(target2, value: { 'msg' => "ok" }))
outputter.fatal_error(Bolt::CLIError.new("oops"))
parsed = JSON.parse(output.string)
expect(parsed['items'].size).to eq(2)
expect(parsed['_error']['kind']).to eq("bolt/cli-error")
end
it 'prints a list of guides' do
topics = %w[apple banana carrot]
outputter.print_topics(topics)
parsed = JSON.parse(output.string)
expect(parsed['topics']).to match_array(topics)
end
it 'prints a guide page' do
topic = 'boltymcboltface'
guide = "The trials and tribulations of <NAME>.\n"
outputter.print_guide(guide, 'boltymcboltface')
parsed = JSON.parse(output.string)
expect(parsed['topic']).to eq(topic)
expect(parsed['guide']).to eq(guide)
end
context '#print_targets' do
let(:inventoryfile) { '/path/to/inventory' }
let(:target_list) do
{
inventory: [double('target', name: 'target')],
adhoc: [double('target', name: 'target')]
}
end
it 'outputs inventory targets with count and file' do
outputter.print_targets(target_list, inventoryfile)
parsed = JSON.parse(output.string)
expect(parsed['inventory']).to eq(
'targets' => ['target'],
'count' => 1,
'file' => inventoryfile
)
end
it 'outputs adhoc targets with count' do
outputter.print_targets(target_list, inventoryfile)
parsed = JSON.parse(output.string)
expect(parsed['adhoc']).to eq(
'targets' => ['target'],
'count' => 1
)
end
it 'outputs all targets with count' do
outputter.print_targets(target_list, inventoryfile)
parsed = JSON.parse(output.string)
expect(parsed['targets']).to match_array(%w[target target])
expect(parsed['count']).to eq(2)
end
end
end
|
buzz66boy/NS-3_LXC | src/lib/yntdl/objects/include/link.h | #ifndef __LINK_H_INCLUDED__
#define __LINK_H_INCLUDED__
// forward declared dependencies
// include dependencies
#include <string>
#include <vector>
#include <memory>
#include "additionalTags.h"
#include "iface.h"
#include "nameable.h"
namespace yntdl {
// declarations
class Link : public IfaceAcceptor, public Nameable, public AdditionalTags {
private:
bool requiresReRef = false;
std::string type;
public:
std::vector<Iface *> ifaces;
IpAddr *ip = nullptr;
IpAddr *subnetMask = nullptr;
std::string bandwidth;
std::string latency;
Link(std::string name, std::string type): Nameable(name), AdditionalTags(), type(type) {};
Link(std::string name, Link& link);
Link(std::string name): Nameable(name) {}
Link(const Link&);
~Link();
std::string getType() { return type; }
void setType(std::string typ) { type = typ; }
const std::vector<Iface*>& getIfaces() const { return ifaces; }
int connectIface(yntdl::Iface *iface);
int connectIface(std::string ifaceName, yntdl::Iface *iface) override; // OVERRIDES IfaceAccepter
static void reRefIfaces(Link *linkPtr);
};
}
#endif |
enfoTek/tomato.linksys.e2000.nvram-mod | release/src/linux/linux/drivers/media/radio/radio-maxiradio.c | <filename>release/src/linux/linux/drivers/media/radio/radio-maxiradio.c
/*
* Guillemot Maxi Radio FM 2000 PCI radio card driver for Linux
* (C) 2001 <NAME> <<EMAIL>>
*
* Based in the radio Maestro PCI driver. Actually it uses the same chip
* for radio but different pci controller.
*
* I didn't have any specs I reversed engineered the protocol from
* the windows driver (radio.dll).
*
* The card uses the TEA5757 chip that includes a search function but it
* is useless as I haven't found any way to read back the frequency. If
* anybody does please mail me.
*
* For the pdf file see:
* http://www.semiconductors.philips.com/pip/TEA5757H/V1
*
*
* CHANGES:
* 0.75b
* - better pci interface thanks to <NAME> <<EMAIL>>
*
* 0.75
* - tiding up
* - removed support for multiple devices as it didn't work anyway
*
* BUGS:
* - card unmutes if you change frequency
*
*/
#include <linux/module.h>
#include <linux/init.h>
#include <linux/ioport.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <asm/semaphore.h>
#include <linux/pci.h>
#include <linux/videodev.h>
/* version 0.75 Sun Feb 4 22:51:27 EET 2001 */
#define DRIVER_VERSION "0.75"
#ifndef PCI_VENDOR_ID_GUILLEMOT
#define PCI_VENDOR_ID_GUILLEMOT 0x5046
#endif
#ifndef PCI_DEVICE_ID_GUILLEMOT
#define PCI_DEVICE_ID_GUILLEMOT_MAXIRADIO 0x1001
#endif
/* TEA5757 pin mappings */
const int clk = 1, data = 2, wren = 4, mo_st = 8, power = 16 ;
static int radio_nr = -1;
MODULE_PARM(radio_nr, "i");
#define FREQ_LO 50*16000
#define FREQ_HI 150*16000
#define FREQ_IF 171200 /* 10.7*16000 */
#define FREQ_STEP 200 /* 12.5*16 */
#define FREQ2BITS(x) ((( (unsigned int)(x)+FREQ_IF+(FREQ_STEP<<1))\
/(FREQ_STEP<<2))<<2) /* (x==fmhz*16*1000) -> bits */
#define BITS2FREQ(x) ((x) * FREQ_STEP - FREQ_IF)
static int radio_open(struct video_device *, int);
static int radio_ioctl(struct video_device *, unsigned int, void *);
static void radio_close(struct video_device *);
static struct video_device maxiradio_radio=
{
owner: THIS_MODULE,
name: "Maxi Radio FM2000 radio",
type: VID_TYPE_TUNER,
hardware: VID_HARDWARE_SF16MI,
open: radio_open,
close: radio_close,
ioctl: radio_ioctl,
};
static struct radio_device
{
__u16 io, /* base of radio io */
muted, /* VIDEO_AUDIO_MUTE */
stereo, /* VIDEO_TUNER_STEREO_ON */
tuned; /* signal strength (0 or 0xffff) */
unsigned long freq;
struct semaphore lock;
} radio_unit = {0, 0, 0, 0, };
static void sleep_125ms(void)
{
current->state = TASK_INTERRUPTIBLE;
schedule_timeout(HZ >> 3);
}
static void outbit(unsigned long bit, __u16 io)
{
if(bit != 0)
{
outb( power|wren|data ,io); udelay(4);
outb( power|wren|data|clk ,io); udelay(4);
outb( power|wren|data ,io); udelay(4);
}
else
{
outb( power|wren ,io); udelay(4);
outb( power|wren|clk ,io); udelay(4);
outb( power|wren ,io); udelay(4);
}
}
static void turn_power(__u16 io, int p)
{
if(p != 0) outb(power, io); else outb(0,io);
}
static void set_freq(__u16 io, __u32 data)
{
unsigned long int si;
int bl;
/* TEA5757 shift register bits (see pdf) */
outbit(0,io); // 24 search
outbit(1,io); // 23 search up/down
outbit(0,io); // 22 stereo/mono
outbit(0,io); // 21 band
outbit(0,io); // 20 band (only 00=FM works I think)
outbit(0,io); // 19 port ?
outbit(0,io); // 18 port ?
outbit(0,io); // 17 search level
outbit(0,io); // 16 search level
si = 0x8000;
for(bl = 1; bl <= 16 ; bl++) { outbit(data & si,io); si >>=1; }
outb(power,io);
}
static int get_stereo(__u16 io)
{
outb(power,io); udelay(4);
return !(inb(io) & mo_st);
}
static int get_tune(__u16 io)
{
outb(power+clk,io); udelay(4);
return !(inb(io) & mo_st);
}
inline static int radio_function(struct video_device *dev,
unsigned int cmd, void *arg)
{
struct radio_device *card=dev->priv;
switch(cmd) {
case VIDIOCGCAP: {
struct video_capability v;
strcpy(v.name, "Maxi Radio FM2000 radio");
v.type=VID_TYPE_TUNER;
v.channels=v.audios=1;
v.maxwidth=v.maxheight=v.minwidth=v.minheight=0;
if(copy_to_user(arg,&v,sizeof(v)))
return -EFAULT;
return 0;
}
case VIDIOCGTUNER: {
struct video_tuner v;
if(copy_from_user(&v, arg,sizeof(v))!=0)
return -EFAULT;
if(v.tuner)
return -EINVAL;
card->stereo = 0xffff * get_stereo(card->io);
card->tuned = 0xffff * get_tune(card->io);
v.flags = VIDEO_TUNER_LOW | card->stereo;
v.signal = card->tuned;
strcpy(v.name, "FM");
v.rangelow = FREQ_LO;
v.rangehigh = FREQ_HI;
v.mode = VIDEO_MODE_AUTO;
if(copy_to_user(arg,&v, sizeof(v)))
return -EFAULT;
return 0;
}
case VIDIOCSTUNER: {
struct video_tuner v;
if(copy_from_user(&v, arg, sizeof(v)))
return -EFAULT;
if(v.tuner!=0)
return -EINVAL;
return 0;
}
case VIDIOCGFREQ: {
unsigned long tmp=card->freq;
if(copy_to_user(arg, &tmp, sizeof(tmp)))
return -EFAULT;
return 0;
}
case VIDIOCSFREQ: {
unsigned long tmp;
if(copy_from_user(&tmp, arg, sizeof(tmp)))
return -EFAULT;
if ( tmp<FREQ_LO || tmp>FREQ_HI )
return -EINVAL;
card->freq = tmp;
set_freq(card->io, FREQ2BITS(card->freq));
sleep_125ms();
return 0;
}
case VIDIOCGAUDIO: {
struct video_audio v;
strcpy(v.name, "Radio");
v.audio=v.volume=v.bass=v.treble=v.balance=v.step=0;
v.flags=VIDEO_AUDIO_MUTABLE | card->muted;
v.mode=VIDEO_SOUND_STEREO;
if(copy_to_user(arg,&v, sizeof(v)))
return -EFAULT;
return 0;
}
case VIDIOCSAUDIO: {
struct video_audio v;
if(copy_from_user(&v, arg, sizeof(v)))
return -EFAULT;
if(v.audio)
return -EINVAL;
card->muted = v.flags & VIDEO_AUDIO_MUTE;
if(card->muted)
turn_power(card->io, 0);
else
set_freq(card->io, FREQ2BITS(card->freq));
return 0;
}
case VIDIOCGUNIT: {
struct video_unit v;
v.video=VIDEO_NO_UNIT;
v.vbi=VIDEO_NO_UNIT;
v.radio=dev->minor;
v.audio=0;
v.teletext=VIDEO_NO_UNIT;
if(copy_to_user(arg, &v, sizeof(v)))
return -EFAULT;
return 0;
}
default: return -ENOIOCTLCMD;
}
}
static int radio_ioctl(struct video_device *dev, unsigned int cmd, void *arg)
{
struct radio_device *card=dev->priv;
int ret;
down(&card->lock);
ret = radio_function(dev, cmd, arg);
up(&card->lock);
return ret;
}
static int radio_open(struct video_device *dev, int flags)
{
return 0;
}
static void radio_close(struct video_device *dev)
{
}
MODULE_AUTHOR("<NAME>, <EMAIL>");
MODULE_DESCRIPTION("Radio driver for the Guillemot Maxi Radio FM2000 radio.");
MODULE_LICENSE("GPL");
EXPORT_NO_SYMBOLS;
static int __devinit maxiradio_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
{
if(!request_region(pci_resource_start(pdev, 0),
pci_resource_len(pdev, 0), "Maxi Radio FM 2000")) {
printk(KERN_ERR "radio-maxiradio: can't reserve I/O ports\n");
goto err_out;
}
if (pci_enable_device(pdev))
goto err_out_free_region;
radio_unit.io = pci_resource_start(pdev, 0);
init_MUTEX(&radio_unit.lock);
maxiradio_radio.priv = &radio_unit;
if(video_register_device(&maxiradio_radio, VFL_TYPE_RADIO, radio_nr)==-1) {
printk("radio-maxiradio: can't register device!");
goto err_out_free_region;
}
printk(KERN_INFO "radio-maxiradio: version "
DRIVER_VERSION
" time "
__TIME__ " "
__DATE__
"\n");
printk(KERN_INFO "radio-maxiradio: found Guillemot MAXI Radio device (io = 0x%x)\n",
radio_unit.io);
return 0;
err_out_free_region:
release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
err_out:
return -ENODEV;
}
static void __devexit maxiradio_remove_one(struct pci_dev *pdev)
{
video_unregister_device(&maxiradio_radio);
release_region(pci_resource_start(pdev, 0), pci_resource_len(pdev, 0));
}
static struct pci_device_id maxiradio_pci_tbl[] __devinitdata = {
{ PCI_VENDOR_ID_GUILLEMOT, PCI_DEVICE_ID_GUILLEMOT_MAXIRADIO,
PCI_ANY_ID, PCI_ANY_ID, },
{ 0,}
};
MODULE_DEVICE_TABLE(pci, maxiradio_pci_tbl);
static struct pci_driver maxiradio_driver = {
name: "radio-maxiradio",
id_table: maxiradio_pci_tbl,
probe: maxiradio_init_one,
remove: __devexit_p(maxiradio_remove_one),
};
int __init maxiradio_radio_init(void)
{
return pci_module_init(&maxiradio_driver);
}
void __exit maxiradio_radio_exit(void)
{
pci_unregister_driver(&maxiradio_driver);
}
module_init(maxiradio_radio_init);
module_exit(maxiradio_radio_exit);
|
soyemi/ProjRigel | Rigel/legacy/rggui/source/rg_gui_component.cpp | #include "rggui.h"
#include "rg_gui_component.h"
namespace rg {
void RgGUIMenuItemList::AddMenuItem(const RgGUIMenuItem & item)
{
subitems.push_back(item);
}
void RgGUIWindow::focused()
{
RgLogD() << "guiwin focused " << winid;
}
void RgGUIWindow::lost_focuse()
{
RgLogD() << "gui lost focuse" << winid;
}
RgGUIWindow::RgGUIWindow()
{
static long id = 0;
id++;
winid = id;
}
}
|
percevalm/aumyproject | Lib/site-packages/openpyxl/cell/__init__.py | <filename>Lib/site-packages/openpyxl/cell/__init__.py
from __future__ import absolute_import
# Copyright (c) 2010-2017 openpyxl
from .cell import Cell, WriteOnlyCell
from .read_only import ReadOnlyCell
|
cxd9257/yiman | app/src/main/java/com/demo/yiman/widget/RadarView.java | package com.demo.yiman.widget;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Path;
import android.support.annotation.Nullable;
import android.util.AttributeSet;
import android.view.View;
import com.demo.yiman.R;
import java.util.List;
public class RadarView extends View {
//布局的宽度
private int mWidth;
//布局的高度
private int mHeight;
//最大半径
private float mRadius;
//默认个数
private int mCount = 0;
//角度
private double mAngle;
//雷达网路径
private Path mRadarPath = new Path();
//连接线路径
private Path mLinePath = new Path();
//覆盖层路径
private Path mLayerPath = new Path();
//雷达画笔
private Paint mRadarPaint;
//文本画笔
private Paint mTextPaint;
//覆盖层画笔
private Paint mLayerPaint;
//连接线画笔
private Paint mLinePaint;
//圆点画笔
private Paint mCirclePaint;
//雷达网数
private int mNum;
//雷达网络线的颜色
private int mRadarGridColor;
//雷达网络线线宽
private int mRadarGridWidth;
//连接线的颜色
private int radarLineColor;
//连接线线宽
private int radarLineStrokeWidth;
//小圆点的颜色
private int circleColor;
//小圆点的大小
private int circleWidth;
//覆盖图层的颜色
private int layerColor;
//文本颜色
private int textColor;
//文本颜色
private int textSize;
//数据源
private List<RadarData> mData;
//百分比
private double mMaxValue = 100.0d;
public RadarView(Context context) {
this(context,null);
}
public RadarView(Context context, AttributeSet attrs){
this(context,attrs,0);
}
public RadarView(Context context, AttributeSet attrs,int defStyleAttr){
super(context,attrs,defStyleAttr);
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.RadarView,defStyleAttr,0);
mRadarGridColor = a.getColor(R.styleable.RadarView_radarGridColor,context.getResources().getColor(R.color.radarGridColor));
mNum = a.getInteger(R.styleable.RadarView_num, context.getResources().getInteger(R.integer.num));
circleColor = a.getColor(R.styleable.RadarView_circleColor, context.getResources().getColor(R.color.circleColor));
circleWidth = a.getDimensionPixelSize(R.styleable.RadarView_circleWidth, (int) context.getResources().getDimension(R.dimen.circleWidth));
mRadarGridWidth = a.getDimensionPixelSize(R.styleable.RadarView_radarGridStrokeWidth, (int) context.getResources().getDimension(R.dimen.radarGridWidth));
radarLineColor = a.getColor(R.styleable.RadarView_radarLineColor, context.getResources().getColor(R.color.radarLineColor));
radarLineStrokeWidth = a.getDimensionPixelSize(R.styleable.RadarView_radarLineStrokeWidth, (int) context.getResources().getDimension(R.dimen.radarLineStrokeWidth));
layerColor = a.getColor(R.styleable.RadarView_layerColor, context.getResources().getColor(R.color.layerColor));
textColor = a.getColor(R.styleable.RadarView_android_textColor, context.getResources().getColor(R.color.radarTextColor));
textSize = a.getDimensionPixelSize(R.styleable.RadarView_android_textSize, (int) context.getResources().getDimension(R.dimen.radarTextSize));
a.recycle();
}
@Override
protected void onFinishInflate() {
super.onFinishInflate();
initView();
}
private void initView() {
mRadarPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mRadarPaint.setStyle(Paint.Style.STROKE);
mRadarPaint.setColor(mRadarGridColor);
mRadarPaint.setStrokeWidth(mRadarGridWidth);
mLinePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mLinePaint.setStyle(Paint.Style.STROKE);
mLinePaint.setColor(radarLineColor);
mLinePaint.setStrokeWidth(radarLineStrokeWidth);
mCirclePaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mCirclePaint.setStyle(Paint.Style.FILL);
mCirclePaint.setColor(circleColor);
mCirclePaint.setStrokeWidth(circleWidth);
mTextPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mTextPaint.setStyle(Paint.Style.FILL);
mTextPaint.setColor(textColor);
mTextPaint.setTextSize(textSize);
mLayerPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mLayerPaint.setStyle(Paint.Style.FILL_AND_STROKE);
mLayerPaint.setColor(layerColor);
mLayerPaint.setAlpha(128);
}
@Override
protected void onSizeChanged(int w, int h, int oldw, int oldh) {
super.onSizeChanged(w, h, oldw, oldh);
mWidth = w;
mHeight = h;
mRadius = (float) (Math.min(w, h) / 2 * 0.8);
}
/**
* 绑定数据
*
* @param data
* @param maxValue
*/
public void setData(List<RadarData> data, double maxValue) {
if (data == null || data.size() < 3) {
throw new RuntimeException("The number of data can not be less than 3");
} else {
this.mData = data;
this.mMaxValue = maxValue;
this.mCount = mData.size();
this.mAngle = Math.PI * 2 / mCount;
invalidate();
}
}
public void setNum(int num){
this.mNum = num;
invalidate();
}
@Override
protected void onDraw(Canvas canvas) {
super.onDraw(canvas);
canvas.translate(mWidth / 2, mHeight / 2);
drawRadarBg(canvas);
drawText(canvas);
drawLayer(canvas);
}
/**
* 绘制覆盖图层
*
* @param canvas
*/
private void drawLayer(Canvas canvas) {
for (int i = 0; i < mCount; i++) {
double percent = mData.get(i).getPercent() / mMaxValue;
float x = (float) (mRadius * Math.sin(mAngle / 2 + mAngle * i) * percent);
float y = (float) (mRadius * Math.cos(mAngle / 2 + mAngle * i) * percent);
if (i == 0) {
mLayerPath.moveTo(x, y);
} else {
mLayerPath.lineTo(x, y);
}
//画小圆点
canvas.drawCircle(x, y, circleWidth, mCirclePaint);
}
mLayerPath.close();
canvas.drawPath(mLayerPath, mLayerPaint);
}
/**
* 绘制文本内容
*
* @param canvas
*/
private void drawText(Canvas canvas) {
Paint.FontMetrics fontMetrics = mTextPaint.getFontMetrics();
float fontHeight = fontMetrics.descent - fontMetrics.ascent;
for (int i = 0; i < mCount; i++) {
float x = (float) ((mRadius + fontHeight / 2) * Math.sin(mAngle / 2 + mAngle * i));
float y = (float) ((mRadius + fontHeight / 2) * Math.cos(mAngle / 2 + mAngle * i));
String text = mData.get(i).getTitle();
float fontWidth = mTextPaint.measureText(text);
canvas.drawText(text, x - fontWidth / 2, y, mTextPaint);
}
}
/**
* 绘制雷达网格
*
* @param canvas
*/
private void drawRadarBg(Canvas canvas) {
//雷达网格间距
float mSpc = mRadius / (mNum - 1);
for (int i = 1; i < mNum; i++) {
//计算当前半径
float curRadius = mSpc * i;
for (int j = 0; j < mCount; j++) {
//根据半径，计算出每个点的坐标
float x = (float) (curRadius * Math.sin(mAngle / 2 + mAngle * j));
float y = (float) (curRadius * Math.cos(mAngle / 2 + mAngle * j));
if (j == 0) {
mRadarPath.moveTo(x, y);
} else {
mRadarPath.lineTo(x, y);
}
//绘制最后一环时绘制连线
drawLine(canvas, i, x, y);
}
mRadarPath.close();
canvas.drawPath(mRadarPath, mRadarPaint);
}
}
/**
* 绘制连接线
*
* @param canvas
* @param x
* @param y
*/
private void drawLine(Canvas canvas, int i, float x, float y) {
if (i == mNum - 1) {
mLinePath.reset();
mLinePath.moveTo(0, 0);
mLinePath.lineTo(x, y);
canvas.drawPath(mLinePath, mLinePaint);
}
}
}
|
GosthMan/AuShadha | src/AuShadha/visit/visit/models.py | ################################################################################
# Project : AuShadha
# Description : Models for AuShadha OPD Visits.
# Author : Dr. <NAME>
# Date : 17-09-2013
# LICENSE : GNU-GPL Version 3, Please see AuShadha/LICENSE.txt
################################################################################
# General Imports
from datetime import datetime, date, time
import importlib
# Django Specific Imports
from django.db import models
from django.forms import ModelForm, ModelChoiceField, Textarea, TextInput
# Application model imports
from AuShadha.apps.ui.ui import ui as UI
from AuShadha.apps.aushadha_base_models.models import AuShadhaBaseModel,AuShadhaBaseModelForm
from AuShadha.apps.clinic.models import Clinic, Staff
from registry.inv_and_imaging.models import ImagingInvestigationRegistry, LabInvestigationRegistry
#from patient.models import PatientDetail
#from admission.models import AdmissionDetail
PatientDetail = UI.get_module("PatientRegistration")
#AdmissionDetail = UI.get_module("Admission")
VisitComplaint = UI.get_module('OPD_Visit_Complaint')
from dijit_fields_constants import VISIT_DETAIL_FORM_CONSTANTS
DEFAULT_VISIT_DETAIL_FORM_EXCLUDES = ('patient_detail','op_surgeon')
CONSULT_NATURE_CHOICES = (
('initial', 'Initial'),
('fu', 'Follow-Up'),
('emer', 'Emergency'),
)
CONSULT_BOOKING_CATEGORY_CHOICES = (
('appointment', "Appointment"),
('telephonic', 'Telephonic / Web'),
('na', 'Walk-in / Emergency'),
('referral', 'Referral'),
('starred', 'Starred'),
)
CONSULT_REASON_CHOICES = (
('opd_consult', "OPD Consult"),
('inv_review',"Investigations Review"),
('emergency',"Emergency"),
('pre_op',"Pre-op Counselling"),
('post_op',"Post-op Counselling"),
('dressing',"Dressing"),
('minor_opd_procedures',"Minor OPD Procedures"),
('prescription_top_up',"Prescription Top Up"),
('admission',"Admission"),
('others',"Others"),
)
CONSULT_STATUS_CHOICES = (
('waiting', 'Waiting'),
('examining', 'Examining'),
('review_awaited', 'Review Awaited'),
('admission', 'Admission'),
('discharged', 'Discharged'),
('no_show', 'No Show'),
)
class VisitDetail(AuShadhaBaseModel):
def __init__(self, *args, **kwargs):
super(VisitDetail,self).__init__(*args, **kwargs)
self.__model_label__ = "visit"
self._parent_model = 'patient_detail'
self._can_add_list_or_json = ['visit_complaint',
'visit_follow_up',
'visit_ros',
'visit_hpi',
'visit_phyexam',
'vitals',
'gen',
'sys',
'neuro',
'vasc',
'visit_assessment_and_plan',
'visit_soap',
#'past_history',
#'visit_inv',
#'visit_imaging',
#'visit_procedures',
#'discharge'
]
self._extra_url_actions = ['close','change_nature']
patient_detail = models.ForeignKey(PatientDetail)
visit_date = models.DateTimeField(auto_now=False, default=datetime.now())
op_surgeon = models.ForeignKey(Staff,editable=False,null=True,blank=True)
referring_doctor = models.CharField(max_length=30,
default="Self"
) # Should be an FK to referring doctors model / Contacts
consult_nature = models.CharField(max_length=30,
choices=CONSULT_NATURE_CHOICES
) # Should be an FK to appointment model
booking_category = models.CharField(max_length=30,
choices=CONSULT_BOOKING_CATEGORY_CHOICES
) # Should ideally be an FK to appointment model
consult_reason = models.CharField(max_length=30,
choices=CONSULT_REASON_CHOICES
) # Should be an FK to appointment model
status = models.CharField(max_length=30,
choices=CONSULT_STATUS_CHOICES
) # Should update via FK the appointment model
is_active = models.BooleanField(default=True, editable=False)
remarks = models.TextField(max_length=200,
default="NAD",
help_text="limit to 200 words"
)
class Meta:
verbose_name = "Visit Details"
verbose_name_plural = "Visit Details"
def __unicode__(self):
return '%s(%s): %s: %s' % (self.patient_detail,
self.id,
self.visit_date,
self.op_surgeon
)
def get_absolute_url(self):
return '/AuShadha/visit/detail/%d/' % (self.id)
def get_all_patient_complaints_url(self):
return '/AuShadha/visit_complaints/complaint/get/%s/' %(self.id)
def import_active_complaints_url(self):
return '/AuShadha/visit_complaints/complaint/import_active_complaints/%s/' %(self.id)
def get_all_visit_hpi_url(self):
return '/AuShadha/visit_hpi/hpi/get_all_visit_hpi/%s/' %(self.id)
def get_all_visit_ros_url(self):
return '/AuShadha/visit_ros/ros/get_all_visit_ros/%s/' %(self.id)
def get_edit_pane_header_url(self):
return '/AuShadha/visit/get/visit_detail/edit_pane_header/%s/' %(self.id)
def get_visit_detail_close_url(self):
if self.is_active:
return '/AuShadha/visit/visit/detail/close/%d/' % (self.id)
else:
raise Exception("Visit is already not active. Cannot Close")
def get_visit_detail_visit_follow_up_add_url(self):
# if self.patient_detail.has_active_visit():
# return self.patient_detail.get_patient_visit_add_url()
# else:
# return False
return '/AuShadha/visit/follow_up/add/?visit_id=%s' % (self.id)
def get_visit_phyexam_add_vitals_url(self):
return '/AuShadha/visit_phyexam/vitals/add/%s/' %(self.id)
def get_visit_phyexam_add_gen_url(self):
return '/AuShadha/visit_phyexam/gen/add/%s/' %(self.id)
def get_visit_phyexam_add_sys_url(self):
return '/AuShadha/visit_phyexam/sys/add/%s/' %(self.id)
def get_visit_phyexam_add_neuro_url(self):
return '/AuShadha/visit_phyexam/neuro/add/%s/' %(self.id)
def get_visit_phyexam_add_vasc_url(self):
return '/AuShadha/visit_phyexam/vasc/add/%s/' %(self.id)
def has_fu_visits(self):
id = self.id
try:
visit_obj = VisitDetail.objects.get(pk=id)
fu = VisitFollowUp.objects.filter(visit_detail=visit_obj).order_by('-visit_date')
if fu:
return fu
else:
return None
except(VisitDetail.DoesNotExist):
raise Exception("Not Visit Detail with ID:", str(id))
def visit_nature(self):
return unicode(self.consult_nature)
def visit_nature_change(self, nature):
try:
self.consult_nature = unicode(nature)
except (TypeError, NameError, ValueError):
print "ERROR:: Invalid CONSULT_NATURE_CHOICE supplied.."
return False
if consult_nature in ['initial', 'fu','emer']:
self.save()
return unicode(self.consult_nature)
else:
print "ERROR:: Invalid Consult Nature Change Requested.."
return False
def visit_status(self):
return unicode(self.status)
def visit_status_change(self, status):
try:
self.status = unicode(status)
except (TypeError, NameError, ValueError):
print "ERROR:: Invalid CONSULT_STATUS_CHOICES supplied.."
return False
if status in ['discharged', 'admission', 'review_awaited']:
if self.status == 'discharged' or \
self.status == 'admission':
self._close_visit()
else:
self.is_active = True
self.save()
return unicode(self.status)
else:
print "ERROR:: Invalid Consult Status Change Requested.."
return False
def _close_visit(self):
#id = self.id
#visit_obj = VisitDetail.objects.get(pk = id)
#visit_followup = VisitFollowUp.objects.filter(visit_detail = visit_obj)
# if visit_followup:
# for fu in visit_followup:
#fu.status = 'discharged'
# fu.save()
print "Trying to Close a visit with ID"
print self.id
self.is_active = False
kwargs = {'dont_check_status': "yes"}
self.save(**kwargs)
def _close_all_active_visits(self):
pat_obj = self.patient_detail
visit_obj = VisitDetail.objects.filter(
patient_detail=pat_obj).filter(is_active=True)
if visit_obj:
for visit in visit_obj:
visit._close_visit()
return True
else:
return False
def save(self, *args, **kwargs):
# if self.op_surgeon.clinic_staff_role == 'doctor':
consult_nature = self.consult_nature
print "Calling save method with args"
print "kwargs dont_check_status is set to: ", kwargs.get('dont_check_status')
if self.pk is not None:
if kwargs.get('dont_check_status') is 'yes':
kwargs = kwargs.pop('dont_check_status')
self.status = 'discharged'
self.is_active = False
print "Closing the visit and saving the changes"
else:
if self.status == 'no_show' or self.status == 'discharged' or self.status == 'admission':
self.is_active = False
super(VisitDetail, self).save(force_update=True)
else:
# if not self.patient_detail.has_active_visit():
#self.consult_nature = 'initial'
self.is_active = True
super(VisitDetail, self).save(*args, **kwargs)
# else:
#raise Exception("User is not a Provider. Only Doctors can save Visits. ")
def get_visit_complaints(self):
import json
v_id = self.id
try:
visit_obj = VisitDetail.objects.get(pk=v_id)
pat_obj = visit_obj.patient_detail
except(TypeError, AttributeError, NameError):
raise Exception("Invalid ID. Raised Error")
except(VisitDetail.DoesNotExist):
raise Exception("Invalid Visit. No Such Visit recorded")
#visit_fu = VisitFollowUp.objects.filter(visit_detail = visit_obj)
visit_complaints = VisitComplaint.objects.filter(visit_detail=visit_obj)
visit_complaint_list = []
if visit_complaints:
for complaint in visit_complaints:
dict_to_append = {}
dict_to_append['complaint'] = complaint.complaint
dict_to_append['duration'] = complaint.duration
dict_to_append['visit_date'] = complaint.visit_detail.visit_date.date().isoformat()
dict_to_append['visit_active'] = complaint.visit_detail.is_active
visit_complaint_list.append(dict_to_append)
#jsondata = json.dumps(visit_complaint_list)
# return json
return visit_complaint_list
def has_previous_visits(self):
try:
visit_id = self.id
except AttributeError:
raise Exception("Invalid Visit Id: Null")
visit_detail_obj = VisitDetail.objects.get(pk = int(visit_id) )
patient_detail_obj = visit_detail_obj.patient_detail
all_visits = VisitDetail.objects.get(patient_detail = patient_detail_obj).order_by('visit_date')
for v in all_visits:
if (v.visit_date <= visit_detail_obj.visit_date) and (v != visit_detail_obj):
return True
else:
continue
class VisitDetailForm(AuShadhaBaseModelForm):
# op_surgeon = ModelChoiceField(queryset=Staff.objects.filter(clinic_staff_role='doctor'))
dijit_fields = VISIT_DETAIL_FORM_CONSTANTS
def __init__(self, *args, **kwargs):
self.__form_name__ = "Visit Detail Form"
super(VisitDetailForm,self).__init__(*args,**kwargs)
class Meta:
model = VisitDetail
exclude = DEFAULT_VISIT_DETAIL_FORM_EXCLUDES
|
GlebBondarchuk/SED | sed/sed-web/src/test/java/com/bsu/sed/common/AbstractMockMvcIntegrationTest.java | package com.bsu.sed.common;
import com.bsu.sed.model.Role;
import org.junit.Before;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.mock.web.MockHttpSession;
import org.springframework.security.web.FilterChainProxy;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.request.MockHttpServletRequestBuilder;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.context.WebApplicationContext;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
/**
* Basic configuration for running mockmvc integration tests.
*
* @author gbondarchuk
*/
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
//@DirtiesContext
@ContextConfiguration(locations = {
"/spring/test-web-context.xml"
})
@Transactional
public abstract class AbstractMockMvcIntegrationTest {
@Autowired
private FilterChainProxy springSecurityFilterChain;
@Autowired
private WebApplicationContext wac;
protected MockMvc mockMvc;
@Before
public void setup() {
this.mockMvc = MockMvcBuilders.webAppContextSetup(this.wac)
.addFilter(springSecurityFilterChain)
.alwaysDo(print())
.build();
}
protected MockHttpServletRequestBuilder secureGet(String url, Role role) throws Exception {
String login = getLoginByRole(role);
ResultActions result = mockMvc.perform(post("/j_spring_security_check")
.param("j_username", login)
.param("j_password", login))
.andExpect(status().isFound());
MockHttpSession session = (MockHttpSession) result.andReturn().getRequest().getSession();
return MockMvcRequestBuilders.get(url).session(session);
}
private String getLoginByRole(Role role) {
switch (role.name()) {
case "ADMIN":
return "admin";
case "TEACHER":
return "teacher";
case "STUDENT":
return "student";
default:
throw new IllegalArgumentException("Role not found");
}
}
}
|
yoheiueda/notary | tuf/tuf_test.go | package tuf
import (
"crypto/sha256"
"encoding/json"
"io/ioutil"
"os"
"path"
"path/filepath"
"testing"
"time"
"github.com/stretchr/testify/require"
"github.com/theupdateframework/notary/cryptoservice"
"github.com/theupdateframework/notary/passphrase"
"github.com/theupdateframework/notary/trustmanager"
"github.com/theupdateframework/notary/tuf/data"
"github.com/theupdateframework/notary/tuf/signed"
"github.com/theupdateframework/notary/tuf/utils"
)
var testGUN data.GUN = "gun"
func initRepo(t *testing.T, cryptoService signed.CryptoService) *Repo {
rootKey, err := cryptoService.Create("root", testGUN, data.ED25519Key)
require.NoError(t, err)
return initRepoWithRoot(t, cryptoService, rootKey)
}
func initRepoWithRoot(t *testing.T, cryptoService signed.CryptoService, rootKey data.PublicKey) *Repo {
targetsKey, err := cryptoService.Create("targets", testGUN, data.ED25519Key)
require.NoError(t, err)
snapshotKey, err := cryptoService.Create("snapshot", testGUN, data.ED25519Key)
require.NoError(t, err)
timestampKey, err := cryptoService.Create("timestamp", testGUN, data.ED25519Key)
require.NoError(t, err)
rootRole := data.NewBaseRole(
data.CanonicalRootRole,
1,
rootKey,
)
targetsRole := data.NewBaseRole(
data.CanonicalTargetsRole,
1,
targetsKey,
)
snapshotRole := data.NewBaseRole(
data.CanonicalSnapshotRole,
1,
snapshotKey,
)
timestampRole := data.NewBaseRole(
data.CanonicalTimestampRole,
1,
timestampKey,
)
repo := NewRepo(cryptoService)
err = repo.InitRoot(rootRole, timestampRole, snapshotRole, targetsRole, false)
require.NoError(t, err)
_, err = repo.InitTargets(data.CanonicalTargetsRole)
require.NoError(t, err)
err = repo.InitSnapshot()
require.NoError(t, err)
err = repo.InitTimestamp()
require.NoError(t, err)
return repo
}
func TestInitSnapshotNoTargets(t *testing.T) {
cs := signed.NewEd25519()
repo := initRepo(t, cs)
repo.Targets = make(map[data.RoleName]*data.SignedTargets)
err := repo.InitSnapshot()
require.Error(t, err)
require.IsType(t, ErrNotLoaded{}, err)
}
func writeRepo(t *testing.T, dir string, repo *Repo) {
err := os.MkdirAll(dir, 0755)
require.NoError(t, err)
signedRoot, err := repo.SignRoot(data.DefaultExpires("root"), nil)
require.NoError(t, err)
rootJSON, _ := json.Marshal(signedRoot)
ioutil.WriteFile(dir+"/root.json", rootJSON, 0755)
for r := range repo.Targets {
signedTargets, err := repo.SignTargets(r, data.DefaultExpires("targets"))
require.NoError(t, err)
targetsJSON, _ := json.Marshal(signedTargets)
p := path.Join(dir, r.String()+".json")
parentDir := filepath.Dir(p)
os.MkdirAll(parentDir, 0755)
ioutil.WriteFile(p, targetsJSON, 0755)
}
signedSnapshot, err := repo.SignSnapshot(data.DefaultExpires("snapshot"))
require.NoError(t, err)
snapshotJSON, _ := json.Marshal(signedSnapshot)
ioutil.WriteFile(dir+"/snapshot.json", snapshotJSON, 0755)
signedTimestamp, err := repo.SignTimestamp(data.DefaultExpires("timestamp"))
require.NoError(t, err)
timestampJSON, _ := json.Marshal(signedTimestamp)
ioutil.WriteFile(dir+"/timestamp.json", timestampJSON, 0755)
}
func TestInitRepo(t *testing.T) {
testDir, err := ioutil.TempDir("", "testdir")
require.NoError(t, err)
defer os.RemoveAll(testDir)
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
writeRepo(t, testDir, repo)
// after signing a new repo, there are only 4 roles: the 4 base roles
require.Len(t, repo.Root.Signed.Roles, 4)
// can't use getBaseRole because it's not a valid real role
_, err = repo.Root.BuildBaseRole("root.1")
require.Error(t, err)
}
func TestUpdateDelegations(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{"test"}, []string{}, false)
require.NoError(t, err)
// no empty metadata is created for this role
_, ok := repo.Targets["targets/test"]
require.False(t, ok, "no empty targets file should be created for deepest delegation")
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 1)
require.Len(t, r.Signed.Delegations.Keys, 1)
keyIDs := r.Signed.Delegations.Roles[0].KeyIDs
require.Len(t, keyIDs, 1)
require.Equal(t, testKey.ID(), keyIDs[0])
testDeepKey, err := ed25519.Create("targets/test/deep", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test/deep", []data.PublicKey{testDeepKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test/deep", []string{"test/deep"}, []string{}, false)
require.NoError(t, err)
// this metadata didn't exist before, but creating targets/test/deep created
// the targets/test metadata
r, ok = repo.Targets["targets/test"]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 1)
require.Len(t, r.Signed.Delegations.Keys, 1)
keyIDs = r.Signed.Delegations.Roles[0].KeyIDs
require.Len(t, keyIDs, 1)
require.Equal(t, testDeepKey.ID(), keyIDs[0])
require.True(t, r.Dirty)
// no empty delegation metadata is created for targets/test/deep
_, ok = repo.Targets["targets/test/deep"]
require.False(t, ok, "no empty targets file should be created for deepest delegation")
}
func TestPurgeDelegationsKeyFromTop(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
vetinari := data.RoleName(path.Join(data.CanonicalTargetsRole.String(), "vetinari"))
sybil := data.RoleName(path.Join(data.CanonicalTargetsRole.String(), "sybil"))
vimes := data.RoleName(path.Join(data.CanonicalTargetsRole.String(), "vimes"))
carrot := data.RoleName(path.Join(vimes.String(), "carrot"))
targetsWild := data.RoleName(path.Join(data.CanonicalTargetsRole.String(), "*"))
// create 2 keys, we'll purge one of them
testKey1, err := ed25519.Create(vetinari, testGUN, data.ED25519Key)
require.NoError(t, err)
testKey2, err := ed25519.Create(vetinari, testGUN, data.ED25519Key)
require.NoError(t, err)
// create some delegations
err = repo.UpdateDelegationKeys(vetinari, []data.PublicKey{testKey1, testKey2}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths(vetinari, []string{""}, []string{}, false)
require.NoError(t, err)
err = repo.UpdateDelegationKeys(sybil, []data.PublicKey{testKey1}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths(sybil, []string{""}, []string{}, false)
require.NoError(t, err)
err = repo.UpdateDelegationKeys(vimes, []data.PublicKey{testKey2}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths(vimes, []string{""}, []string{}, false)
require.NoError(t, err)
err = repo.UpdateDelegationKeys(carrot, []data.PublicKey{testKey1}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths(carrot, []string{""}, []string{}, false)
require.NoError(t, err)
id1, err := utils.CanonicalKeyID(testKey1)
require.NoError(t, err)
err = repo.PurgeDelegationKeys(targetsWild, []string{id1})
require.NoError(t, err)
role, err := repo.GetDelegationRole(vetinari)
require.NoError(t, err)
require.Len(t, role.Keys, 1)
_, ok := role.Keys[testKey2.ID()]
require.True(t, ok)
role, err = repo.GetDelegationRole(sybil)
require.NoError(t, err)
require.Len(t, role.Keys, 0)
role, err = repo.GetDelegationRole(vimes)
require.NoError(t, err)
require.Len(t, role.Keys, 1)
_, ok = role.Keys[testKey2.ID()]
require.True(t, ok)
role, err = repo.GetDelegationRole(carrot)
require.NoError(t, err)
require.Len(t, role.Keys, 0)
// we know id1 was successfully purged, try purging again and make sure it doesn't error
err = repo.PurgeDelegationKeys(targetsWild, []string{id1})
require.NoError(t, err)
}
func TestPurgeDelegationsKeyFromDeep(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
vetinari := data.RoleName(path.Join(data.CanonicalTargetsRole.String(), "vetinari"))
sybil := data.RoleName(path.Join(data.CanonicalTargetsRole.String(), "sybil"))
vimes := data.RoleName(path.Join(data.CanonicalTargetsRole.String(), "vimes"))
carrot := data.RoleName(path.Join(vimes.String(), "carrot"))
vimesWild := data.RoleName(path.Join(vimes.String(), "*"))
// create 2 keys, we'll purge one of them
testKey1, err := ed25519.Create(vetinari, testGUN, data.ED25519Key)
require.NoError(t, err)
testKey2, err := ed25519.Create(vetinari, testGUN, data.ED25519Key)
require.NoError(t, err)
// create some delegations
err = repo.UpdateDelegationKeys(vetinari, []data.PublicKey{testKey1, testKey2}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths(vetinari, []string{""}, []string{}, false)
require.NoError(t, err)
err = repo.UpdateDelegationKeys(sybil, []data.PublicKey{testKey1}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths(sybil, []string{""}, []string{}, false)
require.NoError(t, err)
err = repo.UpdateDelegationKeys(vimes, []data.PublicKey{testKey2}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths(vimes, []string{""}, []string{}, false)
require.NoError(t, err)
err = repo.UpdateDelegationKeys(carrot, []data.PublicKey{testKey1}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths(carrot, []string{""}, []string{}, false)
require.NoError(t, err)
id1, err := utils.CanonicalKeyID(testKey1)
require.NoError(t, err)
err = repo.PurgeDelegationKeys(vimesWild, []string{id1})
require.NoError(t, err)
role, err := repo.GetDelegationRole(vetinari)
require.NoError(t, err)
require.Len(t, role.Keys, 2)
_, ok := role.Keys[testKey1.ID()]
require.True(t, ok)
_, ok = role.Keys[testKey2.ID()]
require.True(t, ok)
role, err = repo.GetDelegationRole(sybil)
require.NoError(t, err)
require.Len(t, role.Keys, 1)
_, ok = role.Keys[testKey1.ID()]
require.True(t, ok)
role, err = repo.GetDelegationRole(vimes)
require.NoError(t, err)
require.Len(t, role.Keys, 1)
_, ok = role.Keys[testKey2.ID()]
require.True(t, ok)
role, err = repo.GetDelegationRole(carrot)
require.NoError(t, err)
require.Len(t, role.Keys, 0)
}
func TestPurgeDelegationsKeyBadWildRole(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
err := repo.PurgeDelegationKeys("targets/foo", nil)
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
func TestUpdateDelegationsParentMissing(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testDeepKey, err := ed25519.Create("targets/test/deep", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test/deep", []data.PublicKey{testDeepKey}, []string{}, 1)
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 0)
// no delegation metadata created for non-existent parent
_, ok = repo.Targets["targets/test"]
require.False(t, ok, "no targets file should be created for nonexistent parent delegation")
}
// Updating delegations needs to modify the parent of the role being updated.
// If there is no signing key for that parent, the delegation cannot be added.
func TestUpdateDelegationsMissingParentKey(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
// remove the target key (all keys)
repo.cryptoService = signed.NewEd25519()
roleKey, err := ed25519.Create("Invalid Role", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/role", []data.PublicKey{roleKey}, []string{}, 1)
require.Error(t, err)
require.IsType(t, signed.ErrNoKeys{}, err)
// no empty delegation metadata created for new delegation
_, ok := repo.Targets["targets/role"]
require.False(t, ok, "no targets file should be created for empty delegation")
}
func TestUpdateDelegationsInvalidRole(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
roleKey, err := ed25519.Create("Invalid Role", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys(data.CanonicalRootRole, []data.PublicKey{roleKey}, []string{}, 1)
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 0)
// no delegation metadata created for invalid delegation
_, ok = repo.Targets["root"]
require.False(t, ok, "no targets file should be created since delegation failed")
}
// A delegation can be created with a role that is missing a signing key, so
// long as UpdateDelegations is called with the key
func TestUpdateDelegationsRoleThatIsMissingDelegationKey(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
roleKey, err := ed25519.Create("Invalid Role", testGUN, data.ED25519Key)
require.NoError(t, err)
// key should get added to role as part of updating the delegation
err = repo.UpdateDelegationKeys("targets/role", []data.PublicKey{roleKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/role", []string{""}, []string{}, false)
require.NoError(t, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 1)
require.Len(t, r.Signed.Delegations.Keys, 1)
keyIDs := r.Signed.Delegations.Roles[0].KeyIDs
require.Len(t, keyIDs, 1)
require.Equal(t, roleKey.ID(), keyIDs[0])
require.True(t, r.Dirty)
// no empty delegation metadata created for new delegation
_, ok = repo.Targets["targets/role"]
require.False(t, ok, "no targets file should be created for empty delegation")
}
func TestUpdateDelegationsNotEnoughKeys(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
roleKey, err := ed25519.Create("Invalid Role", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/role", []data.PublicKey{roleKey}, []string{}, 2)
require.NoError(t, err)
// no delegation metadata created for failed delegation
_, ok := repo.Targets["targets/role"]
require.False(t, ok, "no targets file should be created since delegation failed")
}
func TestUpdateDelegationsAddKeyToRole(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{"test"}, []string{}, false)
require.NoError(t, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 1)
require.Len(t, r.Signed.Delegations.Keys, 1)
keyIDs := r.Signed.Delegations.Roles[0].KeyIDs
require.Len(t, keyIDs, 1)
require.Equal(t, testKey.ID(), keyIDs[0])
testKey2, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey2}, []string{}, 1)
require.NoError(t, err)
r, ok = repo.Targets["targets"]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 1)
require.Len(t, r.Signed.Delegations.Keys, 2)
keyIDs = r.Signed.Delegations.Roles[0].KeyIDs
require.Len(t, keyIDs, 2)
// it does an append so the order is deterministic (but not meaningful to TUF)
require.Equal(t, testKey.ID(), keyIDs[0])
require.Equal(t, testKey2.ID(), keyIDs[1])
require.True(t, r.Dirty)
}
func TestDeleteDelegations(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{"test"}, []string{}, false)
require.NoError(t, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 1)
require.Len(t, r.Signed.Delegations.Keys, 1)
keyIDs := r.Signed.Delegations.Roles[0].KeyIDs
require.Len(t, keyIDs, 1)
require.Equal(t, testKey.ID(), keyIDs[0])
// ensure that the metadata is there and snapshot is there
targets, err := repo.InitTargets("targets/test")
require.NoError(t, err)
targetsSigned, err := targets.ToSigned()
require.NoError(t, err)
require.NoError(t, repo.UpdateSnapshot("targets/test", targetsSigned))
_, ok = repo.Snapshot.Signed.Meta["targets/test"]
require.True(t, ok)
require.NoError(t, repo.DeleteDelegation("targets/test"))
require.Len(t, r.Signed.Delegations.Roles, 0)
require.Len(t, r.Signed.Delegations.Keys, 0)
require.True(t, r.Dirty)
// metadata should be deleted
_, ok = repo.Targets["targets/test"]
require.False(t, ok)
_, ok = repo.Snapshot.Signed.Meta["targets/test"]
require.False(t, ok)
}
func TestDeleteDelegationsRoleNotExistBecauseNoParentMeta(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{"test"}, []string{}, false)
require.NoError(t, err)
// no empty delegation metadata created for new delegation
_, ok := repo.Targets["targets/test"]
require.False(t, ok, "no targets file should be created for empty delegation")
delRole, err := data.NewRole("targets/test/a", 1, []string{testKey.ID()}, []string{"test"})
require.NoError(t, err)
err = repo.DeleteDelegation(delRole.Name)
require.NoError(t, err)
// still no metadata
_, ok = repo.Targets["targets/test"]
require.False(t, ok)
}
func TestDeleteDelegationsRoleNotExist(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
// initRepo leaves all the roles as Dirty. Set to false
// to test removing a non-existent role doesn't mark
// a role as dirty
repo.Targets[data.CanonicalTargetsRole].Dirty = false
role, err := data.NewRole("targets/test", 1, []string{}, []string{""})
require.NoError(t, err)
err = repo.DeleteDelegation(role.Name)
require.NoError(t, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 0)
require.Len(t, r.Signed.Delegations.Keys, 0)
require.False(t, r.Dirty)
}
func TestDeleteDelegationsInvalidRole(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
// data.NewRole errors if the role isn't a valid TUF role so use one of the non-delegation
// valid roles
invalidRole, err := data.NewRole("root", 1, []string{}, []string{""})
require.NoError(t, err)
err = repo.DeleteDelegation(invalidRole.Name)
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 0)
}
func TestDeleteDelegationsParentMissing(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testRole, err := data.NewRole("targets/test/deep", 1, []string{}, []string{""})
require.NoError(t, err)
err = repo.DeleteDelegation(testRole.Name)
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 0)
}
// Can't delete a delegation if we don't have the parent's signing key
func TestDeleteDelegationsMissingParentSigningKey(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{"test"}, []string{}, false)
require.NoError(t, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 1)
require.Len(t, r.Signed.Delegations.Keys, 1)
keyIDs := r.Signed.Delegations.Roles[0].KeyIDs
require.Len(t, keyIDs, 1)
require.Equal(t, testKey.ID(), keyIDs[0])
// ensure that the metadata is there and snapshot is there
targets, err := repo.InitTargets("targets/test")
require.NoError(t, err)
targetsSigned, err := targets.ToSigned()
require.NoError(t, err)
require.NoError(t, repo.UpdateSnapshot("targets/test", targetsSigned))
_, ok = repo.Snapshot.Signed.Meta["targets/test"]
require.True(t, ok)
// delete all signing keys
repo.cryptoService = signed.NewEd25519()
err = repo.DeleteDelegation("targets/test")
require.Error(t, err)
require.IsType(t, signed.ErrNoKeys{}, err)
require.Len(t, r.Signed.Delegations.Roles, 1)
require.Len(t, r.Signed.Delegations.Keys, 1)
require.True(t, r.Dirty)
// metadata should be here still
_, ok = repo.Targets["targets/test"]
require.True(t, ok)
_, ok = repo.Snapshot.Signed.Meta["targets/test"]
require.True(t, ok)
}
func TestDeleteDelegationsMidSliceRole(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{""}, []string{}, false)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test2", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test2", []string{""}, []string{}, false)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test3", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test3", []string{"test"}, []string{}, false)
require.NoError(t, err)
err = repo.DeleteDelegation("targets/test2")
require.NoError(t, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
require.Len(t, r.Signed.Delegations.Roles, 2)
require.Len(t, r.Signed.Delegations.Keys, 1)
require.True(t, r.Dirty)
}
// If the parent exists, the metadata exists, and the delegation is in it,
// returns the role that was found
func TestGetDelegationRoleAndMetadataExistDelegationExists(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("meh", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/level1", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/level1", []string{""}, []string{}, false)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/level1/level2", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/level1/level2", []string{""}, []string{}, false)
require.NoError(t, err)
gottenRole, err := repo.GetDelegationRole("targets/level1/level2")
require.NoError(t, err)
require.EqualValues(t, "targets/level1/level2", gottenRole.Name)
require.Equal(t, 1, gottenRole.Threshold)
require.Equal(t, []string{""}, gottenRole.Paths)
_, ok := gottenRole.Keys[testKey.ID()]
require.True(t, ok)
}
// If the parent exists, the metadata exists, and the delegation isn't in it,
// returns an ErrNoSuchRole
func TestGetDelegationRoleAndMetadataExistDelegationDoesntExists(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("meh", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/level1", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/level1", []string{""}, []string{}, false)
require.NoError(t, err)
// ensure metadata exists
repo.InitTargets("targets/level1")
_, err = repo.GetDelegationRole("targets/level1/level2")
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
// If the parent exists but the metadata doesn't exist, returns an ErrNoSuchRole
func TestGetDelegationRoleAndMetadataDoesntExists(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("meh", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/level1", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/level1", []string{""}, []string{}, false)
require.NoError(t, err)
// no empty delegation metadata created for new delegation
_, ok := repo.Targets["targets/test"]
require.False(t, ok, "no targets file should be created for empty delegation")
_, err = repo.GetDelegationRole("targets/level1/level2")
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
// If the parent role doesn't exist, GetDelegation fails with an ErrInvalidRole
func TestGetDelegationParentMissing(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
_, err := repo.GetDelegationRole("targets/level1/level2")
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
// Adding targets to a role that exists and has metadata (like targets)
// correctly adds the target
func TestAddTargetsRoleAndMetadataExist(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
hash := sha256.Sum256([]byte{})
f := data.FileMeta{
Length: 1,
Hashes: map[string][]byte{
"sha256": hash[:],
},
}
_, err := repo.AddTargets(data.CanonicalTargetsRole, data.Files{"f": f})
require.NoError(t, err)
r, ok := repo.Targets[data.CanonicalTargetsRole]
require.True(t, ok)
targetsF, ok := r.Signed.Targets["f"]
require.True(t, ok)
require.Equal(t, f, targetsF)
}
// Adding targets to a role that exists and has not metadata first creates the
// metadata and then correctly adds the target
func TestAddTargetsRoleExistsAndMetadataDoesntExist(t *testing.T) {
hash := sha256.Sum256([]byte{})
f := data.FileMeta{
Length: 1,
Hashes: map[string][]byte{
"sha256": hash[:],
},
}
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{""}, []string{}, false)
require.NoError(t, err)
// no empty metadata is created for this role
_, ok := repo.Targets["targets/test"]
require.False(t, ok, "no empty targets file should be created")
// adding the targets to the role should create the metadata though
_, err = repo.AddTargets("targets/test", data.Files{"f": f})
require.NoError(t, err)
r, ok := repo.Targets["targets/test"]
require.True(t, ok)
targetsF, ok := r.Signed.Targets["f"]
require.True(t, ok)
require.Equal(t, f, targetsF)
require.True(t, r.Dirty)
// set it to not dirty so we can assert that if we add the exact same data, it won't be dirty
r.Dirty = false
_, err = repo.AddTargets("targets/test", data.Files{"f": f})
require.NoError(t, err)
require.False(t, r.Dirty)
// If we add the same target but with different metadata, it's dirty again
f2 := f
f2.Length = 2
_, err = repo.AddTargets("targets/test", data.Files{"f": f2})
require.NoError(t, err)
require.True(t, r.Dirty)
}
// Adding targets to a role that doesn't exist fails only if a target was actually added or updated
func TestAddTargetsRoleDoesntExist(t *testing.T) {
hash := sha256.Sum256([]byte{})
f := data.FileMeta{
Length: 1,
Hashes: map[string][]byte{
"sha256": hash[:],
},
}
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
_, err := repo.AddTargets("targets/test", data.Files{"f": f})
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
// Adding targets to a role that we don't have signing keys for fails
func TestAddTargetsNoSigningKeys(t *testing.T) {
hash := sha256.Sum256([]byte{})
f := data.FileMeta{
Length: 1,
Hashes: map[string][]byte{
"sha256": hash[:],
},
}
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{""}, []string{}, false)
require.NoError(t, err)
_, err = repo.AddTargets("targets/test", data.Files{"f": f})
require.NoError(t, err)
// now delete the signing key (all keys)
repo.cryptoService = signed.NewEd25519()
// adding the same exact target to the role should succeed even though the key is missing
_, err = repo.AddTargets("targets/test", data.Files{"f": f})
require.NoError(t, err)
// adding a different target to the role should fail because the keys is missing
_, err = repo.AddTargets("targets/test", data.Files{"t": f})
require.Error(t, err)
require.IsType(t, signed.ErrNoKeys{}, err)
}
// Removing targets from a role that exists, has targets, and is signable
// should succeed, even if we also want to remove targets that don't exist.
func TestRemoveExistingAndNonexistingTargets(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{"test"}, []string{}, false)
require.NoError(t, err)
// no empty metadata is created for this role
_, ok := repo.Targets["targets/test"]
require.False(t, ok, "no empty targets file should be created")
// now remove a target
require.NoError(t, repo.RemoveTargets("targets/test", "f"))
// still no metadata
_, ok = repo.Targets["targets/test"]
require.False(t, ok)
// add a target to remove
hash := sha256.Sum256([]byte{})
_, err = repo.AddTargets("targets/test", data.Files{"test": data.FileMeta{
Length: 1,
Hashes: map[string][]byte{
"sha256": hash[:],
},
}})
require.NoError(t, err)
tgt, ok := repo.Targets["targets/test"]
require.True(t, ok)
require.True(t, tgt.Dirty)
// set this to false so we can prove that removing a non-existing target does not mark as dirty
tgt.Dirty = false
require.NoError(t, repo.RemoveTargets("targets/test", "not_real"))
require.False(t, tgt.Dirty)
require.NotEmpty(t, tgt.Signed.Targets)
require.NoError(t, repo.RemoveTargets("targets/test", "test"))
require.True(t, tgt.Dirty)
require.Empty(t, tgt.Signed.Targets)
}
// Removing targets from a role that doesn't exist fails
func TestRemoveTargetsRoleDoesntExist(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
err := repo.RemoveTargets("targets/test", "f")
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
// Removing targets from a role that we don't have signing keys for fails only if
// a target was actually removed
func TestRemoveTargetsNoSigningKeys(t *testing.T) {
hash := sha256.Sum256([]byte{})
f := data.FileMeta{
Length: 1,
Hashes: map[string][]byte{
"sha256": hash[:],
},
}
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{""}, []string{}, false)
require.NoError(t, err)
// adding the targets to the role should create the metadata though
_, err = repo.AddTargets("targets/test", data.Files{"f": f})
require.NoError(t, err)
r, ok := repo.Targets["targets/test"]
require.True(t, ok)
_, ok = r.Signed.Targets["f"]
require.True(t, ok)
// now delete the signing key (all keys)
repo.cryptoService = signed.NewEd25519()
// remove a nonexistent target - it should not fail
err = repo.RemoveTargets("targets/test", "t")
require.NoError(t, err)
// now remove a target that does exist - it should fail
err = repo.RemoveTargets("targets/test", "t", "f", "g")
require.Error(t, err)
require.IsType(t, signed.ErrNoKeys{}, err)
}
// adding a key to a role marks root as dirty as well as the role
func TestAddBaseKeysToRoot(t *testing.T) {
for _, role := range data.BaseRoles {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
origKeyIDs := ed25519.ListKeys(role)
require.Len(t, origKeyIDs, 1)
key, err := ed25519.Create(role, testGUN, data.ED25519Key)
require.NoError(t, err)
require.Len(t, repo.Root.Signed.Roles[role].KeyIDs, 1)
require.NoError(t, repo.AddBaseKeys(role, key))
_, ok := repo.Root.Signed.Keys[key.ID()]
require.True(t, ok)
require.Len(t, repo.Root.Signed.Roles[role].KeyIDs, 2)
require.True(t, repo.Root.Dirty)
switch role {
case data.CanonicalSnapshotRole:
require.True(t, repo.Snapshot.Dirty)
case data.CanonicalTargetsRole:
require.True(t, repo.Targets[data.CanonicalTargetsRole].Dirty)
case data.CanonicalTimestampRole:
require.True(t, repo.Timestamp.Dirty)
case data.CanonicalRootRole:
require.NoError(t, err)
require.Len(t, repo.originalRootRole.Keys, 1)
require.Contains(t, repo.originalRootRole.ListKeyIDs(), origKeyIDs[0])
}
}
}
// removing one or more keys from a role marks root as dirty as well as the role
func TestRemoveBaseKeysFromRoot(t *testing.T) {
for _, role := range data.BaseRoles {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
origKeyIDs := ed25519.ListKeys(role)
require.Len(t, origKeyIDs, 1)
require.Len(t, repo.Root.Signed.Roles[role].KeyIDs, 1)
require.NoError(t, repo.RemoveBaseKeys(role, origKeyIDs...))
require.Len(t, repo.Root.Signed.Roles[role].KeyIDs, 0)
require.True(t, repo.Root.Dirty)
switch role {
case data.CanonicalSnapshotRole:
require.True(t, repo.Snapshot.Dirty)
case data.CanonicalTargetsRole:
require.True(t, repo.Targets[data.CanonicalTargetsRole].Dirty)
case data.CanonicalTimestampRole:
require.True(t, repo.Timestamp.Dirty)
case data.CanonicalRootRole:
require.Len(t, repo.originalRootRole.Keys, 1)
require.Contains(t, repo.originalRootRole.ListKeyIDs(), origKeyIDs[0])
}
}
}
// replacing keys in a role marks root as dirty as well as the role
func TestReplaceBaseKeysInRoot(t *testing.T) {
for _, role := range data.BaseRoles {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
origKeyIDs := ed25519.ListKeys(role)
require.Len(t, origKeyIDs, 1)
key, err := ed25519.Create(role, testGUN, data.ED25519Key)
require.NoError(t, err)
require.Len(t, repo.Root.Signed.Roles[role].KeyIDs, 1)
require.NoError(t, repo.ReplaceBaseKeys(role, key))
_, ok := repo.Root.Signed.Keys[key.ID()]
require.True(t, ok)
require.Len(t, repo.Root.Signed.Roles[role].KeyIDs, 1)
require.True(t, repo.Root.Dirty)
switch role {
case data.CanonicalSnapshotRole:
require.True(t, repo.Snapshot.Dirty)
case data.CanonicalTargetsRole:
require.True(t, repo.Targets[data.CanonicalTargetsRole].Dirty)
case data.CanonicalTimestampRole:
require.True(t, repo.Timestamp.Dirty)
case data.CanonicalRootRole:
require.Len(t, repo.originalRootRole.Keys, 1)
require.Contains(t, repo.originalRootRole.ListKeyIDs(), origKeyIDs[0])
}
origNumRoles := len(repo.Root.Signed.Roles)
// sign the root and assert the number of roles after
_, err = repo.SignRoot(data.DefaultExpires(data.CanonicalRootRole), nil)
require.NoError(t, err)
// number of roles should not have changed
require.Len(t, repo.Root.Signed.Roles, origNumRoles)
}
}
func TestGetAllRoles(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
// After we init, we get the base roles
roles := repo.GetAllLoadedRoles()
require.Len(t, roles, len(data.BaseRoles))
}
func TestGetBaseRoles(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
// After we init, we get the base roles
for _, role := range data.BaseRoles {
baseRole, err := repo.GetBaseRole(role)
require.NoError(t, err)
require.Equal(t, role, baseRole.Name)
keyIDs := repo.cryptoService.ListKeys(role)
for _, keyID := range keyIDs {
_, ok := baseRole.Keys[keyID]
require.True(t, ok)
require.Contains(t, baseRole.ListKeyIDs(), keyID)
}
// initRepo should set all key thresholds to 1
require.Equal(t, 1, baseRole.Threshold)
}
}
func TestGetBaseRolesInvalidName(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
_, err := repo.GetBaseRole("invalid")
require.Error(t, err)
_, err = repo.GetBaseRole("targets/delegation")
require.Error(t, err)
}
func TestGetDelegationValidRoles(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey1, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey1}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{"path", "anotherpath"}, []string{}, false)
require.NoError(t, err)
delgRole, err := repo.GetDelegationRole("targets/test")
require.NoError(t, err)
require.EqualValues(t, "targets/test", delgRole.Name)
require.Equal(t, 1, delgRole.Threshold)
require.Equal(t, []string{testKey1.ID()}, delgRole.ListKeyIDs())
require.Equal(t, []string{"path", "anotherpath"}, delgRole.Paths)
require.Equal(t, testKey1, delgRole.Keys[testKey1.ID()])
testKey2, err := ed25519.Create("targets/a", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/a", []data.PublicKey{testKey2}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/a", []string{""}, []string{}, false)
require.NoError(t, err)
delgRole, err = repo.GetDelegationRole("targets/a")
require.NoError(t, err)
require.EqualValues(t, "targets/a", delgRole.Name)
require.Equal(t, 1, delgRole.Threshold)
require.Equal(t, []string{testKey2.ID()}, delgRole.ListKeyIDs())
require.Equal(t, []string{""}, delgRole.Paths)
require.Equal(t, testKey2, delgRole.Keys[testKey2.ID()])
testKey3, err := ed25519.Create("targets/test/b", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test/b", []data.PublicKey{testKey3}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test/b", []string{"path/subpath", "anotherpath"}, []string{}, false)
require.NoError(t, err)
delgRole, err = repo.GetDelegationRole("targets/test/b")
require.NoError(t, err)
require.EqualValues(t, "targets/test/b", delgRole.Name)
require.Equal(t, 1, delgRole.Threshold)
require.Equal(t, []string{testKey3.ID()}, delgRole.ListKeyIDs())
require.Equal(t, []string{"path/subpath", "anotherpath"}, delgRole.Paths)
require.Equal(t, testKey3, delgRole.Keys[testKey3.ID()])
testKey4, err := ed25519.Create("targets/test/c", testGUN, data.ED25519Key)
require.NoError(t, err)
// Try adding empty paths, ensure this is valid
err = repo.UpdateDelegationKeys("targets/test/c", []data.PublicKey{testKey4}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test/c", []string{}, []string{}, false)
require.NoError(t, err)
}
func TestGetDelegationRolesInvalidName(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
_, err := repo.GetDelegationRole("invalid")
require.Error(t, err)
for _, role := range data.BaseRoles {
_, err = repo.GetDelegationRole(role)
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
_, err = repo.GetDelegationRole("targets/does_not_exist")
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
func TestGetDelegationRolesInvalidPaths(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
testKey1, err := ed25519.Create("targets/test", testGUN, data.ED25519Key)
require.NoError(t, err)
err = repo.UpdateDelegationKeys("targets/test", []data.PublicKey{testKey1}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test", []string{"path", "anotherpath"}, []string{}, false)
require.NoError(t, err)
testKey2, err := ed25519.Create("targets/test/b", testGUN, data.ED25519Key)
require.NoError(t, err)
// Now we add a delegation with a path that is not prefixed by its parent delegation, the invalid path can't be added so there is an error
err = repo.UpdateDelegationKeys("targets/test/b", []data.PublicKey{testKey2}, []string{}, 1)
require.NoError(t, err)
err = repo.UpdateDelegationPaths("targets/test/b", []string{"invalidpath"}, []string{}, false)
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
delgRole, err := repo.GetDelegationRole("targets/test")
require.NoError(t, err)
require.Contains(t, delgRole.Paths, "path")
require.Contains(t, delgRole.Paths, "anotherpath")
}
func TestDelegationRolesParent(t *testing.T) {
delgA := data.DelegationRole{
BaseRole: data.BaseRole{
Keys: nil,
Name: "targets/a",
Threshold: 1,
},
Paths: []string{"path", "anotherpath"},
}
delgB := data.DelegationRole{
BaseRole: data.BaseRole{
Keys: nil,
Name: "targets/a/b",
Threshold: 1,
},
Paths: []string{"path/b", "anotherpath/b", "b/invalidpath"},
}
// Assert direct parent relationship
require.True(t, delgA.IsParentOf(delgB))
require.False(t, delgB.IsParentOf(delgA))
require.False(t, delgA.IsParentOf(delgA))
delgC := data.DelegationRole{
BaseRole: data.BaseRole{
Keys: nil,
Name: "targets/a/b/c",
Threshold: 1,
},
Paths: []string{"path/b", "anotherpath/b/c", "c/invalidpath"},
}
// Assert direct parent relationship
require.True(t, delgB.IsParentOf(delgC))
require.False(t, delgB.IsParentOf(delgB))
require.False(t, delgA.IsParentOf(delgC))
require.False(t, delgC.IsParentOf(delgB))
require.False(t, delgC.IsParentOf(delgA))
require.False(t, delgC.IsParentOf(delgC))
// Check that parents correctly restrict paths
restrictedDelgB, err := delgA.Restrict(delgB)
require.NoError(t, err)
require.Contains(t, restrictedDelgB.Paths, "path/b")
require.Contains(t, restrictedDelgB.Paths, "anotherpath/b")
require.NotContains(t, restrictedDelgB.Paths, "b/invalidpath")
_, err = delgB.Restrict(delgA)
require.Error(t, err)
_, err = delgA.Restrict(delgC)
require.Error(t, err)
_, err = delgC.Restrict(delgB)
require.Error(t, err)
_, err = delgC.Restrict(delgA)
require.Error(t, err)
// Make delgA have no paths and check that it changes delgB and delgC accordingly when chained
delgA.Paths = []string{}
restrictedDelgB, err = delgA.Restrict(delgB)
require.NoError(t, err)
require.Empty(t, restrictedDelgB.Paths)
restrictedDelgC, err := restrictedDelgB.Restrict(delgC)
require.NoError(t, err)
require.Empty(t, restrictedDelgC.Paths)
}
func TestGetBaseRoleEmptyRepo(t *testing.T) {
repo := NewRepo(nil)
_, err := repo.GetBaseRole(data.CanonicalRootRole)
require.Error(t, err)
require.IsType(t, ErrNotLoaded{}, err)
}
func TestGetBaseRoleKeyMissing(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
// change root role to have a KeyID that doesn't exist
repo.Root.Signed.Roles[data.CanonicalRootRole].KeyIDs = []string{"abc"}
_, err := repo.GetBaseRole(data.CanonicalRootRole)
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
func TestGetDelegationRoleKeyMissing(t *testing.T) {
ed25519 := signed.NewEd25519()
repo := initRepo(t, ed25519)
// add a delegation that has a KeyID that doesn't exist
// in the relevant key map
tar := repo.Targets[data.CanonicalTargetsRole]
tar.Signed.Delegations.Roles = []*data.Role{
{
RootRole: data.RootRole{
KeyIDs: []string{"abc"},
Threshold: 1,
},
Name: "targets/missing_key",
Paths: []string{""},
},
}
_, err := repo.GetDelegationRole("targets/missing_key")
require.Error(t, err)
require.IsType(t, data.ErrInvalidRole{}, err)
}
func verifySignatureList(t *testing.T, signed *data.Signed, expectedKeys ...data.PublicKey) {
require.Equal(t, len(expectedKeys), len(signed.Signatures))
usedKeys := make(map[string]struct{}, len(signed.Signatures))
for _, sig := range signed.Signatures {
usedKeys[sig.KeyID] = struct{}{}
}
for _, key := range expectedKeys {
_, ok := usedKeys[key.ID()]
require.True(t, ok)
verifyRootSignatureAgainstKey(t, signed, key)
}
}
func verifyRootSignatureAgainstKey(t *testing.T, signedRoot *data.Signed, key data.PublicKey) error {
roleWithKeys := data.BaseRole{Name: data.CanonicalRootRole, Keys: data.Keys{key.ID(): key}, Threshold: 1}
return signed.VerifySignatures(signedRoot, roleWithKeys)
}
func TestSignRootOldKeyCertExists(t *testing.T) {
var gun data.GUN = "docker/test-sign-root"
referenceTime := time.Now()
cs := cryptoservice.NewCryptoService(trustmanager.NewKeyMemoryStore(
passphrase.ConstantRetriever("password")))
rootPublicKey, err := cs.Create(data.CanonicalRootRole, gun, data.ECDSAKey)
require.NoError(t, err)
rootPrivateKey, _, err := cs.GetPrivateKey(rootPublicKey.ID())
require.NoError(t, err)
oldRootCert, err := cryptoservice.GenerateCertificate(rootPrivateKey, gun, referenceTime.AddDate(-9, 0, 0),
referenceTime.AddDate(1, 0, 0))
require.NoError(t, err)
oldRootCertKey := utils.CertToKey(oldRootCert)
repo := initRepoWithRoot(t, cs, oldRootCertKey)
// Create a first signature, using the old key.
signedRoot, err := repo.SignRoot(data.DefaultExpires(data.CanonicalRootRole), nil)
require.NoError(t, err)
verifySignatureList(t, signedRoot, oldRootCertKey)
err = verifyRootSignatureAgainstKey(t, signedRoot, oldRootCertKey)
require.NoError(t, err)
// Create a new certificate
newRootCert, err := cryptoservice.GenerateCertificate(rootPrivateKey, gun, referenceTime, referenceTime.AddDate(10, 0, 0))
require.NoError(t, err)
newRootCertKey := utils.CertToKey(newRootCert)
require.NotEqual(t, oldRootCertKey.ID(), newRootCertKey.ID())
// Only trust the new certificate
err = repo.ReplaceBaseKeys(data.CanonicalRootRole, newRootCertKey)
require.NoError(t, err)
updatedRootRole, err := repo.GetBaseRole(data.CanonicalRootRole)
require.NoError(t, err)
updatedRootKeyIDs := updatedRootRole.ListKeyIDs()
require.Equal(t, 1, len(updatedRootKeyIDs))
require.Equal(t, newRootCertKey.ID(), updatedRootKeyIDs[0])
// Create a second signature
signedRoot, err = repo.SignRoot(data.DefaultExpires(data.CanonicalRootRole), nil)
require.NoError(t, err)
verifySignatureList(t, signedRoot, oldRootCertKey, newRootCertKey)
// Verify that the signature can be verified when trusting the old certificate
err = verifyRootSignatureAgainstKey(t, signedRoot, oldRootCertKey)
require.NoError(t, err)
// Verify that the signature can be verified when trusting the new certificate
err = verifyRootSignatureAgainstKey(t, signedRoot, newRootCertKey)
require.NoError(t, err)
}
func TestSignRootOldKeyCertMissing(t *testing.T) {
var gun data.GUN = "docker/test-sign-root"
referenceTime := time.Now()
cs := cryptoservice.NewCryptoService(trustmanager.NewKeyMemoryStore(
passphrase.ConstantRetriever("password")))
rootPublicKey, err := cs.Create(data.CanonicalRootRole, gun, data.ECDSAKey)
require.NoError(t, err)
rootPrivateKey, _, err := cs.GetPrivateKey(rootPublicKey.ID())
require.NoError(t, err)
oldRootCert, err := cryptoservice.GenerateCertificate(rootPrivateKey, gun, referenceTime.AddDate(-9, 0, 0),
referenceTime.AddDate(1, 0, 0))
require.NoError(t, err)
oldRootCertKey := utils.CertToKey(oldRootCert)
repo := initRepoWithRoot(t, cs, oldRootCertKey)
// Create a first signature, using the old key.
signedRoot, err := repo.SignRoot(data.DefaultExpires(data.CanonicalRootRole), nil)
require.NoError(t, err)
verifySignatureList(t, signedRoot, oldRootCertKey)
err = verifyRootSignatureAgainstKey(t, signedRoot, oldRootCertKey)
require.NoError(t, err)
// Create a new certificate
newRootCert, err := cryptoservice.GenerateCertificate(rootPrivateKey, gun, referenceTime, referenceTime.AddDate(10, 0, 0))
require.NoError(t, err)
newRootCertKey := utils.CertToKey(newRootCert)
require.NotEqual(t, oldRootCertKey.ID(), newRootCertKey.ID())
// Only trust the new certificate
err = repo.ReplaceBaseKeys(data.CanonicalRootRole, newRootCertKey)
require.NoError(t, err)
updatedRootRole, err := repo.GetBaseRole(data.CanonicalRootRole)
require.NoError(t, err)
updatedRootKeyIDs := updatedRootRole.ListKeyIDs()
require.Equal(t, 1, len(updatedRootKeyIDs))
require.Equal(t, newRootCertKey.ID(), updatedRootKeyIDs[0])
// Now forget all about the old certificate: drop it from the Root carried keys
delete(repo.Root.Signed.Keys, oldRootCertKey.ID())
repo2 := NewRepo(cs)
repo2.Root = repo.Root
repo2.originalRootRole = updatedRootRole
// Create a second signature
signedRoot, err = repo2.SignRoot(data.DefaultExpires(data.CanonicalRootRole), nil)
require.NoError(t, err)
verifySignatureList(t, signedRoot, newRootCertKey) // Without oldRootCertKey
// Verify that the signature can be verified when trusting the new certificate
err = verifyRootSignatureAgainstKey(t, signedRoot, newRootCertKey)
require.NoError(t, err)
err = verifyRootSignatureAgainstKey(t, signedRoot, oldRootCertKey)
require.Error(t, err)
}
// SignRoot signs with the current root and the previous, to allow root key
// rotation. After signing with the previous keys, they can be discarded from
// the root role.
func TestRootKeyRotation(t *testing.T) {
var gun data.GUN = "docker/test-sign-root"
referenceTime := time.Now()
cs := cryptoservice.NewCryptoService(trustmanager.NewKeyMemoryStore(
passphrase.ConstantRetriever("password")))
rootCertKeys := make([]data.PublicKey, 7)
rootPrivKeys := make([]data.PrivateKey, cap(rootCertKeys))
for i := 0; i < cap(rootCertKeys); i++ {
rootPublicKey, err := cs.Create(data.CanonicalRootRole, gun, data.ECDSAKey)
require.NoError(t, err)
rootPrivateKey, _, err := cs.GetPrivateKey(rootPublicKey.ID())
require.NoError(t, err)
rootCert, err := cryptoservice.GenerateCertificate(rootPrivateKey, gun, referenceTime.AddDate(-9, 0, 0),
referenceTime.AddDate(1, 0, 0))
require.NoError(t, err)
rootCertKeys[i] = utils.CertToKey(rootCert)
rootPrivKeys[i] = rootPrivateKey
}
// Initialize and sign with one key
repo := initRepoWithRoot(t, cs, rootCertKeys[0])
signedObj, err := repo.Root.ToSigned()
require.NoError(t, err)
signedObj, err = repo.sign(signedObj, nil, []data.PublicKey{rootCertKeys[0]})
require.NoError(t, err)
verifySignatureList(t, signedObj, rootCertKeys[0])
repo.Root.Signatures = signedObj.Signatures
// Add new root key, should sign with previous and new
require.NoError(t, repo.ReplaceBaseKeys(data.CanonicalRootRole, rootCertKeys[1]))
signedObj, err = repo.SignRoot(data.DefaultExpires(data.CanonicalRootRole), nil)
require.NoError(t, err)
expectedSigningKeys := []data.PublicKey{
rootCertKeys[0],
rootCertKeys[1],
}
verifySignatureList(t, signedObj, expectedSigningKeys...)
// Add new root key, should sign with previous and new, not with old
require.NoError(t, repo.ReplaceBaseKeys(data.CanonicalRootRole, rootCertKeys[2]))
signedObj, err = repo.SignRoot(data.DefaultExpires(data.CanonicalRootRole), nil)
require.NoError(t, err)
expectedSigningKeys = []data.PublicKey{
rootCertKeys[1],
rootCertKeys[2],
}
verifySignatureList(t, signedObj, expectedSigningKeys...)
// Rotate to two new keys, should be signed with previous and current (3 total)
require.NoError(t, repo.ReplaceBaseKeys(data.CanonicalRootRole, rootCertKeys[3], rootCertKeys[4]))
signedObj, err = repo.SignRoot(data.DefaultExpires(data.CanonicalRootRole), nil)
require.NoError(t, err)
expectedSigningKeys = []data.PublicKey{
rootCertKeys[2],
rootCertKeys[3],
rootCertKeys[4],
}
verifySignatureList(t, signedObj, expectedSigningKeys...)
// Rotate to two new keys, should be signed with previous set and current set (4 total)
require.NoError(t, repo.ReplaceBaseKeys(data.CanonicalRootRole, rootCertKeys[5], rootCertKeys[6]))
signedObj, err = repo.SignRoot(data.DefaultExpires(data.CanonicalRootRole), nil)
require.NoError(t, err)
expectedSigningKeys = []data.PublicKey{
rootCertKeys[3],
rootCertKeys[4],
rootCertKeys[5],
rootCertKeys[6],
}
verifySignatureList(t, signedObj, expectedSigningKeys...)
}
|
dslab-epfl/pix | dpdk-nfs/nf/nf_main.c | #ifdef KLEE_VERIFICATION
#include "lib/stubs/driver_stub.h"
#include "lib/stubs/hardware_stub.h"
#include "lib/stubs/time_stub_control.h"
#include <klee/klee.h>
#endif
#include <inttypes.h>
#include <stdio.h>
#include <assert.h>
//#define REPLAY
// TX configuration default values
#define IXGBE_DEFAULT_TX_FREE_THRESH 32
#define IXGBE_DEFAULT_TX_PTHRESH 32
#define IXGBE_DEFAULT_TX_HTHRESH 0
#define IXGBE_DEFAULT_TX_WTHRESH 0
#define IXGBE_DEFAULT_TX_RSBIT_THRESH 32
#ifdef FREUD
#define MAX_PKTS 500
#endif // FREUD
#ifdef KLEE_VERIFICATION
#define VIGOR_LOOP_BEGIN \
unsigned _vigor_lcore_id = rte_lcore_id(); \
time_t _vigor_start_time = start_time(); \
int _vigor_loop_termination = klee_int("loop_termination"); \
unsigned VIGOR_DEVICES_COUNT; \
klee_possibly_havoc(&VIGOR_DEVICES_COUNT, sizeof(VIGOR_DEVICES_COUNT), \
"VIGOR_DEVICES_COUNT"); \
time_t VIGOR_NOW; \
klee_possibly_havoc(&VIGOR_NOW, sizeof(VIGOR_NOW), "VIGOR_NOW"); \
unsigned VIGOR_DEVICE; \
klee_possibly_havoc(&VIGOR_DEVICE, sizeof(VIGOR_DEVICE), "VIGOR_DEVICE"); \
unsigned _d; \
klee_possibly_havoc(&_d, sizeof(_d), "_d"); \
while (klee_induce_invariants() & _vigor_loop_termination) { \
nf_loop_iteration_border(_vigor_lcore_id, _vigor_start_time); \
VIGOR_NOW = current_time(); \
/* concretize the device to avoid leaking symbols into DPDK */ \
VIGOR_DEVICES_COUNT = rte_eth_dev_count_avail(); \
VIGOR_DEVICE = klee_range(0, VIGOR_DEVICES_COUNT, "VIGOR_DEVICE"); \
for (_d = 0; _d < VIGOR_DEVICES_COUNT; _d++) \
if (VIGOR_DEVICE == _d) { \
VIGOR_DEVICE = _d; \
break; \
} \
stub_hardware_receive_packet(VIGOR_DEVICE);
#ifdef REPLAY
#define VIGOR_LOOP_END \
stub_hardware_reset_receive(VIGOR_DEVICE); \
nf_loop_iteration_border(_vigor_lcore_id, VIGOR_NOW); \
if (klee_int("tired")) { \
exit(0); \
} \
}
#else // REPLAY
#define VIGOR_LOOP_END \
stub_hardware_reset_receive(VIGOR_DEVICE); \
nf_loop_iteration_border(_vigor_lcore_id, VIGOR_NOW); \
}
#endif // REPLAY
#else // KLEE_VERIFICATION
#define VIGOR_LOOP_BEGIN \
while (1) { \
time_t VIGOR_NOW = current_time(); \
unsigned VIGOR_DEVICES_COUNT = rte_eth_dev_count_avail(); \
for (uint16_t VIGOR_DEVICE = 0; VIGOR_DEVICE < VIGOR_DEVICES_COUNT; \
VIGOR_DEVICE++) {
#define VIGOR_LOOP_END \
} \
}
#endif // KLEE_VERIFICATION
// DPDK uses these but doesn't include them. :|
#include <linux/limits.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
#include <rte_common.h>
#include <rte_eal.h>
#include <rte_errno.h>
#include <rte_ethdev.h>
#include <rte_lcore.h>
#include <rte_mbuf.h>
#include "lib/nf_forward.h"
#include "lib/nf_log.h"
#include "lib/nf_time.h"
#include "lib/nf_util.h"
#include "lib/nf_perf_log.h"
// Number of RX/TX queues
static const uint16_t RX_QUEUES_COUNT = 1;
static const uint16_t TX_QUEUES_COUNT = 1;
#define batch_param 1000000
#define MMAP_NUM_ENTRIES 1000000
#define CPU_HZ 3292060000 // Change this for different computers. (cat /proc/cpuinfo)
#define PAGE_SIZE 4096
#if (defined DUMP_LATENCY)
#include "lib/nf_log.h"
#include "x86intrin.h"
#include <time.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int TRAFFIC_CLASS;
long long* mmap_file;
long mmap_file_cntr = 0;
// Returns time in nanoseconds scale.
static __inline__ long rdtsc(void) {
unsigned a, d;
asm volatile("rdtsc" : "=a" (a), "=d" (d));
return (long)((double)(((long)a) | (((long)d) << 32)) / (double)CPU_HZ * 1000000000);
}
#endif // DUMP_LATENCY
// --- Static config ---
// TODO see remark in lcore_main
// Size of batches to receive; trade-off between latency and throughput
// Can be overriden at compile time
//#ifndef BATCH_SIZE
// static const uint16_t BATCH_SIZE = 32;
//#endif
// Queue sizes for receiving/transmitting packets
// NOT powers of 2 so that ixgbe doesn't use vector stuff
// but they have to be multiples of 8, and at least 32, otherwise the driver
// refuses
static const uint16_t RX_QUEUE_SIZE = 96;
static const uint16_t TX_QUEUE_SIZE = 96;
// Clone pool for flood()
static struct rte_mempool *clone_pool;
// Buffer count for mempools
static const unsigned MEMPOOL_BUFFER_COUNT = 256;
// --- Initialization ---
static int nf_init_device(uint16_t device, struct rte_mempool *mbuf_pool) {
int retval;
// device_conf passed to rte_eth_dev_configure cannot be NULL
struct rte_eth_conf device_conf;
memset(&device_conf, 0, sizeof(struct rte_eth_conf));
// Configure the device
retval = rte_eth_dev_configure(device, RX_QUEUES_COUNT, TX_QUEUES_COUNT,
&device_conf);
if (retval != 0) {
return retval;
}
struct rte_eth_txconf *tx_confp = NULL;
// This config breaks verify-hardware. however it is nessary to ensure,
// we avoid batch buffer recycling on some packets. It enforces the dpdk to
// free a buffer right after a packet is sent (after some warm-up period,
// like starting from a packet#95).
// In verify-klee, this config is ignored anyway.
// In verify-hardware, this config apprently leads to an explosion. Instead,
// to ensure the state at the end of an iteration (send+receive) matches
// the one at the beginning, we employ a "hack" -stub_hardware_reset_receive
#ifndef KLEE_VERIFICATION
// Allocate and set up TX queues
struct rte_eth_txconf tx_conf;
tx_conf = (struct rte_eth_txconf){
.tx_thresh =
{
.pthresh = IXGBE_DEFAULT_TX_PTHRESH,
.hthresh = IXGBE_DEFAULT_TX_HTHRESH,
.wthresh = IXGBE_DEFAULT_TX_WTHRESH,
},
.tx_free_thresh = IXGBE_DEFAULT_TX_FREE_THRESH,
.tx_rs_thresh = IXGBE_DEFAULT_TX_RSBIT_THRESH,
};
tx_conf.tx_free_thresh = 1;
tx_conf.tx_rs_thresh = 1;
tx_confp = &tx_conf;
#endif //! KLEE_VERIFICATION
for (int txq = 0; txq < TX_QUEUES_COUNT; txq++) {
retval = rte_eth_tx_queue_setup(device, txq, TX_QUEUE_SIZE,
rte_eth_dev_socket_id(device),
NULL // default config
);
if (retval != 0) {
return retval;
}
}
// Allocate and set up RX queues
for (int rxq = 0; rxq < RX_QUEUES_COUNT; rxq++) {
retval = rte_eth_rx_queue_setup(device, rxq, RX_QUEUE_SIZE,
rte_eth_dev_socket_id(device),
NULL, // default config
mbuf_pool);
if (retval != 0) {
return retval;
}
}
// Start the device
retval = rte_eth_dev_start(device);
if (retval != 0) {
return retval;
}
// Enable RX in promiscuous mode, just in case
rte_eth_promiscuous_enable(device);
if (rte_eth_promiscuous_get(device) != 1) {
return retval;
}
return 0;
}
// Flood method for the bridge
#ifdef KLEE_VERIFICATION
void flood(struct rte_mbuf *frame, uint16_t skip_device,
uint16_t nb_devices); // defined in stubs
#else
void flood(struct rte_mbuf *frame, uint16_t skip_device, uint16_t nb_devices) {
for (uint16_t device = 0; device < nb_devices; device++) {
if (device == skip_device)
continue;
struct rte_mbuf *copy = rte_pktmbuf_clone(frame, clone_pool);
if (copy == NULL) {
rte_exit(EXIT_FAILURE, "Cannot clone a frame for flooding");
}
uint16_t actual_tx_len = rte_eth_tx_burst(device, 0, ©, 1);
if (actual_tx_len == 0) {
rte_pktmbuf_free(copy);
}
}
rte_pktmbuf_free(frame);
}
#endif //! KLEE_VERIFICATION
// --- Per-core work ---
static void lcore_main(void) {
// TODO is this check useful?
for (uint16_t device = 0; device < rte_eth_dev_count_avail(); device++) {
if (rte_eth_dev_socket_id(device) > 0 &&
rte_eth_dev_socket_id(device) != (int)rte_socket_id()) {
NF_INFO("Device %" PRIu8 " is on remote NUMA node to polling thread.",
device);
}
}
nf_core_init();
NF_INFO("Core %u forwarding packets.", rte_lcore_id());
#ifdef FREUD
long long packets_processed = 0;
#endif
uint16_t actual_rx_len;
uint16_t dst_device;
struct rte_mbuf *buf;
uint16_t actual_tx_len;
#ifdef KLEE_VERIFICATION
klee_possibly_havoc(&actual_rx_len, sizeof(actual_rx_len), "actual_rx_len");
klee_possibly_havoc(&dst_device, sizeof(dst_device), "dst_device");
klee_possibly_havoc(&buf, sizeof(buf), "buf_addr");
klee_possibly_havoc(&actual_tx_len, sizeof(actual_tx_len), "actual_tx_len");
#endif // KLEE_VERIFICATION
/* Setting up perf measurement code before event loop */
TN_PERF_PAPI_INIT();
/* Event loop begins */
TN_PERF_PAPI_RESET();
VIGOR_LOOP_BEGIN
buf = NULL;
actual_rx_len = rte_eth_rx_burst(VIGOR_DEVICE, 0, &buf, 1);
if (actual_rx_len != 0) {
// TN_PERF_PAPI_RESET();
TN_PERF_PAPI_LOG_PKT();
#ifdef FREUD
packets_processed++;
#endif
/* Start measurements */
#ifdef DUMP_LATENCY
long long start_time = rdtsc();
#endif // DUMP_LATENCY
#ifdef DUMP_PERF_VARS
NF_PERF_DEBUG("New Packet");
#endif
dst_device = nf_core_process(&buf[0], VIGOR_NOW);
/* End measurements */
// TN_PERF_PAPI_RECORD(1);
#ifdef DUMP_LATENCY
long long end_time = rdtsc();
mmap_file[mmap_file_cntr++] = end_time - start_time;
if (mmap_file_cntr == MMAP_NUM_ENTRIES) // To Avoid overflow
mmap_file_cntr = 0;
#endif // DUMP_LATENCY
if (dst_device == VIGOR_DEVICE) {
rte_pktmbuf_free(buf);
} else if (dst_device == FLOOD_FRAME) {
flood(buf, VIGOR_DEVICE, VIGOR_DEVICES_COUNT);
} else {
actual_tx_len = rte_eth_tx_burst(dst_device, 0, &buf, 1);
if (actual_tx_len == 0) {
rte_pktmbuf_free(buf);
}
}
}
#ifdef FREUD
if (packets_processed == MAX_PKTS){
return;
}
#endif // FREUD
#ifdef STOP_ON_RX_0
else if (VIGOR_DEVICE == 0) {
return;
}
#endif
#ifdef STOP_ON_RX_1
else if (VIGOR_DEVICE == 1) {
return;
}
#endif
VIGOR_LOOP_END
}
// --- Main ---
int main(int argc, char *argv[]) {
// Initialize the Environment Abstraction Layer (EAL)
int ret = rte_eal_init(argc, argv);
if (ret < 0) {
rte_exit(EXIT_FAILURE, "Error with EAL initialization, ret=%d\n", ret);
}
argc -= ret;
argv += ret;
#ifdef KLEE_VERIFICATION
// Attach stub driver (note that hardware stub is autodetected, no need to
// attach)
stub_driver_attach();
#endif
// NF-specific config
nf_config_init(argc, argv);
nf_print_config();
// Create a memory pool
unsigned nb_devices = rte_eth_dev_count_avail();
struct rte_mempool *mbuf_pool = rte_pktmbuf_pool_create(
"MEMPOOL", // name
MEMPOOL_BUFFER_COUNT * nb_devices, // #elements
0, // cache size (per-lcore, not useful in a single-threaded app)
0, // application private area size
RTE_MBUF_DEFAULT_BUF_SIZE, // data buffer size
rte_socket_id() // socket ID
);
if (mbuf_pool == NULL) {
rte_exit(EXIT_FAILURE, "Cannot create mbuf pool: %s\n",
rte_strerror(rte_errno));
}
// Create another pool for the flood() cloning
clone_pool =
rte_pktmbuf_pool_create("clone_pool", // name
MEMPOOL_BUFFER_COUNT, // #elements
0, // cache size (same remark as above)
0, // application private data size
RTE_MBUF_DEFAULT_BUF_SIZE, // data buffer size
rte_socket_id() // socket ID
);
if (clone_pool == NULL) {
rte_exit(EXIT_FAILURE, "Cannot create mbuf clone pool: %s\n",
rte_strerror(rte_errno));
}
// Initialize all devices
for (uint16_t device = 0; device < nb_devices; device++) {
ret = nf_init_device(device, mbuf_pool);
if (ret == 0) {
NF_INFO("Initialized device %" PRIu8 ".", device);
} else {
rte_exit(EXIT_FAILURE, "Cannot init device %" PRIu8 ", ret=%d", device,
ret);
}
}
// Run!
// ...in single-threaded mode, that is.
#if (defined DUMP_LATENCY)
FILE *fp = fopen("latency_log.bin","w+");
if(fp == 0)
assert (0 && "fopen failed");
fseek(fp,(MMAP_NUM_ENTRIES*sizeof(long))-1,SEEK_SET);
fwrite("", 1, sizeof(char), fp);
fflush(fp);
fclose(fp);
int fd = open("./latency_log.bin", O_RDWR);
if(fd < 0)
assert(0 && "open failed");
mmap_file = (long long *) mmap(NULL, MMAP_NUM_ENTRIES*sizeof(long long), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
if(mmap_file == MAP_FAILED)
assert(0 && "mmap failed");
close(fd);
long gap = PAGE_SIZE/sizeof(long long);
// Touch each page to load them to the TLB.
for (long i = 0; i < MMAP_NUM_ENTRIES; i += gap)
mmap_file[i] = 0;
#endif //DUMP_LATENCY
lcore_main();
return 0;
}
|
Ayushk93/amplify_bootstrap | node_modules/@aws-sdk/client-personalize-events/dist/cjs/models/index.js | "use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const smithy_client_1 = require("@aws-sdk/smithy-client");
var Event;
(function (Event) {
function isa(o) {
return smithy_client_1.isa(o, "Event");
}
Event.isa = isa;
})(Event = exports.Event || (exports.Event = {}));
var PutEventsRequest;
(function (PutEventsRequest) {
function isa(o) {
return smithy_client_1.isa(o, "PutEventsRequest");
}
PutEventsRequest.isa = isa;
})(PutEventsRequest = exports.PutEventsRequest || (exports.PutEventsRequest = {}));
var InvalidInputException;
(function (InvalidInputException) {
function isa(o) {
return smithy_client_1.isa(o, "InvalidInputException");
}
InvalidInputException.isa = isa;
})(InvalidInputException = exports.InvalidInputException || (exports.InvalidInputException = {}));
//# sourceMappingURL=index.js.map |
MrsZ/licode-windows | ThirdParty/glib-2.28.8/glib/gvariant-core.c | <reponame>MrsZ/licode-windows
/*
* Copyright © 2007, 2008 <NAME>
* Copyright © 2010 Codethink Limited
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
#include <glib/gvariant-core.h>
#include <glib/gvariant-serialiser.h>
#include <glib/gtestutils.h>
#include <glib/gbitlock.h>
#include <glib/gatomic.h>
#include <glib/gbuffer.h>
#include <glib/gslice.h>
#include <glib/gmem.h>
#include <string.h>
/*
* This file includes the structure definition for GVariant and a small
* set of functions that are allowed to access the structure directly.
*
* This minimises the amount of code that can possibly touch a GVariant
* structure directly to a few simple fundamental operations. These few
* operations are written to be completely threadsafe with respect to
* all possible outside access. This means that we only need to be
* concerned about thread safety issues in this one small file.
*
* Most GVariant API functions are in gvariant.c.
*/
/**
* GVariant:
*
* #GVariant is an opaque data structure and can only be accessed
* using the following functions.
*
* Since: 2.24
**/
struct _GVariant
/* see below for field member documentation */
{
GVariantTypeInfo *type_info;
gsize size;
union
{
struct
{
GBuffer *buffer;
gconstpointer data;
} serialised;
struct
{
GVariant **children;
gsize n_children;
} tree;
} contents;
gint state;
gint ref_count;
};
/* struct GVariant:
*
* There are two primary forms of GVariant instances: "serialised form"
* and "tree form".
*
* "serialised form": A serialised GVariant instance stores its value in
* the GVariant serialisation format. All
* basic-typed instances (ie: non-containers) are in
* serialised format, as are some containers.
*
* "tree form": Some containers are in "tree form". In this case,
* instead of containing the serialised data for the
* container, the instance contains an array of pointers to
* the child values of the container (thus forming a tree).
*
* It is possible for an instance to transition from tree form to
* serialised form. This happens, implicitly, if the serialised data is
* requested (eg: via g_variant_get_data()). Serialised form instances
* never transition into tree form.
*
*
* The fields of the structure are documented here:
*
* type_info: this is a reference to a GVariantTypeInfo describing the
* type of the instance. When the instance is freed, this
* reference must be released with g_variant_type_info_unref().
*
* The type_info field never changes during the life of the
* instance, so it can be accessed without a lock.
*
* size: this is the size of the serialised form for the instance, if it
* is known. If the instance is in serialised form then it is, by
* definition, known. If the instance is in tree form then it may
* be unknown (in which case it is -1). It is possible for the
* size to be known when in tree form if, for example, the user
* has called g_variant_get_size() without calling
* g_variant_get_data(). Additionally, even when the user calls
* g_variant_get_data() the size of the data must first be
* determined so that a large enough buffer can be allocated for
* the data.
*
* Once the size is known, it can never become unknown again.
* g_variant_ensure_size() is used to ensure that the size is in
* the known state -- it calculates the size if needed. After
* that, the size field can be accessed without a lock.
*
* contents: a union containing either the information associated with
* holding a value in serialised form or holding a value in
* tree form.
*
* .serialised: Only valid when the instance is in serialised form.
*
* Since an instance can never transition away from
* serialised form, once these fields are set, they will
* never be changed. It is therefore valid to access
* them without holding a lock.
*
* .buffer: the #GBuffer that contains the memory pointed to by
* .data, or %NULL if .data is %NULL. In the event that
* the instance was deserialised from another instance,
* then the buffer will be shared by both of them. When
* the instance is freed, this reference must be released
* with g_buffer_unref().
*
* .data: the serialised data (of size 'size') of the instance.
* This pointer should not be freed or modified in any way.
* #GBuffer is responsible for memory management.
*
* This pointer may be %NULL in two cases:
*
* - if the serialised size of the instance is 0
*
* - if the instance is of a fixed-sized type and was
* deserialised out of a corrupted container such that
* the container contains too few bytes to point to the
* entire proper fixed-size of this instance. In this
* case, 'size' will still be equal to the proper fixed
* size, but this pointer will be %NULL. This is exactly
* the reason that g_variant_get_data() sometimes returns
* %NULL. For all other calls, the effect should be as
* if .data pointed to the appropriate number of nul
* bytes.
*
* .tree: Only valid when the instance is in tree form.
*
* Note that accesses from other threads could result in
* conversion of the instance from tree form to serialised form
* at any time. For this reason, the instance lock must always
* be held while performing any operations on 'contents.tree'.
*
* .children: the array of the child instances of this instance.
* When the instance is freed (or converted to serialised
* form) then each child must have g_variant_unref()
* called on it and the array must be freed using
* g_free().
*
* .n_children: the number of items in the .children array.
*
* state: a bitfield describing the state of the instance. It is a
* bitwise-or of the following STATE_* constants:
*
* STATE_LOCKED: the instance lock is held. This is the bit used by
* g_bit_lock().
*
* STATE_SERIALISED: the instance is in serialised form. If this
* flag is not set then the instance is in tree
* form.
*
* STATE_TRUSTED: for serialised form instances, this means that the
* serialised data is known to be in normal form (ie:
* not corrupted).
*
* For tree form instances, this means that all of the
* child instances in the contents.tree.children array
* are trusted. This means that if the container is
* serialised then the resulting data will be in
* normal form.
*
* If this flag is unset it does not imply that the
* data is corrupted. It merely means that we're not
* sure that it's valid. See g_variant_is_trusted().
*
* STATE_FLOATING: if this flag is set then the object has a floating
* reference. See g_variant_ref_sink().
*
* ref_count: the reference count of the instance
*/
#define STATE_LOCKED 1
#define STATE_SERIALISED 2
#define STATE_TRUSTED 4
#define STATE_FLOATING 8
/* -- private -- */
/* < private >
* g_variant_lock:
* @value: a #GVariant
*
* Locks @value for performing sensitive operations.
*/
static void
g_variant_lock (GVariant *value)
{
g_bit_lock (&value->state, 0);
}
/* < private >
* g_variant_unlock:
* @value: a #GVariant
*
* Unlocks @value after performing sensitive operations.
*/
static void
g_variant_unlock (GVariant *value)
{
g_bit_unlock (&value->state, 0);
}
/* < private >
* g_variant_release_children:
* @value: a #GVariant
*
* Releases the reference held on each child in the 'children' array of
* @value and frees the array itself. @value must be in tree form.
*
* This is done when freeing a tree-form instance or converting it to
* serialised form.
*
* The current thread must hold the lock on @value.
*/
static void
g_variant_release_children (GVariant *value)
{
gsize i;
g_assert (value->state & STATE_LOCKED);
g_assert (~value->state & STATE_SERIALISED);
for (i = 0; i < value->contents.tree.n_children; i++)
g_variant_unref (value->contents.tree.children[i]);
g_free (value->contents.tree.children);
}
/* This begins the main body of the recursive serialiser.
*
* There are 3 functions here that work as a team with the serialiser to
* get things done. g_variant_store() has a trivial role, but as a
* public API function, it has its definition elsewhere.
*
* Note that "serialisation" of an instance does not mean that the
* instance is converted to serialised form -- it means that the
* serialised form of an instance is written to an external buffer.
* g_variant_ensure_serialised() (which is not part of this set of
* functions) is the function that is responsible for converting an
* instance to serialised form.
*
* We are only concerned here with container types since non-container
* instances are always in serialised form. For these instances,
* storing their serialised form merely involves a memcpy().
*
* Serialisation is a two-step process. First, the size of the
* serialised data must be calculated so that an appropriately-sized
* buffer can be allocated. Second, the data is written into the
* buffer.
*
* Determining the size:
* The process of determining the size is triggered by a call to
* g_variant_ensure_size() on a container. This invokes the
* serialiser code to determine the size. The serialiser is passed
* g_variant_fill_gvs() as a callback.
*
* g_variant_fill_gvs() is called by the serialiser on each child of
* the container which, in turn, calls g_variant_ensure_size() on
* itself and fills in the result of its own size calculation.
*
* The serialiser uses the size information from the children to
* calculate the size needed for the entire container.
*
* Writing the data:
* After the buffer has been allocated, g_variant_serialise() is
* called on the container. This invokes the serialiser code to write
* the bytes to the container. The serialiser is, again, passed
* g_variant_fill_gvs() as a callback.
*
* This time, when g_variant_fill_gvs() is called for each child, the
* child is given a pointer to a sub-region of the allocated buffer
* where it should write its data. This is done by calling
* g_variant_store(). In the event that the instance is in serialised
* form this means a memcpy() of the serialised data into the
* allocated buffer. In the event that the instance is in tree form
* this means a recursive call back into g_variant_serialise().
*
*
* The forward declaration here allows corecursion via callback:
*/
static void g_variant_fill_gvs (GVariantSerialised *, gpointer);
/* < private >
* g_variant_ensure_size:
* @value: a #GVariant
*
* Ensures that the ->size field of @value is filled in properly. This
* must be done as a precursor to any serialisation of the value in
* order to know how large of a buffer is needed to store the data.
*
* The current thread must hold the lock on @value.
*/
static void
g_variant_ensure_size (GVariant *value)
{
g_assert (value->state & STATE_LOCKED);
if (value->size == (gssize) -1)
{
gpointer *children;
gsize n_children;
children = (gpointer *) value->contents.tree.children;
n_children = value->contents.tree.n_children;
value->size = g_variant_serialiser_needed_size (value->type_info,
g_variant_fill_gvs,
children, n_children);
}
}
/* < private >
* g_variant_serialise:
* @value: a #GVariant
* @data: an appropriately-sized buffer
*
* Serialises @value into @data. @value must be in tree form.
*
* No change is made to @value.
*
* The current thread must hold the lock on @value.
*/
static void
g_variant_serialise (GVariant *value,
gpointer data)
{
GVariantSerialised serialised = { 0, };
gpointer *children;
gsize n_children;
g_assert (~value->state & STATE_SERIALISED);
g_assert (value->state & STATE_LOCKED);
serialised.type_info = value->type_info;
serialised.size = value->size;
serialised.data = data;
children = (gpointer *) value->contents.tree.children;
n_children = value->contents.tree.n_children;
g_variant_serialiser_serialise (serialised, g_variant_fill_gvs,
children, n_children);
}
/* < private >
* g_variant_fill_gvs:
* @serialised: a pointer to a #GVariantSerialised
* @data: a #GVariant instance
*
* This is the callback that is passed by a tree-form container instance
* to the serialiser. This callback gets called on each child of the
* container. Each child is responsible for performing the following
* actions:
*
* - reporting its type
*
* - reporting its serialised size (requires knowing the size first)
*
* - possibly storing its serialised form into the provided buffer
*/
static void
g_variant_fill_gvs (GVariantSerialised *serialised,
gpointer data)
{
GVariant *value = data;
g_variant_lock (value);
g_variant_ensure_size (value);
g_variant_unlock (value);
if (serialised->type_info == NULL)
serialised->type_info = value->type_info;
g_assert (serialised->type_info == value->type_info);
if (serialised->size == 0)
serialised->size = value->size;
g_assert (serialised->size == value->size);
if (serialised->data)
/* g_variant_store() is a public API, so it
* it will reacquire the lock if it needs to.
*/
g_variant_store (value, serialised->data);
}
/* this ends the main body of the recursive serialiser */
/* < private >
* g_variant_ensure_serialised:
* @value: a #GVariant
*
* Ensures that @value is in serialised form.
*
* If @value is in tree form then this function ensures that the
* serialised size is known and then allocates a buffer of that size and
* serialises the instance into the buffer. The 'children' array is
* then released and the instance is set to serialised form based on the
* contents of the buffer.
*
* The current thread must hold the lock on @value.
*/
static void
g_variant_ensure_serialised (GVariant *value)
{
g_assert (value->state & STATE_LOCKED);
if (~value->state & STATE_SERIALISED)
{
GBuffer *buffer;
gpointer data;
g_variant_ensure_size (value);
data = g_malloc (value->size);
g_variant_serialise (value, data);
g_variant_release_children (value);
buffer = g_buffer_new_take_data (data, value->size);
value->contents.serialised.data = buffer->data;
value->contents.serialised.buffer = buffer;
value->state |= STATE_SERIALISED;
}
}
/* < private >
* g_variant_alloc:
* @type: the type of the new instance
* @serialised: if the instance will be in serialised form
* @trusted: if the instance will be trusted
* @returns: a new #GVariant with a floating reference
*
* Allocates a #GVariant instance and does some common work (such as
* looking up and filling in the type info), setting the state field,
* and setting the ref_count to 1.
*/
static GVariant *
g_variant_alloc (const GVariantType *type,
gboolean serialised,
gboolean trusted)
{
GVariant *value;
value = g_slice_new (GVariant);
value->type_info = g_variant_type_info_get (type);
value->state = (serialised ? STATE_SERIALISED : 0) |
(trusted ? STATE_TRUSTED : 0) |
STATE_FLOATING;
value->size = (gssize) -1;
value->ref_count = 1;
return value;
}
/* -- internal -- */
/* < internal >
* g_variant_new_from_buffer:
* @type: a #GVariantType
* @buffer: a #GBuffer
* @trusted: if the contents of @buffer are trusted
* @returns: a new #GVariant with a floating reference
*
* Constructs a new serialised-mode #GVariant instance. This is the
* inner interface for creation of new serialised values that gets
* called from various functions in gvariant.c.
*
* A reference is taken on @buffer.
*/
GVariant *
g_variant_new_from_buffer (const GVariantType *type,
GBuffer *buffer,
gboolean trusted)
{
GVariant *value;
guint alignment;
gsize size;
value = g_variant_alloc (type, TRUE, trusted);
value->contents.serialised.buffer = g_buffer_ref (buffer);
g_variant_type_info_query (value->type_info,
&alignment, &size);
if (size && buffer->size != size)
{
/* Creating a fixed-sized GVariant with a buffer of the wrong
* size.
*
* We should do the equivalent of pulling a fixed-sized child out
* of a brozen container (ie: data is NULL size is equal to the correct
* fixed size).
*/
value->contents.serialised.data = NULL;
value->size = size;
}
else
{
value->contents.serialised.data = buffer->data;
value->size = buffer->size;
}
return value;
}
/* < internal >
* g_variant_new_from_children:
* @type: a #GVariantType
* @children: an array of #GVariant pointers. Consumed.
* @n_children: the length of @children
* @trusted: %TRUE if every child in @children in trusted
* @returns: a new #GVariant with a floating reference
*
* Constructs a new tree-mode #GVariant instance. This is the inner
* interface for creation of new serialised values that gets called from
* various functions in gvariant.c.
*
* @children is consumed by this function. g_free() will be called on
* it some time later.
*/
GVariant *
g_variant_new_from_children (const GVariantType *type,
GVariant **children,
gsize n_children,
gboolean trusted)
{
GVariant *value;
value = g_variant_alloc (type, FALSE, trusted);
value->contents.tree.children = children;
value->contents.tree.n_children = n_children;
return value;
}
/* < internal >
* g_variant_get_type_info:
* @value: a #GVariant
* @returns: the #GVariantTypeInfo for @value
*
* Returns the #GVariantTypeInfo corresponding to the type of @value. A
* reference is not added, so the return value is only good for the
* duration of the life of @value.
*/
GVariantTypeInfo *
g_variant_get_type_info (GVariant *value)
{
return value->type_info;
}
/* < internal >
* g_variant_is_trusted:
* @value: a #GVariant
* @returns: if @value is trusted
*
* Determines if @value is trusted by #GVariant to contain only
* fully-valid data. All values constructed solely via #GVariant APIs
* are trusted, but values containing data read in from other sources
* are usually not trusted.
*
* The main advantage of trusted data is that certain checks can be
* skipped. For example, we don't need to check that a string is
* properly nul-terminated or that an object path is actually a
* properly-formatted object path.
*/
gboolean
g_variant_is_trusted (GVariant *value)
{
return (value->state & STATE_TRUSTED) != 0;
}
/* -- public -- */
/**
* g_variant_unref:
* @value: a #GVariant
*
* Decreases the reference count of @value. When its reference count
* drops to 0, the memory used by the variant is freed.
*
* Since: 2.24
**/
void
g_variant_unref (GVariant *value)
{
if (g_atomic_int_dec_and_test (&value->ref_count))
{
if G_UNLIKELY (value->state & STATE_LOCKED)
g_critical ("attempting to free a locked GVariant instance. "
"This should never happen.");
value->state |= STATE_LOCKED;
g_variant_type_info_unref (value->type_info);
if (value->state & STATE_SERIALISED)
g_buffer_unref (value->contents.serialised.buffer);
else
g_variant_release_children (value);
memset (value, 0, sizeof (GVariant));
g_slice_free (GVariant, value);
}
}
/**
* g_variant_ref:
* @value: a #GVariant
* @returns: the same @value
*
* Increases the reference count of @value.
*
* Since: 2.24
**/
GVariant *
g_variant_ref (GVariant *value)
{
g_atomic_int_inc (&value->ref_count);
return value;
}
/**
* g_variant_ref_sink:
* @value: a #GVariant
* @returns: the same @value
*
* #GVariant uses a floating reference count system. All functions with
* names starting with <literal>g_variant_new_</literal> return floating
* references.
*
* Calling g_variant_ref_sink() on a #GVariant with a floating reference
* will convert the floating reference into a full reference. Calling
* g_variant_ref_sink() on a non-floating #GVariant results in an
* additional normal reference being added.
*
* In other words, if the @value is floating, then this call "assumes
* ownership" of the floating reference, converting it to a normal
* reference. If the @value is not floating, then this call adds a
* new normal reference increasing the reference count by one.
*
* All calls that result in a #GVariant instance being inserted into a
* container will call g_variant_ref_sink() on the instance. This means
* that if the value was just created (and has only its floating
* reference) then the container will assume sole ownership of the value
* at that point and the caller will not need to unreference it. This
* makes certain common styles of programming much easier while still
* maintaining normal refcounting semantics in situations where values
* are not floating.
*
* Since: 2.24
**/
GVariant *
g_variant_ref_sink (GVariant *value)
{
g_variant_lock (value);
if (~value->state & STATE_FLOATING)
g_variant_ref (value);
else
value->state &= ~STATE_FLOATING;
g_variant_unlock (value);
return value;
}
/**
* g_variant_is_floating:
* @value: a #GVariant
* @returns: whether @value is floating
*
* Checks whether @value has a floating reference count.
*
* This function should only ever be used to assert that a given variant
* is or is not floating, or for debug purposes. To acquire a reference
* to a variant that might be floating, always use g_variant_ref_sink().
*
* See g_variant_ref_sink() for more information about floating reference
* counts.
*
* Since: 2.26
**/
gboolean
g_variant_is_floating (GVariant *value)
{
g_return_val_if_fail (value != NULL, FALSE);
return (value->state & STATE_FLOATING) != 0;
}
/**
* g_variant_get_size:
* @value: a #GVariant instance
* @returns: the serialised size of @value
*
* Determines the number of bytes that would be required to store @value
* with g_variant_store().
*
* If @value has a fixed-sized type then this function always returned
* that fixed size.
*
* In the case that @value is already in serialised form or the size has
* already been calculated (ie: this function has been called before)
* then this function is O(1). Otherwise, the size is calculated, an
* operation which is approximately O(n) in the number of values
* involved.
*
* Since: 2.24
**/
gsize
g_variant_get_size (GVariant *value)
{
g_variant_lock (value);
g_variant_ensure_size (value);
g_variant_unlock (value);
return value->size;
}
/**
* g_variant_get_data:
* @value: a #GVariant instance
* @returns: the serialised form of @value, or %NULL
*
* Returns a pointer to the serialised form of a #GVariant instance.
* The returned data may not be in fully-normalised form if read from an
* untrusted source. The returned data must not be freed; it remains
* valid for as long as @value exists.
*
* If @value is a fixed-sized value that was deserialised from a
* corrupted serialised container then %NULL may be returned. In this
* case, the proper thing to do is typically to use the appropriate
* number of nul bytes in place of @value. If @value is not fixed-sized
* then %NULL is never returned.
*
* In the case that @value is already in serialised form, this function
* is O(1). If the value is not already in serialised form,
* serialisation occurs implicitly and is approximately O(n) in the size
* of the result.
*
* Since: 2.24
**/
gconstpointer
g_variant_get_data (GVariant *value)
{
g_variant_lock (value);
g_variant_ensure_serialised (value);
g_variant_unlock (value);
return value->contents.serialised.data;
}
/**
* g_variant_n_children:
* @value: a container #GVariant
* @returns: the number of children in the container
*
* Determines the number of children in a container #GVariant instance.
* This includes variants, maybes, arrays, tuples and dictionary
* entries. It is an error to call this function on any other type of
* #GVariant.
*
* For variants, the return value is always 1. For values with maybe
* types, it is always zero or one. For arrays, it is the length of the
* array. For tuples it is the number of tuple items (which depends
* only on the type). For dictionary entries, it is always 2
*
* This function is O(1).
*
* Since: 2.24
**/
gsize
g_variant_n_children (GVariant *value)
{
gsize n_children;
g_variant_lock (value);
if (value->state & STATE_SERIALISED)
{
GVariantSerialised serialised = {
value->type_info,
(gpointer) value->contents.serialised.data,
value->size
};
n_children = g_variant_serialised_n_children (serialised);
}
else
n_children = value->contents.tree.n_children;
g_variant_unlock (value);
return n_children;
}
/**
* g_variant_get_child_value:
* @value: a container #GVariant
* @index_: the index of the child to fetch
* @returns: (transfer full): the child at the specified index
*
* Reads a child item out of a container #GVariant instance. This
* includes variants, maybes, arrays, tuples and dictionary
* entries. It is an error to call this function on any other type of
* #GVariant.
*
* It is an error if @index_ is greater than the number of child items
* in the container. See g_variant_n_children().
*
* This function is O(1).
*
* Since: 2.24
**/
GVariant *
g_variant_get_child_value (GVariant *value,
gsize index_)
{
g_return_val_if_fail (index_ < g_variant_n_children (value), NULL);
if (~g_atomic_int_get (&value->state) & STATE_SERIALISED)
{
g_variant_lock (value);
if (~value->state & STATE_SERIALISED)
{
GVariant *child;
child = g_variant_ref (value->contents.tree.children[index_]);
g_variant_unlock (value);
return child;
}
g_variant_unlock (value);
}
{
GVariantSerialised serialised = {
value->type_info,
(gpointer) value->contents.serialised.data,
value->size
};
GVariantSerialised s_child;
GVariant *child;
/* get the serialiser to extract the serialised data for the child
* from the serialised data for the container
*/
s_child = g_variant_serialised_get_child (serialised, index_);
/* create a new serialised instance out of it */
child = g_slice_new (GVariant);
child->type_info = s_child.type_info;
child->state = (value->state & STATE_TRUSTED) |
STATE_SERIALISED;
child->size = s_child.size;
child->ref_count = 1;
child->contents.serialised.buffer =
g_buffer_ref (value->contents.serialised.buffer);
child->contents.serialised.data = s_child.data;
return child;
}
}
/**
* g_variant_store:
* @value: the #GVariant to store
* @data: the location to store the serialised data at
*
* Stores the serialised form of @value at @data. @data should be
* large enough. See g_variant_get_size().
*
* The stored data is in machine native byte order but may not be in
* fully-normalised form if read from an untrusted source. See
* g_variant_get_normal_form() for a solution.
*
* This function is approximately O(n) in the size of @data.
*
* Since: 2.24
**/
void
g_variant_store (GVariant *value,
gpointer data)
{
g_variant_lock (value);
if (value->state & STATE_SERIALISED)
{
if (value->contents.serialised.data != NULL)
memcpy (data, value->contents.serialised.data, value->size);
else
memset (data, 0, value->size);
}
else
g_variant_serialise (value, data);
g_variant_unlock (value);
}
/**
* g_variant_is_normal_form:
* @value: a #GVariant instance
* @returns: %TRUE if @value is in normal form
*
* Checks if @value is in normal form.
*
* The main reason to do this is to detect if a given chunk of
* serialised data is in normal form: load the data into a #GVariant
* using g_variant_new_from_data() and then use this function to
* check.
*
* If @value is found to be in normal form then it will be marked as
* being trusted. If the value was already marked as being trusted then
* this function will immediately return %TRUE.
*
* Since: 2.24
**/
gboolean
g_variant_is_normal_form (GVariant *value)
{
if (value->state & STATE_TRUSTED)
return TRUE;
g_variant_lock (value);
if (value->state & STATE_SERIALISED)
{
GVariantSerialised serialised = {
value->type_info,
(gpointer) value->contents.serialised.data,
value->size
};
if (g_variant_serialised_is_normal (serialised))
value->state |= STATE_TRUSTED;
}
else
{
gboolean normal = TRUE;
gsize i;
for (i = 0; i < value->contents.tree.n_children; i++)
normal &= g_variant_is_normal_form (value->contents.tree.children[i]);
if (normal)
value->state |= STATE_TRUSTED;
}
g_variant_unlock (value);
return (value->state & STATE_TRUSTED) != 0;
}
|
LegalizeAdulthood/cimple | src/brevity/ref/CIMXML.h | <filename>src/brevity/ref/CIMXML.h
/*
**==============================================================================
**
** Copyright (c) 2003, 2004, 2005, 2006, <NAME>, <NAME>
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and associated documentation files (the "Software"),
** to deal in the Software without restriction, including without limitation
** the rights to use, copy, modify, merge, publish, distribute, sublicense,
** and/or sell copies of the Software, and to permit persons to whom the
** Software is furnished to do so, subject to the following conditions:
**
** The above copyright notice and this permission notice shall be included in
** all copies or substantial portions of the Software.
**
** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
** IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
** FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
** AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
** LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
** OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
** SOFTWARE.
**
**==============================================================================
*/
#ifndef _brevity_CIMXML_h
#define _brevity_CIMXML_h
#include <cimple/cimple.h>
#include "linkage.h"
#include "defines.h"
CIMPLE_NAMESPACE_BEGIN
class CIMPLE_BREVITY_LINKAGE CIMXML
{
public:
static void xml_line(Buffer& out)
{
out.append(STRLIT("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"));
}
static void start_CIM(Buffer& out)
{
out.append(STRLIT("<CIM CIMVERSION=\"2.0\" DTDVERSION=\"2.0\">\n"));
}
static void end_CIM(Buffer& out)
{
out.append(STRLIT("</CIM>\n"));
}
static void start_MESSAGE(Buffer& out, uint64 id);
static void end_MESSAGE(Buffer& out)
{
out.append(STRLIT("</MESSAGE>\n"));
}
static void start_SIMPLEREQ(Buffer& out)
{
out.append(STRLIT("<SIMPLEREQ>\n"));
}
static void end_SIMPLEREQ(Buffer& out)
{
out.append(STRLIT("</SIMPLEREQ>\n"));
}
static void start_IMETHODCALL(
Buffer& out, const char* name, size_t size)
{
out.append(STRLIT("<IMETHODCALL NAME=\""));
out.append(name, size);
out.append(STRLIT("\">\n"));
}
static void end_IMETHODCALL(Buffer& out)
{
out.append(STRLIT("</IMETHODCALL>\n"));
}
static void put_LOCALNAMESPACEPATH(Buffer& out, const char* name_space);
static void start_IPARAMVALUE(
Buffer& out, const char* name, size_t size)
{
out.append(STRLIT("<IPARAMVALUE NAME=\""));
out.append(name, size);
out.append(STRLIT("\">\n"));
}
static void end_IPARAMVALUE(Buffer& out)
{
out.append(STRLIT("</IPARAMVALUE>\n"));
}
static void put_CLASSNAME(Buffer& out, const char* name)
{
out.append(STRLIT("<CLASSNAME NAME=\""));
out.appends(name);
out.append(STRLIT("\"/>\n"));
}
};
CIMPLE_NAMESPACE_END
#endif /* _brevity_CIMXML_h */
|
01org/murphy | src/murphy-db/mdb/row.c | /*
* Copyright (c) 2012, Intel Corporation
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of Intel Corporation nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <stdint.h>
#include <limits.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdio.h>
#include <errno.h>
#define _GNU_SOURCE
#include <string.h>
#include <murphy-db/macros.h>
#include "row.h"
#include "table.h"
#include "index.h"
#include "column.h"
mdb_row_t *mdb_row_create(mdb_table_t *tbl)
{
mdb_row_t *row;
MDB_CHECKARG(tbl, NULL);
if (!(row = calloc(1, sizeof(mdb_row_t) + tbl->dlgh))) {
errno = ENOMEM;
return NULL;
}
MDB_DLIST_APPEND(mdb_row_t, link, row, &tbl->rows);
return row;
}
mdb_row_t *mdb_row_duplicate(mdb_table_t *tbl, mdb_row_t *row)
{
mdb_row_t *dup;
MDB_CHECKARG(tbl && row, NULL);
if (!(dup = calloc(1, sizeof(mdb_row_t) + tbl->dlgh))) {
errno = ENOMEM;
return NULL;
}
MDB_DLIST_INIT(dup->link);
memcpy(dup->data, row->data, tbl->dlgh);
return dup;
}
int mdb_row_delete(mdb_table_t *tbl,
mdb_row_t *row,
int index_update,
int free_it)
{
int sts = 0;
(void)tbl;
MDB_CHECKARG(row, -1);
if (index_update && mdb_index_delete(tbl, row) < 0)
sts = -1;
if (!MDB_DLIST_EMPTY(row->link))
MDB_DLIST_UNLINK(mdb_row_t, link, row);
if (free_it)
free(row);
else
MDB_DLIST_INIT(row->link);
return sts;
}
int mdb_row_update(mdb_table_t *tbl,
mdb_row_t *row,
mqi_column_desc_t *cds,
void *data,
int index_update,
mqi_bitfld_t *cmask_ret)
{
mdb_column_t *columns;
mqi_column_desc_t *source_dsc;
int cidx, cmod;
mqi_bitfld_t cmask;
int i;
MDB_CHECKARG(tbl && row && cds && data, -1);
columns = tbl->columns;
if (index_update)
mdb_index_delete(tbl, row);
cmod = 0;
for (cmask = i = 0; (cidx = (source_dsc = cds + i)->cindex) >= 0; i++) {
cmask |= (((mqi_bitfld_t)1) << cidx);
cmod |= mdb_column_write(columns + cidx, row->data, source_dsc, data);
}
if (index_update) {
if (mdb_index_insert(tbl, row, cmask, 0) < 0) {
if (cmask_ret)
*cmask_ret = 0;
return -1;
}
}
if (cmask_ret)
*cmask_ret = cmask;
if (!cmod)
return 0;
else
return 1;
}
int mdb_row_copy_over(mdb_table_t *tbl, mdb_row_t *dst, mdb_row_t *src)
{
MDB_CHECKARG(tbl && dst && src, -1);
if (mdb_index_delete(tbl, dst) < 0)
return -1;
memcpy(dst->data, src->data, tbl->dlgh);
if (mdb_index_insert(tbl, dst, 0, 0) < 0)
return -1;
return 0;
}
/*
* Local Variables:
* c-basic-offset: 4
* indent-tabs-mode: nil
* End:
*
*/
|
dyna-mis/Hilabeling | src/analysis/network/qgsvectorlayerdirector.h | <gh_stars>0
/***************************************************************************
qgsvectorlayerdirector.h
--------------------------------------
Date : 2010-10-20
Copyright : (C) 2010 by <NAME>
Email : YakushevS <at> list.ru
****************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef QGSVECTORLAYERDIRECTOR_H
#define QGSVECTORLAYERDIRECTOR_H
#include "qgis.h"
#include "qgsgraphdirector.h"
#include "qgis_analysis.h"
class QgsGraphBuilderInterface;
class QgsFeatureSource;
/**
* \ingroup analysis
* \class QgsVectorLayerDirector
* \brief Determine making the graph from vector line layer
* \since QGIS 3.0
*/
class ANALYSIS_EXPORT QgsVectorLayerDirector : public QgsGraphDirector
{
Q_OBJECT
public:
/**
* Edge direction
* Edge can be one-way with direct flow (one can move only from the start
* point to the end point), one-way with reversed flow (one can move only
* from the end point to the start point) and bidirectional or two-way
* (one can move in any direction)
*/
enum Direction
{
DirectionForward, //!< One-way direct
DirectionBackward, //!< One-way reversed
DirectionBoth, //!< Two-way
};
/**
* Default constructor
* \param source feature source representing network
* \param directionFieldId field containing direction value
* \param directDirectionValue value for direct one-way road
* \param reverseDirectionValue value for reversed one-way road
* \param bothDirectionValue value for two-way (bidirectional) road
* \param defaultDirection default direction. Will be used if corresponding
* attribute value is not set or does not equal to the given values
*/
QgsVectorLayerDirector( QgsFeatureSource *source,
int directionFieldId,
const QString &directDirectionValue,
const QString &reverseDirectionValue,
const QString &bothDirectionValue,
Direction defaultDirection
);
/*
* MANDATORY DIRECTOR PROPERTY DECLARATION
*/
void makeGraph( QgsGraphBuilderInterface *builder,
const QVector< QgsPointXY > &additionalPoints,
QVector< QgsPointXY> &snappedPoints SIP_OUT,
QgsFeedback *feedback = nullptr ) const override;
QString name() const override;
private:
QgsFeatureSource *mSource = nullptr;
int mDirectionFieldId = -1;
QString mDirectDirectionValue;
QString mReverseDirectionValue;
QString mBothDirectionValue;
Direction mDefaultDirection = DirectionBoth;
QgsAttributeList requiredAttributes() const;
Direction directionForFeature( const QgsFeature &feature ) const;
};
#endif // QGSVECTORLAYERDIRECTOR_H
|
DFE-Digital/fb-submitter | spec/support/authenticated_method.rb | RSpec.shared_examples 'an authenticated method' do |method, url, payload|
let(:basic_auth) {
password = ENV['<PASSWORD>']
raise unless password.present?
ActionController::HttpAuthentication::Basic.encode_credentials('', password)
}
let(:body) { response.body }
let(:parsed_body) {
JSON.parse(response.body.to_s)
}
context 'with no auth header' do
let(:headers) {
{
'content-type' => 'application/json'
}
}
before do
send method, url, params: payload, headers: headers
end
it 'has status 401' do
expect(response).to have_http_status(401)
end
end
context 'with an auth header' do
before do
send method, url, params: payload, headers: headers
end
let(:headers) do
{
'content-type' => 'application/json',
'authorization' => basic_auth
}
end
context 'which is valid' do
it 'does not respond with an unauthorized or forbidden status' do
expect(response).to_not have_http_status(401)
expect(response).to_not have_http_status(403)
end
end
context 'which is not valid' do
let(:headers) do
{
'content-type' => 'application/json',
'authorization' => 'invalid'
}
end
context 'a request is made' do
it 'has status 401' do
expect(response).to have_http_status(401)
end
end
end
end
end
|
smrz2001/go-ipld-prime | traversal/selector/matcher.go | package selector
import (
"fmt"
"io"
"github.com/ipld/go-ipld-prime/datamodel"
"github.com/ipld/go-ipld-prime/node/basicnode"
)
// Matcher marks a node to be included in the "result" set.
// (All nodes traversed by a selector are in the "covered" set (which is a.k.a.
// "the merkle proof"); the "result" set is a subset of the "covered" set.)
//
// In libraries using selectors, the "result" set is typically provided to
// some user-specified callback.
//
// A selector tree with only "explore*"-type selectors and no Matcher selectors
// is valid; it will just generate a "covered" set of nodes and no "result" set.
// TODO: From spec: implement conditions and labels
type Matcher struct {
*Slice
}
// Slice limits a result node to a subset of the node.
// The returned node will be limited based on slicing the specified range of the
// node into a new node, or making use of the `AsLargeBytes` io.ReadSeeker to
// restrict response with a SectionReader.
type Slice struct {
From int64
To int64
}
func (s Slice) Slice(n datamodel.Node) (datamodel.Node, error) {
var from, to int64
switch n.Kind() {
case datamodel.Kind_String:
str, err := n.AsString()
if err != nil {
return nil, err
}
to = s.To
if len(str) < int(to) {
to = int64(len(str))
}
from = s.From
if len(str) < int(from) {
from = int64(len(str))
}
return basicnode.NewString(str[from:to]), nil
case datamodel.Kind_Bytes:
if lbn, ok := n.(datamodel.LargeBytesNode); ok {
rdr, err := lbn.AsLargeBytes()
if err != nil {
return nil, err
}
sr := io.NewSectionReader(readerat{rdr}, s.From, s.To-s.From)
return basicnode.NewBytesFromReader(sr), nil
}
bytes, err := n.AsBytes()
if err != nil {
return nil, err
}
to = s.To
if len(bytes) < int(to) {
to = int64(len(bytes))
}
from = s.From
if len(bytes) < int(from) {
from = int64(len(bytes))
}
return basicnode.NewBytes(bytes[from:to]), nil
default:
return nil, fmt.Errorf("selector slice rejected on %s: subset match must be over string or bytes", n.Kind())
}
}
// Interests are empty for a matcher (for now) because
// It is always just there to match, not explore further
func (s Matcher) Interests() []datamodel.PathSegment {
return []datamodel.PathSegment{}
}
// Explore will return nil because a matcher is a terminal selector
func (s Matcher) Explore(n datamodel.Node, p datamodel.PathSegment) (Selector, error) {
return nil, nil
}
// Decide is always true for a match cause it's in the result set
// Deprecated: use Match instead
func (s Matcher) Decide(n datamodel.Node) bool {
return true
}
// Match is always true for a match cause it's in the result set
func (s Matcher) Match(node datamodel.Node) (datamodel.Node, error) {
if s.Slice != nil {
return s.Slice.Slice(node)
}
return node, nil
}
// ParseMatcher assembles a Selector
// from a matcher selector node
// TODO: Parse labels and conditions
func (pc ParseContext) ParseMatcher(n datamodel.Node) (Selector, error) {
if n.Kind() != datamodel.Kind_Map {
return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map")
}
// check if a slice is specified
if subset, err := n.LookupByString("subset"); err == nil {
if subset.Kind() != datamodel.Kind_Map {
return nil, fmt.Errorf("selector spec parse rejected: subset body must be a map")
}
from, err := subset.LookupByString("[")
if err != nil {
return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map with a from '[' key")
}
fromN, err := from.AsInt()
if err != nil {
return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map with a 'from' key that is a number")
}
to, err := subset.LookupByString("]")
if err != nil {
return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map with a to ']' key")
}
toN, err := to.AsInt()
if err != nil {
return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map with a 'to' key that is a number")
}
if fromN > toN {
return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map with a 'from' key that is less than or equal to the 'to' key")
}
if fromN < 0 || toN < 0 {
return nil, fmt.Errorf("selector spec parse rejected: selector body must be a map with keys not less than 0")
}
return Matcher{&Slice{
From: fromN,
To: toN,
}}, nil
}
return Matcher{}, nil
}
|
karthik-git-user/SAP-Stage | core-customize/hybris/bin/modules/integration-apis/odata2services/src/de/hybris/platform/odata2services/odata/persistence/lookup/ItemLookupResult.java | <reponame>karthik-git-user/SAP-Stage<filename>core-customize/hybris/bin/modules/integration-apis/odata2services/src/de/hybris/platform/odata2services/odata/persistence/lookup/ItemLookupResult.java
/*
* [y] hybris Platform
*
* Copyright (c) 2018 SAP SE or an SAP affiliate company.
* All rights reserved.
*
* This software is the confidential and proprietary information of SAP
* ("Confidential Information"). You shall not disclose such Confidential
* Information and shall use it only in accordance with the terms of the
* license agreement you entered into with SAP.
*/
package de.hybris.platform.odata2services.odata.persistence.lookup;
import de.hybris.platform.servicelayer.search.SearchResult;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* Result of looking up items by the {@link ItemLookupStrategy}. This result is immutable except it does not guarantee immutability
* of the items returned by {@link #getEntries()} method.
*/
public class ItemLookupResult<T>
{
private final List<T> entries;
private final int totalCount;
private ItemLookupResult(final List<T> entries, final int totalCount)
{
this.entries = Collections.unmodifiableList(entries);
this.totalCount = totalCount;
}
public static <T> ItemLookupResult<T> createFrom(final SearchResult<T> result)
{
return createFrom(result.getResult(), result.getTotalCount());
}
public static <T> ItemLookupResult<T> createFrom(final List<T> entries, final int totalCount)
{
return new ItemLookupResult<>(entries, totalCount);
}
public static <T> ItemLookupResult<T> createFrom(final List<T> entries)
{
return new ItemLookupResult<>(entries, -1);
}
/**
* Retrieves items existing in the platform and matching the request conditions.
* @return all items matching the {@link de.hybris.platform.odata2services.odata.persistence.ItemLookupRequest} conditions or
* a subset of all items in case of a paged request. When no items match the conditions, an empty list is returned.
*/
public List<T> getEntries()
{
return entries;
}
/**
* Retrieves total number of items matching the request conditions and existing in the platform
* @return number of items matching the conditions in the platform. This number may be greater than the number of items returned
* by {@link #getEntries()} method. Negative number indicates that total number of matching items is not calculated/unknown.
*/
public int getTotalCount()
{
return totalCount;
}
/**
* Transforms this result into a result containing different kind of entries.
* @param f a function to be applied to each entry contained in this result
* @param <R> type of the entries in the transformed result
* @return a result containing entries, which were transformed from the original result by applying the specifed function.
*/
public <R> ItemLookupResult<R> map(final Function<T, R> f)
{
final List<R> mapped = getEntries().stream()
.map(f)
.collect(Collectors.toList());
return ItemLookupResult.createFrom(mapped, getTotalCount());
}
}
|
scali/agrest | agrest-sencha/src/main/java/io/agrest/sencha/runtime/encoder/SenchaEncoderService.java | package io.agrest.sencha.runtime.encoder;
import io.agrest.encoder.PropertyMetadataEncoder;
import io.agrest.runtime.encoder.DataEncoderFactory;
import io.agrest.runtime.encoder.EncoderService;
import io.agrest.runtime.encoder.IEncodablePropertyFactory;
import io.agrest.runtime.encoder.IStringConverterFactory;
import io.agrest.runtime.semantics.IRelationshipMapper;
import org.apache.cayenne.di.Inject;
import java.util.Map;
/**
* @since 1.5
*/
public class SenchaEncoderService extends EncoderService {
public SenchaEncoderService(
@Inject IEncodablePropertyFactory attributeEncoderFactory,
@Inject IStringConverterFactory stringConverterFactory,
@Inject IRelationshipMapper relationshipMapper,
@Inject Map<String, PropertyMetadataEncoder> propertyMetadataEncoders) {
super(attributeEncoderFactory, stringConverterFactory, relationshipMapper, propertyMetadataEncoders);
}
@Override
protected DataEncoderFactory dataEncoderFactory() {
return new SenchaDataEncoderFactory(
attributeEncoderFactory,
stringConverterFactory,
relationshipMapper);
}
}
|
lokiworks/codebase | backend/lab/leetcode/src/main/java/com/loki/lab/leetcode/Q8Solution.java | <reponame>lokiworks/codebase
package com.loki.lab.leetcode;
import java.util.HashMap;
import java.util.Map;
public class Q8Solution {
static class Automation{
public int sign = 1;
public long ans = 0;
private String state = "start";
private Map<String, String[]> table = new HashMap<String, String[]>(){{
put("start", new String[]{"start", "signed", "in_number", "end"});
put("signed", new String[]{"end", "end", "in_number", "end"});
put("in_number", new String[]{"end", "end", "in_number", "end"});
put("end", new String[]{"end", "end", "end", "end"});
}};
public void get(char c){
state = table.get(state)[get_col(c)];
if("in_number".equals(state)){
ans = ans*10 + c - '0';
ans = sign == 1 ? Math.min(ans, (long) Integer.MAX_VALUE):Math.max(ans, -(long)Integer.MIN_VALUE);
}else if ("signed".equals(state)){
sign = c == '+' ? 1:-1;
}
}
private int get_col(char c){
if (c == ' '){
return 0;
}
if (c == '+' || c == '-'){
return 1;
}
if (Character.isDigit(c)){
return 2;
}
return 3;
}
}
public static int myAtoi2(String s){
Automation a = new Automation();
for (int i = 0; i < s.length(); i++){
a.get(s.charAt(i));
}
return (int)(a.sign * a.ans);
}
public static int myAtoi(String s) {
int ret = 0;
int flag = 0;
boolean r = false;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (r == false && c == ' ') {
continue;
}
r = true;
if (flag == 0 && (c == '+' || c == '-')) {
if (c == '-') {
flag = -1;
}else{
flag = 1;
}
continue;
}
if (flag == 0){
flag = 1;
}
int num = c - '0';
if (!(num >= 0 && num <= 9)) {
break;
}
if (ret*flag > Integer.MAX_VALUE / 10 || (ret*flag == Integer.MAX_VALUE/10 && num >7)) {
return Integer.MAX_VALUE;
}
if (ret*flag < Integer.MIN_VALUE / 10 || (ret*flag == Integer.MIN_VALUE/10 && num > 8)) {
return Integer.MIN_VALUE;
}
ret = 10 * ret + num;
}
return ret*flag;
}
}
|
neocodejack/burial-plots | burialplots/js/Cart/cart.js | $(document).ready(function () {
});
var addtocart= function (Id) {
var id = Id;
var geturl = $("#addtocart").val();
$.ajax({
url: geturl,
type: "Post",
data: { Id: id },
success:function(result)
{
if (result == "true") {
alert("Product Added To Cart Succefully");
}
else {
alert("Product Not Added To Succefully");
}
}
})
}
var Deletetocart = function (Id) {
var id = Id;
var geturl = $("#deltecart").val();
$.ajax({
url: "/Product/DeleteCart",
type: "Post",
data: { Id: id },
success: function (result) {
if (result == "true") {
alert("Product Deleted To Cart Succefully");
loadcart();
}
else {
alert("Product Not Deleted ");
}
}
})
}
var Checkout = function () {
var geturl = $("#addtocart").val();
$.ajax({
url: "/Product/Payment",
type: "Post",
data: { Id: 1 },
success: function (result) {
if (result !=null) {
window.location = "/Orders/Index";
}
else {
alert("Product Not Purchase Succefully");
}
}
})
}
//var loadcart=function()
//{
// var geturl = $("#relodpage").val();
// $.ajax({
// url: "/Product/Chekout"
// })
//} |
0xd34d10cc/pong | utils/log.h | <filename>utils/log.h
#ifndef LOG_H
#define LOG_H
typedef enum {
LOG_LEVEL_DEBUG,
LOG_LEVEL_INFO,
LOG_LEVEL_WARNING,
LOG_LEVEL_ERROR,
LOG_LEVEL_FATAL
} LogLevel;
void game_log(LogLevel level, const char* file, int line, const char* format, ...);
#define LOG_INFO(...) game_log(LOG_LEVEL_INFO, __FILE__, __LINE__, __VA_ARGS__)
#define LOG_WARN(...) game_log(LOG_LEVEL_WARNING, __FILE__, __LINE__, __VA_ARGS__)
#define LOG_ERROR(...) game_log(LOG_LEVEL_ERROR, __FILE__, __LINE__, __VA_ARGS__)
#define LOG_FATAL(...) game_log(LOG_LEVEL_FATAL, __FILE__, __LINE__, __VA_ARGS__)
#ifdef PONG_DEBUG
#define LOG_DEBUG(...) game_log(LOG_LEVEL_DEBUG, __FILE__, __LINE__, __VA_ARGS__)
#else
#define LOG_DEBUG(...) do { } while(0)
#endif // PONG_DEBUG
#endif // LOG_H
|
jr-ok/docstest | node_modules/rxjs/dist/esm5/internal/operators/takeUntil.js | import { operate } from '../util/lift';
import { OperatorSubscriber } from './OperatorSubscriber';
import { innerFrom } from '../observable/from';
import { noop } from '../util/noop';
export function takeUntil(notifier) {
return operate(function (source, subscriber) {
innerFrom(notifier).subscribe(new OperatorSubscriber(subscriber, function () { return subscriber.complete(); }, undefined, noop));
!subscriber.closed && source.subscribe(subscriber);
});
}
//# sourceMappingURL=takeUntil.js.map |
continuum/neography | spec/unit/rest/node_relationships_spec.rb | <reponame>continuum/neography<filename>spec/unit/rest/node_relationships_spec.rb<gh_stars>0
require 'spec_helper'
module Neography
class Rest
describe NodeRelationships do
let(:connection) { double(:configuration => "http://configuration") }
subject { NodeRelationships.new(connection) }
it "creates a relationship" do
body_hash = { "type" => "some_type",
"to" => "http://configuration/node/43",
"data" => {"foo"=>"bar","baz"=>"qux"}
}
connection.should_receive(:post).with("/node/42/relationships", json_match(:body, body_hash))
subject.create("some_type", "42", "43", {:foo => "bar", :baz => "qux"})
end
it "returns the post results" do
connection.stub(:post).and_return("foo")
subject.create("some_type", "42", "43", {}).should == "foo"
end
it "gets relationships" do
connection.should_receive(:get).with("/node/42/relationships/all")
subject.get("42")
end
it "gets relationships with direction" do
connection.should_receive(:get).with("/node/42/relationships/in")
subject.get("42", :in)
end
it "gets relationships with direction and type" do
connection.should_receive(:get).with("/node/42/relationships/in/foo")
subject.get("42", :in, "foo")
end
it "gets relationships with direction and types" do
connection.should_receive(:get).with("/node/42/relationships/in/foo%26bar")
subject.get("42", :in, ["foo", "bar"])
end
it "returns nil if no relationships were found" do
connection.stub(:get).and_return(nil)
subject.get("42", :in).should be_nil
end
it "returns nil if no relationships were found by type" do
connection.stub(:get).and_return(nil)
subject.get("42", :in, "foo")
end
context "directions" do
[ :incoming, "incoming", :in, "in" ].each do |direction|
it "parses 'in' direction" do
NodeRelationships.new(nil).parse_direction(direction).should == "in"
end
end
[ :outgoing, "outgoing", :out, "out" ].each do |direction|
it "parses 'out' direction" do
NodeRelationships.new(nil).parse_direction(direction).should == "out"
end
end
it "parses 'all' direction by default" do
NodeRelationships.new(nil).parse_direction("foo").should == "all"
end
end
end
end
end
|
ledanck/fJinal | jpress-web/src/main/java/io/jpress/front/controller/IndexController.java | /**
* Copyright (c) 2015-2016, <NAME> 杨福海 (<EMAIL>).
*
* Licensed under the GNU Lesser General Public License (LGPL) ,Version 3.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.gnu.org/licenses/lgpl-3.0.txt
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.jpress.front.controller;
import com.jfinal.render.Render;
import io.jpress.Consts;
import io.jpress.core.BaseFrontController;
import io.jpress.core.addon.HookInvoker;
import io.jpress.core.cache.ActionCache;
import io.jpress.model.query.OptionQuery;
import io.jpress.router.RouterMapping;
import io.jpress.ui.freemarker.tag.IndexPageTag;
import io.jpress.utils.StringUtils;
@RouterMapping(url = "/")
public class IndexController extends BaseFrontController {
//@ActionCache
public void index() {
try {
Render render = onRenderBefore();
if (render != null) {
render(render);
} else {
doRender();
}
} finally {
onRenderAfter();
}
}
private void doRender() {
setGlobleAttrs();
String para = getPara();
if (StringUtils.isBlank(para)) {
setAttr(IndexPageTag.TAG_NAME, new IndexPageTag(getRequest(), null, 1, null));
render("index.html");
return;
}
String[] paras = para.split("-");
if (paras.length == 1) {
if (StringUtils.isNumeric(para.trim())) {
setAttr(IndexPageTag.TAG_NAME, new IndexPageTag(getRequest(), null, StringUtils.toInt(para.trim(), 1), null));
render("index.html");
} else {
setAttr(IndexPageTag.TAG_NAME, new IndexPageTag(getRequest(), para.trim(), 1, null));
render("page_" + para + ".html");
}
} else if (paras.length == 2) {
String pageName = paras[0];
String pageNumber = paras[1];
if (!StringUtils.isNumeric(pageNumber)) {
renderError(404);
}
setAttr(IndexPageTag.TAG_NAME, new IndexPageTag(getRequest(), pageName, StringUtils.toInt(pageNumber, 1), null));
render("page_" + pageName + ".html");
} else {
renderError(404);
}
}
private void setGlobleAttrs() {
String title = OptionQuery.me().findValue("seo_index_title");
String keywords = OptionQuery.me().findValue("seo_index_keywords");
String description = OptionQuery.me().findValue("seo_index_description");
if (StringUtils.isNotBlank(title)) {
setAttr(Consts.ATTR_GLOBAL_WEB_TITLE, title);
}
if (StringUtils.isNotBlank(keywords)) {
setAttr(Consts.ATTR_GLOBAL_META_KEYWORDS, keywords);
}
if (StringUtils.isNotBlank(description)) {
setAttr(Consts.ATTR_GLOBAL_META_DESCRIPTION, description);
}
}
private Render onRenderBefore() {
return HookInvoker.indexRenderBefore(this);
}
private void onRenderAfter() {
HookInvoker.indexRenderAfter(this);
}
}
|
waitingwx/locman_rails | db/migrate/20180125082400_remove_addressid_from_gradorder.rb | <gh_stars>0
class RemoveAddressidFromGradorder < ActiveRecord::Migration[5.1]
def change
remove_column :gradorders, :addressid, :integer
end
end
|
npocmaka/Windows-Server-2003 | inetsrv/query/cicat/pershash.hxx | //+---------------------------------------------------------------------------
//
// Copyright (C) Microsoft Corporation, 1991 - 1998
//
// File: pershash.hxx
//
// Contents: Abstract class for persistent hash table
//
// History: 07-May-97 SitaramR Created from strings.hxx
//
//----------------------------------------------------------------------------
#pragma once
#include <prpstmgr.hxx>
#include <dynstrm.hxx>
#include "chash.hxx"
//+-------------------------------------------------------------------------
//
// Class: CPersHash
//
// Purpose: Abstract class for persistent hash table
//
// History: 07-May-97 SitaramR Created
// 23-Feb-98 KitmanH Added a protected member,
// _fIsReadOnly
//
//--------------------------------------------------------------------------
class CPersHash
{
public:
CPersHash( CPropStoreManager & PropStoreMgr, BOOL fAggressiveGrowth );
virtual ~CPersHash();
virtual BOOL FastInit ( CiStorage * pStorage, ULONG version, BOOL fIsFileIdMap );
virtual void LongInit ( ULONG version, BOOL fDirtyShutdown );
virtual void Empty();
virtual void LokFlush();
void Shutdown ();
protected:
void GrowHashTable();
void GrowToSize( unsigned cElements );
//
// Error recovery.
//
virtual BOOL ReInit( ULONG version );
virtual void HashAll() = 0;
CPropStoreManager & _PropStoreMgr;// Property store manager
CDynStream * _pStreamHash; // Persistent hash stream
CWidHashTable _hTable; // Map fileids to wids (using hash stream)
BOOL _fIsOpen; // If TRUE, successfully opened
BOOL _fAbort; // To abort long operations
BOOL _fFullInit; // Set to TRUE if fully initialized.
BOOL _fIsReadOnly; // TRUE if the catalog is for read only
};
|
eugeneilyin/mdi-norm | es/OutlineSentimentVerySatisfied.js | import React from 'react';
import { Icon } from './Icon';
import { fz, yq } from './fragments';
export var OutlineSentimentVerySatisfied =
/*#__PURE__*/
function OutlineSentimentVerySatisfied(props) {
return React.createElement(Icon, props, React.createElement("path", {
d: "M11.99 2" + fz + "m1-10.06L14.06 11l1.06-1.06L16.18 11l1.06-1.06-2.12-2.12zm-4.12 0L9.94 11 11 9.94 8.88 7.82 6.76 9.94 7.82 11zM12 17.5" + yq
}));
}; |
samesense/mahdi_epi | src/scripts/limit_exac_genes.py | <reponame>samesense/mahdi_epi
import pandas, sys
dat_file, vcf_file, out_file = sys.argv[1:]
df_pre = pandas.read_excel(dat_file)
genes = set(df_pre['Gene Symbol'].values)
with open(vcf_file) as f, open(out_file, 'w') as fout:
for line in f:
if line[0] == '#':
print(line.strip(), file=fout)
else:
sp = line.strip().split('\t')
effs = sp[-3].split('EFF=')[1].split(';')[0].split(',')
for eff in effs:
# downstream_gene_variant(MODIFIER||958|||WASH7P||NON_CODING|NR_024540.1||1)
# print(eff)
gene = eff.split('|')[-6]
if gene in genes:
print(line.strip(), file=fout)
|
euleryang/mysql-server-mysql-323-31 | sql/frm_crypt.cc | /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/*
** change the following to the output of password('<PASSWORD>')
** split into 2 parts of 8 characters each.
** This is done to make it impossible to search after a text string in the
** mysql binary.
*/
#include "mysql_priv.h"
#ifdef HAVE_CRYPTED_FRM
/* password('<PASSWORD>') */
ulong password_seed[2]={0x3<PASSWORD>, 0x220ca493};
SQL_CRYPT *get_crypt_for_frm(void)
{
return new SQL_CRYPT(password_seed);
}
#endif
|
andrewparrish/perigren_github_webhooks | lib/generators/perigren_github_webhooks/templates/perigren_github_webhooks.rb | PerigrenGithubWebhooks.setup do |config|
# https://docs.github.com/en/developers/webhooks-and-events/securing-your-webhooks
config.use_webhooks_secret_auth = true
overrides = "#{Rails.root}/app/overrides"
Rails.autoloaders.main.ignore(overrides)
Rails.application.config.to_prepare do
Dir.glob("#{overrides}/**/*_override.rb").each do |override|
load override
end
end
end
|
Khasms/discord.js-codemod | src/v13.0.0/update-create-role.js | <gh_stars>1-10
const { parser } = require('../util');
module.exports = function transform(file, api, options) {
const j = api.jscodeshift;
const root = j(file.source);
const printOptions = options.printOptions;
return root
.find(j.CallExpression, {
callee: {
property: {
name: 'create',
},
},
arguments: [
{
type: 'ObjectExpression',
properties: [
{
key: {
name: 'data',
},
},
],
},
],
})
.forEach(({ node }) => {
const reason = node.arguments[1];
const newProp = j.objectExpression(node.arguments[0].properties[0].value.properties);
if (reason) {
const reasonProp = j.property('init', j.identifier('reason'), reason);
newProp.properties.push(reasonProp);
}
node.arguments = [newProp];
})
.toSource(printOptions);
};
module.exports.parser = parser;
|
dumitru-tap-at-endava/porta | lib/developer_portal/lib/liquid/drops/site.rb | module Liquid
module Drops
class Site < Drops::Base
allowed_name :site
drop_example "Using site drop in liquid.", %{
<div>Organization name {{ site.company_name }}</div>
<div>Domain (accessed through account) {{ site.account.domain }}</div>
<div>API (accessed through service) {{ site.service.name }}</div>
<div>
<p>Plans</p>
<ul>
{% for plan in site.plans %}
<li>{{ plan.name }}</li>
{% endfor %}
</ul>
</div>
{% if site.forum? %}
<p>The forum is enabled.</p>
{% endif %}
<a href="{{ site.theme_css_link }}">link theme to css</a>
}
def initialize(account, service = account.first_service)
@account = account
@service = service
end
def account
Liquid::Drops::Provider.new(@account)
end
def forum?
@account.settings.forum_enabled?
end
def service
@service
end
def plans
service.published_plans
end
def company_name
@account.org_name
end
def favicon
ThreeScale::Warnings.deprecated_method!(:favicon)
@account.settings.favicon unless account.settings.favicon.blank?
end
def google_tracker_code
ThreeScale::Warnings.deprecated_method!(:google_tracker_code)
@account.settings.tracker_code || nil
end
def theme_css_link
"/css/theme_css.css"
end
def authentication_providers
Drops::Collection
.for_drop(Drops::AuthenticationProvider)
.new(@account.authentication_providers.published)
end
end
end
end
|
FBL-Coder/ChuangKeYuan | src/com/yitong/ChuangKeYuan/utils/UpdateManager.java | <reponame>FBL-Coder/ChuangKeYuan
package com.yitong.ChuangKeYuan.utils;
import android.app.Activity;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;
import com.yitong.ChuangKeYuan.Application.MyApplication;
import com.yitong.ChuangKeYuan.R;
import com.yitong.ChuangKeYuan.widget.CustomDialog_comment;
import com.yitong.ChuangKeYuan.widget.CustomDialog_upload;
import com.yitong.ChuangKeYuan.widget.NumberProgressBar;
import com.yitong.ChuangKeYuan.widget.OnProgressBarListener;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
/**
* 版本更新
*/
public class UpdateManager {
private Context mContext; //上下文
private String apkUrl = DatasUtil.URL_NewApp;//apk下载地址
private static final String savePath = "/sdcard/ChuagKeYuanAPK/"; //apk保存到SD卡的路径
private static final String saveFileName = savePath + "apkName.apk"; //完整路径名
private NumberProgressBar mProgress; //下载进度条控件
private static final int DOWNLOADING = 1; //表示正在下载
private static final int DOWNLOADED = 2; //下载完毕
private static final int DOWNLOAD_FAILED = 3; //下载失败
private int progress; //下载进度
private boolean cancelFlag = false; //取消下载标志位
private int serverVersion; //从服务器获取的版本号
private int clientVersion; //客户端当前的版本号
private String updateDescription = "是否现在更新"; //更新内容描述信息
private boolean forceUpdate = true; //是否强制更新
private Handler mHandler;
private CustomDialog_comment alertDialog1;
private Activity SplashActivity;
private CustomDialog_upload alertDialog2;
/**
* 构造函数
*/
public UpdateManager(Context context, String serverVersion) {
this.mContext = context;
this.serverVersion = Integer.parseInt(serverVersion);
PackageManager packageManager = context.getPackageManager();
// getPackageName()是你当前类的包名，0代表是获取版本信息
PackageInfo packInfo = null;
try {
packInfo = packageManager.getPackageInfo(MyApplication.getContext().getPackageName(), 0);
clientVersion = packInfo.versionCode;
Log.i("UpAPP", "客户端版本号:" + clientVersion);
} catch (PackageManager.NameNotFoundException e) {
Log.i("UpAPP", "检查更新异常:" + e);
}
/**
* 更新UI的handler
*/
mHandler = new Handler(Looper.getMainLooper()) {
@Override
public void handleMessage(Message msg) {
// TODO Auto-generated method stub
switch (msg.what) {
case DOWNLOADING:
// mProgress.incrementProgressBy(progress);
mProgress.setProgress(progress);
break;
case DOWNLOADED:
if (alertDialog2 != null)
alertDialog2.dismiss();
installAPK();
break;
case DOWNLOAD_FAILED:
ToastUtil.showToast(mContext, "网络断开，请稍候再试");
break;
default:
break;
}
}
};
}
/**
* 显示更新对话框
*/
public void showNoticeDialog(final Handler handler) {
//如果版本最新，则不需要更新
if (serverVersion <= clientVersion) {
Message message = handler.obtainMessage();
handler.sendMessage(message);
return;
}
CustomDialog_comment.Builder dialog = new CustomDialog_comment.Builder(mContext);
dialog.setTitle("发现新版本 ：" + serverVersion + "\n 如果安装失败，请在根目录下ChuagKeYuanAPK文件夹中打开apk文件安装！！");
dialog.setMessage(updateDescription);
dialog.setPositiveButton("更新", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface arg0, int arg1) {
// TODO Auto-generated method stub
arg0.dismiss();
showDownloadDialog();
}
});
dialog.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
dialog.dismiss();
Message message = handler.obtainMessage();
handler.sendMessage(message);
}
});
alertDialog1 = dialog.create();
alertDialog1.setCancelable(false);
alertDialog1.show();
}
private OnProgressBarListener listener;
/**
* 显示进度条对话框
*/
public void showDownloadDialog() {
alertDialog2 = new CustomDialog_upload(mContext, R.style.customDialog, R.layout.dialog_progressbar_layout);
alertDialog2.show();
mProgress = (NumberProgressBar) alertDialog2.findViewById(R.id.update_progress);
mProgress.setOnProgressBarListener(listener);
alertDialog2.setCancelable(false);
//下载apk
downloadAPK();
}
/**
* 下载apk的线程
*/
public void downloadAPK() {
new Thread(new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
try {
URL url = new URL(apkUrl);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.connect();
int length = conn.getContentLength();
InputStream is = conn.getInputStream();
File file = new File(savePath);
if (!file.exists()) {
file.mkdir();
}
String apkFile = saveFileName;
File ApkFile = new File(apkFile);
FileOutputStream fos = new FileOutputStream(ApkFile);
int count = 0;
byte buf[] = new byte[1024];
do {
int numread = is.read(buf);
count += numread;
progress = (int) (((float) count / length) * 100);
//更新进度
mHandler.sendEmptyMessage(DOWNLOADING);
if (numread <= 0) {
//下载完成通知安装
mHandler.sendEmptyMessage(DOWNLOADED);
break;
}
fos.write(buf, 0, numread);
} while (!cancelFlag); //点击取消就停止下载.
fos.close();
is.close();
} catch (Exception e) {
Log.i("UpApp", "更新应用异常:" + e);
mHandler.sendEmptyMessage(DOWNLOAD_FAILED);
}
}
}).start();
}
/**
* 下载完成后自动安装apk
*/
public void installAPK() {
File apkFile = new File(saveFileName);
if (!apkFile.exists()) {
return;
}
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.setDataAndType(Uri.parse("file://" + apkFile.toString()), "application/vnd.android.package-archive");
mContext.startActivity(intent);
}
}
|
ibabkov/let_it_code | problems/hash/design_hash_map_210/index.js | <reponame>ibabkov/let_it_code<gh_stars>0
/**
* @link https://leetcode.com/problems/design-hashmap/
* @description
* Your MyHashMap object will be instantiated and called as such:
* var obj = new MyHashMap()
* obj.put(key,value)
* var param_2 = obj.get(key)
* obj.remove(key)
*/
const MyHashMap = function(length) {
this.hashMap = new Array();
};
/**
* get index of array from key string
* @param {number} key
* @param {number} value
* @return {void}
*/
MyHashMap.prototype.put = function (key, val) {
this.hashMap[key] = val;
};
/**
* Returns the value to which the specified key is mapped, or -1 if this map contains no mapping for the key
* @param {number} key
* @return {number}
*/
MyHashMap.prototype.get = function(key) {
const item = this.hashMap[key];
return typeof item === 'undefined' ? -1 : item;
};
/**
* Removes the mapping of the specified value key if this map contains a mapping for the key
* @param {number} key
* @return {void}
*/
MyHashMap.prototype.remove = function(key) {
if (!this.hashMap[key]) return;
delete this.hashMap[key];
};
export { MyHashMap }; |
npirotte/catchapp | src/js/lib/AssetService.js | <reponame>npirotte/catchapp
var Storate = require('../lib/localStorage');
const {serverUrl} = require('../config');
var url = serverUrl + 'assets/upload',
trustHosts = true,
upOptions = {
headers: {
//Authorization : 'Bearer ' + $localStorage.token
}
};
export default function(fileURL, cb)
{
console.log(fileURL, cb);
var { token } = Storate.get('AuthStore', 'object');
var options = new FileUploadOptions();
options.fileKey="file";
options.fileName = fileURL.substr(fileURL.lastIndexOf('/')+1);
options.mimeType="image/jpeg";
options.headers = {
'Authorization' : 'Brearer ' + token
};
var ft = new FileTransfer();
console.log(fileURL, url, win, fail, options);
ft.upload(fileURL, url, win, fail, options);
function win(res)
{
if (res.responseCode === 200) {
return cb(null, JSON.parse(res.response));
}
else
{
return cb(new Error(res.responseCode))
}
}
function fail(err)
{
return cb(err);
}
} |
cbmono/hapijs-MVC-seed-es6 | src/routes/base.routes.spec.js | import { BaseRoutes } from './base.routes';
//
// Tests
//
describe('Routes: Base', () => {
let routes;
let ExtendedRoutes;
const endpoint = 'my-endpoint';
const controller = new class MockedController {
/* eslint-disable */
index() {}
view() {}
create() {}
update() {}
remove() {}
/* eslint-enable */
}();
beforeEach(() => {
ExtendedRoutes = class ext extends BaseRoutes {};
routes = new ExtendedRoutes(controller, endpoint);
});
it('should not instantiated directly', () => {
const createBase = () => new BaseRoutes(controller, endpoint);
expect(createBase).toThrow(Error('BaseRoutes is an abstract class and cannot be instantiated directly'));
});
it('should be defined', () => {
expect(routes).not.toBe(undefined);
expect(routes.joi).not.toBe(undefined);
expect(routes.endpoint).toBe(endpoint);
expect(routes.controller).not.toBe(undefined);
});
it('should throw on empty controller', () => {
try {
new ExtendedRoutes();
}
catch (exc) {
expect(exc.name).toBe('Error');
expect(exc.message).toBe('BaseRoute: controller is undefined');
}
});
it('should throw on empty controller handler', () => {
try {
const emptyCtrl = new class TempController {}();
routes = new ExtendedRoutes(emptyCtrl);
routes.index();
}
catch (exc) {
expect(exc.name).toBe('Error');
expect(exc.message).toBe('BaseRoute: controller handler is undefined');
}
});
it('should expose index()', () => {
const options = routes.index();
expect(options.method).toBe('GET');
expect(options.path).toBe(routes.endpoint);
expect(options.handler).not.toBe(undefined);
});
it('should expose view()', () => {
const options = routes.view();
expect(options.method).toBe('GET');
expect(options.path).toBe(`${routes.endpoint}/{id}`);
expect(options.handler).not.toBe(undefined);
expect(options.config.validate.params.id).not.toBe(undefined);
});
it('should expose create()', () => {
const options = routes.create();
expect(options.method).toBe('POST');
expect(options.path).toBe(routes.endpoint);
expect(options.handler).not.toBe(undefined);
expect(options.config.validate).not.toBe(undefined);
});
it('should expose update()', () => {
const options = routes.update();
expect(options.method).toBe('PUT');
expect(options.path).toBe(`${routes.endpoint}/{id}`);
expect(options.handler).not.toBe(undefined);
expect(options.config.validate.params.id).not.toBe(undefined);
});
it('should expose remove()', () => {
const options = routes.remove();
expect(options.method).toBe('DELETE');
expect(options.path).toBe(`${routes.endpoint}/{id}`);
expect(options.handler).not.toBe(undefined);
expect(options.config.validate.params.id).not.toBe(undefined);
});
});
|
ShantamShorewala/aizynthfinder | tests/data/post_processing_test.py | def post_processing(finder):
return {"quantity": 5, "another_quantity": 10}
|
scleradb/sclera | modules/core/src/main/scala/dbms/rdbms/driver/SqlTableResult.scala | <reponame>scleradb/sclera
/**
* Sclera - Core
* Copyright 2012 - 2020 Sclera, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.scleradb.dbms.rdbms.driver
import java.sql.{Types, ResultSet, ResultSetMetaData, Statement}
import com.scleradb.sql.expr.SortExpr
import com.scleradb.sql.types.SqlType
import com.scleradb.sql.datatypes.Column
import com.scleradb.sql.result.TableResult
class SqlTableResult(
statement: Statement,
queryStr: String,
override val resultOrder: List[SortExpr]
) extends TableResult {
private val resultSet: ResultSet =
try statement.executeQuery(queryStr) catch { case (e: Throwable) =>
statement.close()
throw e
}
private val metaData: ResultSetMetaData = resultSet.getMetaData()
private val nColumns: Int = metaData.getColumnCount()
val columns: List[Column] = (1 to nColumns).toList.map { colIndex =>
val name: String = metaData.getColumnLabel(colIndex)
val colType: Int = metaData.getColumnType(colIndex)
if( colType == Types.ARRAY ) throw new RuntimeException(
"Arrays not supported"
)
val len: Int = metaData.getColumnDisplaySize(colIndex)
val lenOpt: Option[Int] =
if( len >= 0 && len <= SqlType.maxLen ) Some(len)
else None
val readPrec: Int = metaData.getPrecision(colIndex)
val prec: Int = if( readPrec < len - 1 ) (len - 1) else readPrec
val precOpt: Option[Int] =
if( prec >= 0 && prec <= SqlType.maxPrec ) Some(prec)
else None
val scale: Int = metaData.getScale(colIndex)
val scaleOpt: Option[Int] =
if( scale >= 0 && scale <= SqlType.maxScale ) Some(scale)
else None
val className: String = metaData.getColumnClassName(colIndex)
val sqlType: SqlType =
try SqlType(colType, lenOpt, precOpt, scaleOpt, Some(className))
catch { case (e: Throwable) =>
throw new IllegalArgumentException(
"Type of column \"" + name +
"\" is not supported: " + e.getMessage(),
e
)
}
if( metaData.isNullable(colIndex) == ResultSetMetaData.columnNoNulls )
Column(name.toUpperCase, sqlType)
else Column(name.toUpperCase, sqlType.option)
}
override def rows: Iterator[SqlTableRow] = new Iterator[SqlTableRow] {
// need var to avoid incrementing resultSet at each check
var hasNext: Boolean = resultSet.next()
def next(): SqlTableRow = if( hasNext ) {
val valMap: Map[String, Option[java.lang.Object]] = Map() ++
columns.map { col =>
val v: java.lang.Object = resultSet.getObject(col.name)
(col.name.toUpperCase ->
(if( resultSet.wasNull ) None else Some(v)))
}
hasNext = resultSet.next()
SqlTableRow(valMap, columns)
} else Iterator.empty.next()
}
override def close(): Unit = {
resultSet.close()
statement.close()
}
}
object SqlTableResult {
def apply(
statement: Statement,
queryStr: String,
resultOrder: List[SortExpr]
): SqlTableResult = new SqlTableResult(statement, queryStr, resultOrder)
}
|
ghalimi/stdlib | lib/node_modules/@stdlib/bench/harness/test/fixtures/process.js | /**
* @license Apache-2.0
*
* Copyright (c) 2018 The Stdlib Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
'use strict';
// MODULES //
var EventEmitter = require( 'events' ).EventEmitter;
var inherit = require( '@stdlib/utils/inherit' );
// MAIN //
/**
* Creates a mock process object.
*
* @private
* @constructor
* @param {Function} onExit - callback to invoke upon invocation of the `exit` method
* @returns {Process} Process instance
*/
function Process( onExit ) {
if ( !( this instanceof Process ) ) {
return new Process( onExit );
}
EventEmitter.call( this );
this.exit = exit;
this._onExit = onExit;
return this;
/**
* Mock `exit` method.
*
* @private
* @param {integer} code - exit code
*/
function exit( code ) {
onExit( code );
}
}
/*
* Inherit from the `EventEmitter` prototype.
*/
inherit( Process, EventEmitter );
// EXPORTS //
module.exports = Process;
|
ayroti-18/Competitive-Programming | array/Nagendra/Cyclically rotate an array by one.py | <filename>array/Nagendra/Cyclically rotate an array by one.py
#link https://practice.geeksforgeeks.org/problems/cyclically-rotate-an-array-by-one/0#
#code
for _ in range(int(input())):
n = int(input())
arr = list(map(int, input().split()))
b = arr.pop()
if n > 1:
print(b, *arr)
else:
print(b)
|
dfki-asr/morphablegraphs | morphablegraphs/construction/preprocessing/__init__.py | LEN_ROOT = 3
LEN_QUATERNION = 4
LEN_EULER = 3
from .bitvector import gen_foot_contact_annotation
from .semantic_annotation import gen_walk_annotation, gen_synthetic_semantic_annotation_pick_and_place, \
gen_synthetic_semantic_annotation_for_screw, \
gen_synthetic_semantic_annotation_for_transfer, \
create_low_level_semantic_annotation
from .motion_normalization import MotionNormalization
from .motion_dtw import MotionDynamicTimeWarping |
raaahuuulll/chess-concepts | board/tactics/__init__.py | from enum import IntEnum
from typing import Dict, Callable
import chess
from .discovered_attack import is_discovered_attack_see as is_discovered_attack
from .fork import is_fork_see as is_fork
from .pin import is_pin_see as is_pin
from .sacrifice import is_sacrifice_see as is_sacrifice
from .skewer import is_skewer_see as is_skewer
# TODO: consider refactoring to enum.IntFlag if we want them to behave like bit flags
# https://docs.python.org/3/library/enum.html#intflag
class Tactic(IntEnum):
NONE = 0
FORK = 1
DISCOVERED_ATTACK = 2
PIN = 3
SKEWER = 4
SACRIFICE = 5
@classmethod
def detectors(cls) -> Dict["Tactic", Callable[[str, chess.Move], bool]]:
return {
cls.FORK: is_fork,
cls.DISCOVERED_ATTACK: is_discovered_attack,
cls.PIN: is_pin,
cls.SKEWER: is_skewer,
cls.SACRIFICE: is_sacrifice,
}
@classmethod
def detector(cls, tactic: "Tactic") -> Callable[[str, chess.Move], bool]:
return cls.detectors()[tactic]
|
seakers/ExtUtils | dakota-6.3.0.Windows.x86/include/SOGA.hpp | /*
================================================================================
PROJECT:
<NAME> Genetic Algorithms (JEGA)
CONTENTS:
Definition of class SOGA.
NOTES:
See notes under section "Class Definition" of this file.
PROGRAMMERS:
<NAME> (<EMAIL>) (JE)
ORGANIZATION:
Sandia National Laboratories
COPYRIGHT:
See the LICENSE file in the top level JEGA directory.
VERSION:
1.0.0
CHANGES:
Mon Jun 02 14:26:59 2003 - Original Version (JE)
================================================================================
*/
/*
================================================================================
Document This File
================================================================================
*/
/** \file
* \brief Contains the definition of the SOGA class.
*/
/*
================================================================================
Prevent Multiple Inclusions
================================================================================
*/
#ifndef JEGA_ALGORITHMS_SOGA_HPP
#define JEGA_ALGORITHMS_SOGA_HPP
/*
================================================================================
Includes
================================================================================
*/
// JEGAConfig.hpp should be the first include in all JEGA files.
#include <../Utilities/include/JEGAConfig.hpp>
#include <memory> // for auto_ptr
#include <GeneticAlgorithm.hpp>
#include <../Utilities/include/JEGATypes.hpp>
/*
================================================================================
Pre-Namespace Forward Declares
================================================================================
*/
namespace JEGA
{
namespace Utilities
{
class Design;
class SolutionOFSortSet;
}
}
/*
================================================================================
Namespace Aliases
================================================================================
*/
/*
================================================================================
Begin Namespace
================================================================================
*/
namespace JEGA {
namespace Algorithms {
/*
================================================================================
In Namespace File Scope Typedefs
================================================================================
*/
/*
================================================================================
In-Namespace Forward Declares
================================================================================
*/
class SOGA;
/*
================================================================================
Class Definition
================================================================================
*/
/// The class that performs a Single-Objective Genetic Algorithm
/**
* This derived type of GeneticAlgorithm is specialized for single
* objective problems. It seeks the one best solution.
*
* This class differs from the GeneticAlgorithm class by only a small degree.
*
* The SOGA overrides a few virtual methods of the GeneticAlgorithm base class.
* Other than that, the only difference is in its operator group registry.
*/
class JEGA_SL_IEDECL SOGA :
public GeneticAlgorithm
{
/*
============================================================================
Member Data Declarations
============================================================================
*/
private:
/**
* \brief This flag indicates whether or not this class properly
* registered the appropriate operator groups on startup.
*/
static const bool _registered_operator_groups;
/// This is the vector of weights to apply to the objective functions
JEGA::DoubleVector _weights;
/*
============================================================================
Mutators
============================================================================
*/
public:
/// Sets the weights for this algorithm to use.
/**
* \param weights The weights used by this algorithm to create weighted
* sums of objectives.
*/
void
SetWeights(
const JEGA::DoubleVector& weights
);
/*
============================================================================
Accessors
============================================================================
*/
public:
/// Returns the set of weights for this algorithm by const_reference
/**
* \return The weights currently being used by this algorithm to create
* weighted sums of objectives.
*/
inline
const JEGA::DoubleVector&
GetWeights(
) const;
/*
============================================================================
Public Methods
============================================================================
*/
public:
/**
* \brief This static method returns the registry of operator
* groups available to SOGA's.
*
* \return All operator groups that can be used when using a SOGA.
*/
static
GeneticAlgorithmOperatorGroupRegistry&
RegistryOfOperatorGroups(
);
/**
* \brief Considers each discarded Design in the target and takes it
* back if it is optimal compared to the current population.
*
* This may introduce designs into the population that dominate
* existing members. If that is the case and you want a purely non-
* dominated population, then you should take an additional step to
* remove dominated solutions.
*/
virtual
void
ReclaimOptimal(
);
/*
============================================================================
Subclass Visible Methods
============================================================================
*/
protected:
/*
============================================================================
Subclass Overridable Methods
============================================================================
*/
public:
/**
* \brief Retrieves specific parameters for this algorithm.
*
* This method is used to extract needed information for this
* algorithm. It does so using the ParameterExtractor class
* methods. The return value is true if the extraction
* completes successfully and false otherwise.
*
* \param db The database of parameter values from which to do
* retrieval.
* \return true if polling completed successfully and false otherwise.
*/
virtual
bool
PollForParameters(
const JEGA::Utilities::ParameterDatabase& db
);
/// Returns the current set of solutions of this algorithm.
/**
* This returns the set of all Solutions that have the same quality
* as defined by their weighted sums. Only feasible designs are
* considered. If no feasible designs exist, then the return is
* an empty set. If any designs are cached by any operators, they will
* not be included.
*
* The solutions in the returned set are created using the new operator
* but are not "kept track of". It will be up to the user to
* explicitly call "flush" on the returned set when you are done
* with it. This will cause destruction of all the created solutions.
* If this does not happen, there will be a memory leak.
*
* \return The set of solutions currently found by this algorithm
*/
virtual
JEGA::Utilities::DesignOFSortSet
GetCurrentSolution(
) const;
/**
* \brief This method returns the registry of all allowed groups for
* use with a SOGA..
*
* These groups define what operators can be used with this algorithm
* and in what configurations (i.e. what operators can be used with
* what other operators).
*
* \return The registry of all operator groups that can be used with
* a SOGA..
*/
virtual
GeneticAlgorithmOperatorGroupRegistry&
GetOperatorGroupRegistry(
);
/**
* \brief Overriden to look through the current designs and remove
* any that are not optimal.
*
* Removeed designs are placed into the targets discards.
*/
virtual
void
FlushNonOptimal(
);
/**
* \brief Return the name of the type of this GA.
*
* \return The string "soga".
*/
virtual
std::string
GetAlgorithmTypeName(
) const;
protected:
private:
/*
============================================================================
Private Methods
============================================================================
*/
private:
/*
============================================================================
Structors
============================================================================
*/
public:
/// Constructs a SOGA which will use \a target.
/**
* \param target The design target to be used by this algorithm.
* \param log The log into which this and all its operators will log.
*/
SOGA(
JEGA::Utilities::DesignTarget& target,
JEGA::Logging::Logger& log
);
}; // class SOGA
/*
================================================================================
End Namespace
================================================================================
*/
} // namespace Algorithms
} // namespace JEGA
/*
================================================================================
Include Inlined Methods File
================================================================================
*/
#include "./inline/SOGA.hpp.inl"
/*
================================================================================
End of Multiple Inclusion Check
================================================================================
*/
#endif // JEGA_ALGORITHMS_SOGA_HPP
|
Toumani/web-coding-challenge-msa | src/main/java/org/shopzz/shopzzapp/util/ListRequest.java | <filename>src/main/java/org/shopzz/shopzzapp/util/ListRequest.java
package org.shopzz.shopzzapp.util;
import java.io.Serializable;
/**
* A request that need the location of the user to be correctly performed
*/
public class ListRequest extends Request implements Serializable {
private Location location;
public Location getLocation() { return location; }
public void setLocation(Location location) { this.location = location; }
public static final long serialVersionUID = 1L;
}
|
AlSpinks/deephaven-core | DB/src/test/java/io/deephaven/db/v2/utils/IndexTest.java | <filename>DB/src/test/java/io/deephaven/db/v2/utils/IndexTest.java
package io.deephaven.db.v2.utils;
import org.junit.Test;
import static org.junit.Assert.*;
public class IndexTest {
private static class FakeIterator implements Index.Iterator {
long curr = 10;
@Override
public void close() {}
@Override
public long nextLong() {
return --curr;
}
@Override
public boolean hasNext() {
return curr > 0;
}
}
@Test
public void testNegReturnValueIteratorForEach() {
final Index.Iterator it = new FakeIterator();
assertFalse(it.forEachLong((v) -> false));
}
@Test
public void testPosReturnValueIteratorForEach() {
final Index.Iterator it = new FakeIterator();
assertTrue(it.forEachLong((v) -> true));
}
}
|
EugeValeiras/template-ui | gulp/gulp.config.js | import { argv } from 'yargs';
function getEnv(log){
if(argv.dev){
return 'development';
} else if(argv.prod){
return 'production';
} else {
if(log){ console.log('No environment selected => Default: development') }
return 'development';
}
}
function getEnvironmentKeys(dev, prod) {
var env = getEnv(true);
const keys = require(`./environments/${env}.js`);
keys.environment = env;
return keys;
}
export const env = getEnv();
export const environmentKeys = getEnvironmentKeys();
export const vendors = [
'/angular/angular.js',
'/angular-animate/angular-animate.js',
'/angular-aria/angular-aria.js',
'/angular-messages/angular-messages.js',
'/angular-ui-router/release/angular-ui-router.js',
'/angular-local-storage/dist/angular-local-storage.js',
'/angular-material/angular-material.js',
'/angular-material/angular-material.css'
];
export const vars = {
buildPath: './build',
bowerPath: './bower_components',
defaultPort: '3000',
fallbackFile: './build/index.html',
files: {
appAssetsFiles: './src/assets/**/*',
appJsFiles: ['./src/app/**/*.js', '!./src/app/config/*.js'],
appHtmlFiles: './src/app/**/*.html',
jsInjectable : [ './build/app/**/*.js', './build/vendor/**/*.js', './build/assets/css/**/*.css'],
cssInjectable : ['./build/vendor/**/*.css'],
indexFile: './src/index.html',
buildIndexFile: './build/index.html',
jsFiles: ['./src/**/*.js']
},
folders: {
buildAssetsFolder: './build/assets',
buildAppFolder: './build/app',
buildVendorFolder: './build/vendor',
buildConfigFolder: './build/app/config'
}
}; |
mihaibuzgau/facter | lib/src/facts/posix/external_resolvers_factory.cc | #include <leatherman/locale/locale.hpp>
#include <facter/facts/external_resolvers_factory.hpp>
using namespace std;
namespace facter { namespace facts {
shared_ptr<external::resolver> external_resolvers_factory::get_resolver(const string& path) {
auto resolver = get_common_resolver(path);
if (resolver)
return resolver;
throw external::external_fact_no_resolver(leatherman::locale::_("No resolver for external facts file {1}", path));
}
}} // facter::facts
|
DogFc/sharding-jdbc | sharding-jdbc-core/src/main/java/com/dangdang/ddframe/rdb/sharding/rewrite/SQLBuilder.java | <reponame>DogFc/sharding-jdbc
/*
* Copyright 1999-2015 dangdang.com.
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* </p>
*/
package com.dangdang.ddframe.rdb.sharding.rewrite;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
/**
* SQL构建器.
*
* @author gaohongtao
* @author zhangliang
*/
@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
public final class SQLBuilder {
private final List<Object> segments;
private StringBuilder currentSegment;
public SQLBuilder() {
segments = new LinkedList<>();
currentSegment = new StringBuilder();
segments.add(currentSegment);
}
/**
* 追加字面量.
*
* @param literals 字面量
*/
public void appendLiterals(final String literals) {
currentSegment.append(literals);
}
/**
* 追加表占位符.
*
* @param tableName 表名称
*/
public void appendTable(final String tableName) {
segments.add(new TableToken(tableName));
currentSegment = new StringBuilder();
segments.add(currentSegment);
}
/**
* 生成SQL语句.
*
* @param tableTokens 占位符集合
* @return SQL语句
*/
public String toSQL(final Map<String, String> tableTokens) {
StringBuilder result = new StringBuilder();
for (Object each : segments) {
if (each instanceof TableToken && tableTokens.containsKey(((TableToken) each).tableName)) {
result.append(tableTokens.get(((TableToken) each).tableName));
} else {
result.append(each);
}
}
return result.toString();
}
// TODO remove
@Override
public String toString() {
StringBuilder result = new StringBuilder();
for (Object each : segments) {
if (each instanceof TableToken) {
result.append(String.format("[Token(%s)]", ((TableToken) each).tableName));
} else {
result.append(each);
}
}
return result.toString();
}
@RequiredArgsConstructor
private class TableToken {
private final String tableName;
@Override
public String toString() {
return tableName;
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.