text stringlengths 1 1.05M |
|---|
#!/bin/sh
# This calls the pre-push git hook local to the repo
git_dir=$(git rev-parse --git-dir)
if [ -f "$git_dir/hooks/pre-push" ]; then
set -e
"$git_dir/hooks/pre-push" "$@"
set +e
fi |
#!/bin/sh
python translator.py --cpp-header-dir ../include --capi-header-dir ../include/capi --cpptoc-global-impl ../libcef_dll/libcef_dll.cc --ctocpp-global-impl ../libcef_dll/wrapper/libcef_dll_wrapper.cc --cpptoc-dir ../libcef_dll/cpptoc --ctocpp-dir ../libcef_dll/ctocpp --gypi-file ../cef_paths.gypi
|
const { Router } = require("express");
const { useAdmin } = require("../middlewares/auth");
const {
createCause,
deleteCause,
updateCause,
} = require("../controllers/cause");
const { Cause } = require("../models/Cause");
const router = Router();
const getAddCause = async (_req, res) => {
res.render("admin/add-cause");
};
const getUpdateCause = async (req, res) => {
const { id } = req.params;
const cause = await Cause.findOne({ _id: id });
res.render("admin/update-cause", { cause });
};
router
.route("/add-cause")
.get(useAdmin, getAddCause)
.post(useAdmin, createCause);
router
.route("/update-cause/:id")
.get(useAdmin, getUpdateCause)
.post(useAdmin, updateCause);
router.route("/delete-cause/:id").post(useAdmin, deleteCause);
router.route("/causes").get(useAdmin, async (_req, res) => {
return res.render("admin/causes");
});
exports.adminRoutes = router;
|
<reponame>syntaxltd/DroidLocation
package ax.synt.droidlocation;
import android.app.IntentService;
import android.content.Intent;
import android.location.Address;
import android.location.Geocoder;
import android.location.Location;
import android.os.Bundle;
import android.os.ResultReceiver;
import android.text.TextUtils;
import android.util.Log;
import androidx.annotation.WorkerThread;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
public class FetchAddressIntentService extends IntentService {
private String TAG = "AddressService";
protected ResultReceiver receiver;
/**
* Creates an IntentService. Invoked by your subclass's constructor.
*
* //@param name Used to name the worker thread, important only for debugging.
*/
public FetchAddressIntentService() {
super("FetchAddressIntentService");
}
// ...
private void deliverResultToReceiver(int resultCode, String message) {
Bundle bundle = new Bundle();
bundle.putString(DroidConstants.RESULT_DATA_KEY, message);
receiver.send(resultCode, bundle);
}
@WorkerThread
@Override
protected void onHandleIntent(Intent intent) {
if (intent == null) {
return;
}
String errorMessage = "";
receiver = intent.getParcelableExtra(DroidConstants.RECEIVER);
// Check if receiver was properly registered.
if (receiver == null) {
Log.wtf(TAG, "No receiver received. There is nowhere to send the results.");
return;
}
// Get the location passed to this service through an extra.
Location location = intent.getParcelableExtra(
DroidConstants.LOCATION_DATA_EXTRA);
// ...
// Determine whether a Geocoder is available.
if (!Geocoder.isPresent()) {
Log.wtf(TAG,getString(R.string.no_geocoder_available));
return;
}
Geocoder geocoder = new Geocoder(this, Locale.getDefault());
List<Address> addresses = null;
try {
Log.d(TAG,"lat"+ location.getLatitude()+"--------- lon"+
location.getLongitude());
addresses = geocoder.getFromLocation(
location.getLatitude(),
location.getLongitude(),
// In this sample, get just a single address.
1);
} catch (IOException ioException) {
// Catch network or other I/O problems.
errorMessage = getString(R.string.service_not_available);
Log.e(TAG, errorMessage, ioException);
} catch (IllegalArgumentException illegalArgumentException) {
// Catch invalid latitude or longitude values.
errorMessage = getString(R.string.invalid_lat_long_used);
Log.e(TAG, errorMessage + ". " +
"Latitude = " + location.getLatitude() +
", Longitude = " +
location.getLongitude(), illegalArgumentException);
}
// Handle case where no address was found.
if (addresses == null || addresses.size() == 0) {
if (errorMessage.isEmpty()) {
errorMessage = getString(R.string.no_address_found);
Log.e(TAG, errorMessage);
}
deliverResultToReceiver(DroidConstants.FAILURE_RESULT, errorMessage);
} else {
Address address = addresses.get(0);
ArrayList<String> addressFragments = new ArrayList<String>();
// Fetch the address lines using getAddressLine,
// join them, and send them to the thread.
// Fetch the address lines using {@code getAddressLine},
// join them, and send them to the thread. The {@link android.location.address}
// class provides other options for fetching address details that you may prefer
// to use. Here are some examples:
// getLocality() ("Mountain View", for example)
// getAdminArea() ("CA", for example)
// getPostalCode() ("94043", for example)
// getCountryCode() ("US", for example)
// getCountryName() ("United States", for example)
for(int i = 0; i <= address.getMaxAddressLineIndex(); i++) {
addressFragments.add(address.getAddressLine(i));
}
Log.i(TAG, getString(R.string.address_found));
deliverResultToReceiver(DroidConstants.SUCCESS_RESULT,
TextUtils.join(System.getProperty("line.separator"),
addressFragments));
}
}
}
|
#!/bin/bash
wget -nc ftp://Contours_IRIS_ext:ao6Phu5ohJ4jaeji@ftp3.ign.fr/CONTOURS-IRIS_2-1__SHP__FRA_2020-01-01.7z
if [ ! -d CONTOURS-IRIS_2-1__SHP__FRA_2020-01-01 ];then
7z x CONTOURS-IRIS_2-1__SHP__FRA_2020-01-01.7z -aos
fi
|
<!DOCTYPE html>
<html>
<body>
<h2>JavaScript Objects CARS</h2>
<p id="mobil"></p>
<script>
// Create an object:
const car = {type:"Avanza", model:"2000", color:"red"};
// Display some data from the object:
document.getElementById("mobil").innerHTML = "The car type is " + car.type;
</script>
</body>
</html>
|
<gh_stars>0
import * as assert from "assert";
import * as Rx from "rxjs/Rx";
import * as gw2shinies from "./gw2shinies";
import * as data from "./gw2shinies.spec.data.json";
import checkObservable from "./helperspec";
describe("remoteservices/gw2shinies", () => {
const fetchFunction = (url: string) =>
url === "https://www.gw2shinies.com/api/json/forge/" ||
url === "https://www.gw2shinies.com/api/json/forge" ?
Promise.resolve((data as any).gw2shiniesdata as gw2shinies.IMyRecipe[]) :
Promise.reject(`Unknown url ${url}`);
it("return an observable returning all the data at once", () => {
// emulate the data
const observable = gw2shinies.getRecipes(fetchFunction);
return checkObservable(observable, [
{
event: "value",
value: [{
average_yield: "1",
recipe_item_1: "21156",
recipe_item_1_quantity: "2",
recipe_item_2: "19700",
recipe_item_2_quantity: "5",
recipe_item_3: "19722",
recipe_item_3_quantity: "5",
recipe_item_4: "20798",
recipe_item_4_quantity: "1",
target_recipe: "21260",
type: "blueprint",
}],
},
]);
});
});
|
function zigzag(a) {
let maxStreak = 0;
let currStreak = 0;
a.forEach((num, i, arr) => {
currStreak += 1;
if (num === arr[i + 1] || arr[i + 1] === undefined) {
maxStreak = maxStreak > currStreak ? maxStreak : currStreak;
currStreak = 0;
} else if (
!(num > arr[i - 1] && num > arr[i + 1]) &&
!(num < arr[i - 1] && num < arr[i + 1])
) {
maxStreak = maxStreak > currStreak ? maxStreak : currStreak;
currStreak = 1;
}
});
return maxStreak;
}
|
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
#Load dataset
data = pd.read_csv('dataset.csv')
# Create features and target
X = data.drop('subscribe', axis=1)
y = data['subscribe']
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Initialize model and fit data
model = RandomForestClassifier(random_state=0)
model.fit(X_train, y_train)
# Make predictions
y_pred = model.predict(X_test)
# calculate accuracy
accuracy = accuracy_score(y_test, y_pred)
print('Accuracy: {:.2f}'.format(accuracy)) |
import { RankingDataSet } from "@app/interface";
export interface State {
originDataSet: RankingDataSet;
displayDataSet: RankingDataSet;
}
export const DEFAULT_STATE: State = {
originDataSet: {
list: [],
},
displayDataSet: {
list: [],
},
};
|
import numpy as np
# Generate a 3D array
x = np.zeros((2, 3, 2))
# Print the array
print(x) |
import { DEFAULT_STUN_RTC_CONFIG } from '../../../../../api/peer/config'
import { Graph } from '../../../../../Class/Graph'
import { Config } from '../../../../../Class/Unit/Config'
import { $makeUnitRemoteRef } from '../../../../../client/makeUnitRemoteRef'
import { RemoteRef } from '../../../../../client/RemoteRef'
import { EXEC, INIT, TERMINATE } from '../../../../../constant/STRING'
import { $$refGlobalObj } from '../../../../../interface/async/AsyncU_'
import { G } from '../../../../../interface/G'
import { Peer } from '../../../../../Peer'
import { Primitive } from '../../../../../Primitive'
import { evaluate } from '../../../../../spec/evaluate'
import { stringify } from '../../../../../spec/stringify'
export interface I {
pod: G
}
export interface O {
id: string
}
export default class PeerSharePod extends Primitive<I, O> {
_ = ['U']
private _connected: boolean = false
private _peer: Peer
private _ref: RemoteRef
constructor(config?: Config) {
super(
{
i: ['pod', 'answer'],
o: ['offer'],
},
config,
{
input: {
pod: {
ref: true,
},
},
}
)
this.addListener('destroy', () => {
console.log('PeerSharePod', 'destroy')
if (this._connected) {
this._disconnect()
this._close()
}
})
const peer = new Peer(true, DEFAULT_STUN_RTC_CONFIG)
peer.addListener('connect', () => {
console.log('PeerSharePod', 'connect')
this._connected = true
if (this._input.pod.active()) {
this._send_init()
}
})
peer.addListener('close', () => {
console.log('PeerSharePod', 'close')
this._connected = false
})
peer.addListener('message', (message: string): void => {
console.log('PeerSharePod', 'message', message)
if (this._ref) {
const data = evaluate(message, globalThis.__specs)
this._ref.exec(data)
}
})
this._peer = peer
;(async () => {
const offer = await peer.offer()
this._output.offer.push(offer)
})()
}
private _disconnect = () => {
this._send_terminate()
}
private _close = () => {
this._ref = null
}
private _send = (data) => {
const message = stringify(data)
this._peer.send(message)
}
private _send_init = () => {
this._send({ type: INIT })
}
private _send_exec = (data: any) => {
this._send({ type: EXEC, data })
}
private _send_terminate = () => {
this._send({ type: TERMINATE })
}
onRefInputData(name: string, data: any) {
// if (name === 'pod') {
const pod = data as Graph
const { globalId } = pod
const $pod = $$refGlobalObj(globalId, ['$U', '$C', '$G'])
const ref = $makeUnitRemoteRef($pod, ['$U', '$C', '$G'], (data) => {
this._send_exec(data)
})
this._ref = ref
if (this._connected) {
this._send_init()
}
// }
}
onRefInputDrop(name: string) {
// if (name === 'pod') {
this._disconnect()
// }
}
async onDataInputData(name: string, data: any) {
if (name === 'answer') {
await this._peer.acceptAnswer(data)
}
}
async onDataOutputDrop(name: string) {
if (name === 'answer') {
}
}
}
|
<reponame>zhangfeng0415/Zakker
package com.zte.zakker.main.entity;
/**
* Description: <主频道类型><br>
* Author: mxdl<br>
* Date: 2018/12/12<br>
* Version: V1.0.0<br>
* Update: <br>
*/
public enum MainChannel {
NEWS(0,"NEWS"), FIND(1,"FIND"), AUTOMATION(2,"AUTOMATION"), ME(3,"ME");
public int id;
public String name;
MainChannel(int id, String name){
this.id = id;
this.name = name;
}
}
|
def is_valid_tags(s):
s = s.strip("<>")
if s != "":
return True
else:
return False |
pkg_name=erlang
pkg_origin=core
pkg_version=18.3
pkg_dirname=otp_src_${pkg_version}
pkg_license=('erlang')
pkg_maintainer="The Habitat Maintainers <humans@habitat.sh>"
pkg_source=http://www.erlang.org/download/otp_src_${pkg_version}.tar.gz
pkg_filename=otp_src_${pkg_version}.tar.gz
pkg_shasum=fdab8129a1cb935db09f1832e3a7d511a4aeb2b9bb3602ca6a7ccb9730d5c9c3
pkg_deps=(core/glibc core/zlib core/ncurses core/openssl)
pkg_build_deps=(core/coreutils core/gcc core/make core/openssl core/perl)
pkg_bin_dirs=(bin)
pkg_include_dirs=(include)
pkg_lib_dirs=(lib)
do_prepare() {
# The `/bin/pwd` path is hardcoded, so we'll add a symlink if needed.
if [[ ! -r /bin/pwd ]]; then
ln -sv $(pkg_path_for coreutils)/bin/pwd /bin/pwd
_clean_pwd=true
fi
}
do_build() {
./configure --prefix=${pkg_prefix} \
--enable-threads \
--enable-smp-support \
--enable-kernel-poll \
--enable-threads \
--enable-smp-support \
--enable-kernel-poll \
--enable-dynamic-ssl-lib \
--enable-shared-zlib \
--enable-hipe \
--with-ssl=$(pkg_path_for openssl)/lib \
--with-ssl-include=$(pkg_path_for openssl)/include \
--without-javac \
--disable-debug
make
}
do_end() {
# Clean up the `pwd` link, if we set it up.
if [[ -n "$_clean_pwd" ]]; then
rm -fv /bin/pwd
fi
}
|
/*
* JBoss, Home of Professional Open Source.
* Copyright 2016, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software 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 software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.dmr.stream;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.math.BigInteger;
import org.jboss.dmr.ModelType;
import org.junit.Test;
/**
* @author <a href="mailto:<EMAIL>"><NAME></a>
*/
public final class ValidModelReaderTestCase extends AbstractModelStreamsTestCase {
@Override
public ModelReader getModelReader( final String data ) throws IOException {
final ByteArrayInputStream bais = new ByteArrayInputStream( data.getBytes() );
return ModelStreamFactory.getInstance( false ).newModelReader( bais );
}
@Test
public void escapesEncoding() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[\"\\\"\\\\\"]" );
assertListStartState( reader );
assertStringState( reader, "\"\\" );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void emptyObjectWithWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{ \t\r\n}" );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void emptyObjectWithoutWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{}" );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simpleObjectWithWhitespacesWithoutComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{ \t\r\n\"a\" \t\r\n=> \t\r\n\"b\" \t\r\n}" );
assertObjectStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simpleObjectWithoutWhitespacesWithoutComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{\"a\"=>\"b\"}" );
assertObjectStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simpleObjectWithWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{ \t\r\n\"a\" \t\r\n=> \t\r\n\"b\" \t\r\n, \t\r\n}" );
assertObjectStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simpleObjectWithoutWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{\"a\"=>\"b\",}" );
assertObjectStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexObjectWithoutWhitespaces() throws IOException, ModelException {
final String data = "{\"0\"=>\"0\",\"1\"=>1,\"2\"=>2L,\"3\"=>3.0,\"4\"=>true,\"5\"=>undefined,\"6\"=>"
+ "biginteger60000000000000000000000000000,\"7\"=>bigdecimal70000000000000000000000000000.000000000000001,"
+ "\"8\"=>expression\"env.JAVA_HOME\",\"9\"=>bytes{0x00,0x01,0x02,0x03},\"10\"=>{\"\"=>false},\"11\"=>"
+ "[OBJECT],\"12\"=>(\"propKey\"=>PROPERTY),\"hexedInt\"=>0xFFFFFFFF,\"hexedLong\"=>0xFFFFFFFFFFFFFFFFL,"
+ "\"minInt\"=>0x" + Integer.toHexString( Integer.MIN_VALUE ) + ",\"maxInt\"=>0x" + Integer.toHexString( Integer.MAX_VALUE ) + ","
+ "\"zeroInt\"=>0x0,\"zeroLong\"=>0x0L,"
+ "\"minLong\"=>0x" + Long.toHexString( Long.MIN_VALUE ) + "L,\"maxLong\"=>0x" + Long.toHexString( Long.MAX_VALUE ) + "L}";
final ModelReader reader = getModelReader( data );
assertObjectStartState( reader );
assertStringState( reader, "0" );
assertStringState( reader, "0" );
assertStringState( reader, "1" );
assertNumberState( reader, 1 );
assertStringState( reader, "2" );
assertNumberState( reader, 2L );
assertStringState( reader, "3" );
assertNumberState( reader, 3. );
assertStringState( reader, "4" );
assertBooleanState( reader, true );
assertStringState( reader, "5" );
assertUndefinedState( reader );
assertStringState( reader, "6" );
assertNumberState( reader, new BigInteger( "60000000000000000000000000000" ) );
assertStringState( reader, "7" );
assertNumberState( reader, new BigDecimal( "70000000000000000000000000000.000000000000001" ) );
assertStringState( reader, "8" );
assertExpressionState( reader, "env.JAVA_HOME" );
assertStringState( reader, "9" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertStringState( reader, "10" );
assertObjectStartState( reader );
assertStringState( reader, "" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertStringState( reader, "11" );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertListEndState( reader );
assertStringState( reader, "12" );
assertPropertyStartState( reader );
assertStringState( reader, "propKey" );
assertTypeState( reader, ModelType.PROPERTY );
assertPropertyEndState( reader );
assertStringState( reader, "hexedInt" );
assertNumberState( reader, -1 );
assertStringState( reader, "hexedLong" );
assertNumberState( reader, -1L );
assertStringState( reader, "minInt" );
assertNumberState( reader, Integer.MIN_VALUE );
assertStringState( reader, "maxInt" );
assertNumberState( reader, Integer.MAX_VALUE );
assertStringState( reader, "zeroInt" );
assertNumberState( reader, 0 );
assertStringState( reader, "zeroLong" );
assertNumberState( reader, 0L );
assertStringState( reader, "minLong" );
assertNumberState( reader, Long.MIN_VALUE );
assertStringState( reader, "maxLong" );
assertNumberState( reader, Long.MAX_VALUE );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexObjectWithoutWhitespacesWithComma() throws IOException, ModelException {
final String data = "{\"0\"=>\"0\",\"1\"=>1,\"2\"=>2L,\"3\"=>3.0,\"4\"=>true,\"5\"=>undefined,\"6\"=>"
+ "biginteger60000000000000000000000000000,\"7\"=>bigdecimal70000000000000000000000000000.000000000000001,"
+ "\"8\"=>expression\"env.JAVA_HOME\",\"9\"=>bytes{0x00,0x01,0x02,0x03,},\"10\"=>{\"\"=>false,},\"11\"=>"
+ "[OBJECT,],\"12\"=>(\"propKey\"=>PROPERTY)}";
final ModelReader reader = getModelReader( data );
assertObjectStartState( reader );
assertStringState( reader, "0" );
assertStringState( reader, "0" );
assertStringState( reader, "1" );
assertNumberState( reader, 1 );
assertStringState( reader, "2" );
assertNumberState( reader, 2L );
assertStringState( reader, "3" );
assertNumberState( reader, 3. );
assertStringState( reader, "4" );
assertBooleanState( reader, true );
assertStringState( reader, "5" );
assertUndefinedState( reader );
assertStringState( reader, "6" );
assertNumberState( reader, new BigInteger( "60000000000000000000000000000" ) );
assertStringState( reader, "7" );
assertNumberState( reader, new BigDecimal( "70000000000000000000000000000.000000000000001" ) );
assertStringState( reader, "8" );
assertExpressionState( reader, "env.JAVA_HOME" );
assertStringState( reader, "9" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertStringState( reader, "10" );
assertObjectStartState( reader );
assertStringState( reader, "" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertStringState( reader, "11" );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertListEndState( reader );
assertStringState( reader, "12" );
assertPropertyStartState( reader );
assertStringState( reader, "propKey" );
assertTypeState( reader, ModelType.PROPERTY );
assertPropertyEndState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexObjectWithWhitespaces() throws IOException, ModelException {
final String data = "{ \"0\" => \"0\" , \t\"1\" => \t1 \t, \r\"2\" \r=> \r2L \r, \n\"3\" \n=> \n 3.0 \n, \"4\" => true , \"5\" => undefined ,\"6\"=>"
+ "big integer 60000000000000000000000000000, \"7\" => \t\r\nbig \t\r\ndecimal \t\r\n70000000000000000000000000000.000000000000001 \t\r\n,"
+ "\"8\" => expression \t\r\n\"env.JAVA_HOME\", \"9\" => \t\r\nbytes \t\r\n{ \t\r\n0x00 \t\r\n, \t\r\n0x01 \t\r\n, \t\r\n0x02"
+ " \t\r\n, \t\r\n0x03},\"10\" => {\"\"=>false \t\r\n},\"11\" \t\r\n=> \t\r\n[ \t\r\nOBJECT ] , \"12\" => ( \t\r\n\"propKey\" => PROPERTY ) \t\r\n}";
final ModelReader reader = getModelReader( data );
assertObjectStartState( reader );
assertStringState( reader, "0" );
assertStringState( reader, "0" );
assertStringState( reader, "1" );
assertNumberState( reader, 1 );
assertStringState( reader, "2" );
assertNumberState( reader, 2L );
assertStringState( reader, "3" );
assertNumberState( reader, 3. );
assertStringState( reader, "4" );
assertBooleanState( reader, true );
assertStringState( reader, "5" );
assertUndefinedState( reader );
assertStringState( reader, "6" );
assertNumberState( reader, new BigInteger( "60000000000000000000000000000" ) );
assertStringState( reader, "7" );
assertNumberState( reader, new BigDecimal( "70000000000000000000000000000.000000000000001" ) );
assertStringState( reader, "8" );
assertExpressionState( reader, "env.JAVA_HOME" );
assertStringState( reader, "9" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertStringState( reader, "10" );
assertObjectStartState( reader );
assertStringState( reader, "" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertStringState( reader, "11" );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertListEndState( reader );
assertStringState( reader, "12" );
assertPropertyStartState( reader );
assertStringState( reader, "propKey" );
assertTypeState( reader, ModelType.PROPERTY );
assertPropertyEndState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexObjectWithWhitespacesWithComma() throws IOException, ModelException {
final String data = "{ \"0\" => \"0\" , \t\"1\" => \t1 \t, \r\"2\" \r=> \r2L \r, \n\"3\" \n=> \n 3.0 \n, \"4\" => true , \"5\" => undefined ,\"6\"=>"
+ "big integer 60000000000000000000000000000, \"7\" => \t\r\nbig \t\r\ndecimal \t\r\n70000000000000000000000000000.000000000000001 \t\r\n,"
+ "\"8\" => expression \t\r\n\"env.JAVA_HOME\", \"9\" => \t\r\nbytes \t\r\n{ \t\r\n0x00 \t\r\n, \t\r\n0x01 \t\r\n, \t\r\n0x02"
+ " \t\r\n, \t\r\n0x03 \t\r\n, \t\r\n},\"10\" => {\"\"=>false \t\r\n, \t\r\n},\"11\" \t\r\n=> \t\r\n[ \t\r\nOBJECT, ] , \"12\" => ( \t\r\n\"propKey\" => PROPERTY ) \t\r\n}";
final ModelReader reader = getModelReader( data );
assertObjectStartState( reader );
assertStringState( reader, "0" );
assertStringState( reader, "0" );
assertStringState( reader, "1" );
assertNumberState( reader, 1 );
assertStringState( reader, "2" );
assertNumberState( reader, 2L );
assertStringState( reader, "3" );
assertNumberState( reader, 3. );
assertStringState( reader, "4" );
assertBooleanState( reader, true );
assertStringState( reader, "5" );
assertUndefinedState( reader );
assertStringState( reader, "6" );
assertNumberState( reader, new BigInteger( "60000000000000000000000000000" ) );
assertStringState( reader, "7" );
assertNumberState( reader, new BigDecimal( "70000000000000000000000000000.000000000000001" ) );
assertStringState( reader, "8" );
assertExpressionState( reader, "env.JAVA_HOME" );
assertStringState( reader, "9" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertStringState( reader, "10" );
assertObjectStartState( reader );
assertStringState( reader, "" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertStringState( reader, "11" );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertListEndState( reader );
assertStringState( reader, "12" );
assertPropertyStartState( reader );
assertStringState( reader, "propKey" );
assertTypeState( reader, ModelType.PROPERTY );
assertPropertyEndState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexObject() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{\"0\"=>{\"String\"=>\"s\",\"boolean\"=>false},\"1\"=>[undefined,true,7,{}]}" );
assertObjectStartState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void emptyListWithWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[ \t\r\n]" );
assertListStartState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void emptyListWithoutWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[]" );
assertListStartState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simpleListWithWhitespacesWithoutComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[ { \t\r\n\"a\" \t\r\n=> \t\r\n\"b\" \t\r\n} \t\r\n]" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertObjectEndState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simpleListWithoutWhitespacesWithoutComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[{\"a\"=>\"b\"}]" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertObjectEndState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simpleListWithWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[ { \t\r\n\"a\" \t\r\n=> \t\r\n\"b\" \t\r\n} \t\r\n, \t\r\n]" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertObjectEndState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simpleListWithoutWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[{\"a\"=>\"b\"},]" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertObjectEndState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexListWithWhitespaces() throws IOException, ModelException {
final String data = "[ \"0\" \r\n, 1 \r\n, 2L \r\n, 3.0 \r\n, \r\n{ \r\n} \r\n, \r\n[ \r\n] \r\n, \r\n ( \"\" \r\n=> \t\r\nEXPRESSION \t\r\n) , bytes { \t\r\n} , expression \t\r\n\"\","
+ "big integer 400000000000000000000000000000000000000, big decimal 500000000000000000000000000000000000000.000000000000000000000000000009 \r\n, true \r\n, undefined \r\n]";
final ModelReader reader = getModelReader( data );
assertListStartState( reader );
assertStringState( reader, "0" );
assertNumberState( reader, 1 );
assertNumberState( reader, 2L );
assertNumberState( reader, 3.0 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "" );
assertTypeState( reader, ModelType.EXPRESSION );
assertPropertyEndState( reader );
assertBytesState( reader, new byte[] {} );
assertExpressionState( reader, "" );
assertNumberState( reader, new BigInteger( "400000000000000000000000000000000000000" ) );
assertNumberState( reader, new BigDecimal( "500000000000000000000000000000000000000.000000000000000000000000000009" ) );
assertBooleanState( reader, true );
assertUndefinedState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexListWithoutWhitespaces() throws IOException, ModelException {
final String data = "[\"0\",1,2L,3.0,{},[],(\"\"=>EXPRESSION),bytes{},expression\"\","
+ "biginteger40000000000000000000000000000,bigdecimal5000000000000000000000000000000000.0000000000000000000000009,true,undefined]";
final ModelReader reader = getModelReader( data );
assertListStartState( reader );
assertStringState( reader, "0" );
assertNumberState( reader, 1 );
assertNumberState( reader, 2L );
assertNumberState( reader, 3.0 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "" );
assertTypeState( reader, ModelType.EXPRESSION );
assertPropertyEndState( reader );
assertBytesState( reader, new byte[] {} );
assertExpressionState( reader, "" );
assertNumberState( reader, new BigInteger( "40000000000000000000000000000" ) );
assertNumberState( reader, new BigDecimal( "5000000000000000000000000000000000.0000000000000000000000009" ) );
assertBooleanState( reader, true );
assertUndefinedState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexListWithWhitespacesWithComma() throws IOException, ModelException {
final String data = "[ \"0\" \r\n, 1 \r\n, 2L \r\n, 3.0 \r\n, \r\n{ \"BOOLEAN\" => undefined, } \r\n, \r\n[ LIST , \r\n] \r\n, \r\n ( \"\" \r\n=> \t\r\nEXPRESSION \t\r\n) , bytes { 0x00,\t\r\n} , expression \t\r\n\"\","
+ "big integer 400000000000000000000000000000000000000, big decimal 500000000000000000000000000000000000000.000000000000000000000000000009 \r\n, true \r\n, undefined \r\n,]";
final ModelReader reader = getModelReader( data );
assertListStartState( reader );
assertStringState( reader, "0" );
assertNumberState( reader, 1 );
assertNumberState( reader, 2L );
assertNumberState( reader, 3.0 );
assertObjectStartState( reader );
assertStringState( reader, "BOOLEAN" );
assertUndefinedState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.LIST );
assertListEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "" );
assertTypeState( reader, ModelType.EXPRESSION );
assertPropertyEndState( reader );
assertBytesState( reader, new byte[] { 0 } );
assertExpressionState( reader, "" );
assertNumberState( reader, new BigInteger( "400000000000000000000000000000000000000" ) );
assertNumberState( reader, new BigDecimal( "500000000000000000000000000000000000000.000000000000000000000000000009" ) );
assertBooleanState( reader, true );
assertUndefinedState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexListWithoutWhitespacesWithComma() throws IOException, ModelException {
final String data = "[\"0\",1,2L,3.0,{\"BOOLEAN\"=>undefined,},[LIST,],(\"\"=>EXPRESSION),bytes{0x00,},expression\"\","
+ "biginteger40000000000000000000000000000,bigdecimal5000000000000000000000000000000000.0000000000000000000000009,true,undefined,]";
final ModelReader reader = getModelReader( data );
assertListStartState( reader );
assertStringState( reader, "0" );
assertNumberState( reader, 1 );
assertNumberState( reader, 2L );
assertNumberState( reader, 3.0 );
assertObjectStartState( reader );
assertStringState( reader, "BOOLEAN" );
assertUndefinedState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.LIST );
assertListEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "" );
assertTypeState( reader, ModelType.EXPRESSION );
assertPropertyEndState( reader );
assertBytesState( reader, new byte[] { 0 } );
assertExpressionState( reader, "" );
assertNumberState( reader, new BigInteger( "40000000000000000000000000000" ) );
assertNumberState( reader, new BigDecimal( "5000000000000000000000000000000000.0000000000000000000000009" ) );
assertBooleanState( reader, true );
assertUndefinedState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexPropertyWithWhitespaces() throws IOException, ModelException {
final String data = "(\"moreComplexPropertyKey\"=>[ \"0\" \r\n, 1 \r\n, 2L \r\n, 3.0 \r\n, \r\n{ \r\n} \r\n, \r\n[ \r\n] \r\n, \r\n ( \"\" \r\n=> \t\r\nEXPRESSION \t\r\n) , bytes { \t\r\n} , expression \t\r\n\"\","
+ "big integer 400000000000000000000000000000000000000, big decimal 500000000000000000000000000000000000000.000000000000000000000000000009 \r\n, true \r\n, undefined \r\n])";
final ModelReader reader = getModelReader( data );
assertPropertyStartState( reader );
assertStringState( reader, "moreComplexPropertyKey" );
assertListStartState( reader );
assertStringState( reader, "0" );
assertNumberState( reader, 1 );
assertNumberState( reader, 2L );
assertNumberState( reader, 3.0 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "" );
assertTypeState( reader, ModelType.EXPRESSION );
assertPropertyEndState( reader );
assertBytesState( reader, new byte[] {} );
assertExpressionState( reader, "" );
assertNumberState( reader, new BigInteger( "400000000000000000000000000000000000000" ) );
assertNumberState( reader, new BigDecimal( "500000000000000000000000000000000000000.000000000000000000000000000009" ) );
assertBooleanState( reader, true );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexPropertyWithoutWhitespaces() throws IOException, ModelException {
final String data = "(\"moreComplexPropertyKey\"=>[\"0\",1,2L,3.0,{},[],(\"\"=>EXPRESSION),bytes{},expression\"\","
+ "biginteger40000000000000000000000000000,bigdecimal5000000000000000000000000000000000.0000000000000000000000009,true,undefined])";
final ModelReader reader = getModelReader( data );
assertPropertyStartState( reader );
assertStringState( reader, "moreComplexPropertyKey" );
assertListStartState( reader );
assertStringState( reader, "0" );
assertNumberState( reader, 1 );
assertNumberState( reader, 2L );
assertNumberState( reader, 3.0 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "" );
assertTypeState( reader, ModelType.EXPRESSION );
assertPropertyEndState( reader );
assertBytesState( reader, new byte[] {} );
assertExpressionState( reader, "" );
assertNumberState( reader, new BigInteger( "40000000000000000000000000000" ) );
assertNumberState( reader, new BigDecimal( "5000000000000000000000000000000000.0000000000000000000000009" ) );
assertBooleanState( reader, true );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexPropertyWithWhitespacesWithComma() throws IOException, ModelException {
final String data = "(\"moreComplexPropertyKey\"=>[ \"0\" \r\n, 1 \r\n, 2L \r\n, 3.0 \r\n, \r\n{ \"BOOLEAN\" => undefined, } \r\n, \r\n[ LIST , \r\n] \r\n, \r\n ( \"\" \r\n=> \t\r\nEXPRESSION \t\r\n) , bytes { 0x00,\t\r\n} , expression \t\r\n\"\","
+ "big integer 400000000000000000000000000000000000000, big decimal 500000000000000000000000000000000000000.000000000000000000000000000009 \r\n, true \r\n, undefined \r\n,])";
final ModelReader reader = getModelReader( data );
assertPropertyStartState( reader );
assertStringState( reader, "moreComplexPropertyKey" );
assertListStartState( reader );
assertStringState( reader, "0" );
assertNumberState( reader, 1 );
assertNumberState( reader, 2L );
assertNumberState( reader, 3.0 );
assertObjectStartState( reader );
assertStringState( reader, "BOOLEAN" );
assertUndefinedState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.LIST );
assertListEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "" );
assertTypeState( reader, ModelType.EXPRESSION );
assertPropertyEndState( reader );
assertBytesState( reader, new byte[] { 0 } );
assertExpressionState( reader, "" );
assertNumberState( reader, new BigInteger( "400000000000000000000000000000000000000" ) );
assertNumberState( reader, new BigDecimal( "500000000000000000000000000000000000000.000000000000000000000000000009" ) );
assertBooleanState( reader, true );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void moreComplexPropertyWithoutWhitespacesWithComma() throws IOException, ModelException {
final String data = "(\"moreComplexPropertyKey\"=>[\"0\",1,2L,3.0,{\"BOOLEAN\"=>undefined,},[LIST,],(\"\"=>EXPRESSION),bytes{0x00,},expression\"\","
+ "biginteger40000000000000000000000000000,bigdecimal5000000000000000000000000000000000.0000000000000000000000009,true,undefined,])";
final ModelReader reader = getModelReader( data );
assertPropertyStartState( reader );
assertStringState( reader, "moreComplexPropertyKey" );
assertListStartState( reader );
assertStringState( reader, "0" );
assertNumberState( reader, 1 );
assertNumberState( reader, 2L );
assertNumberState( reader, 3.0 );
assertObjectStartState( reader );
assertStringState( reader, "BOOLEAN" );
assertUndefinedState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.LIST );
assertListEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "" );
assertTypeState( reader, ModelType.EXPRESSION );
assertPropertyEndState( reader );
assertBytesState( reader, new byte[] { 0 } );
assertExpressionState( reader, "" );
assertNumberState( reader, new BigInteger( "40000000000000000000000000000" ) );
assertNumberState( reader, new BigDecimal( "5000000000000000000000000000000000.0000000000000000000000009" ) );
assertBooleanState( reader, true );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexListWithoutWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[{\"list\"=>[{\"expr\"=>expression\"\",\"BTS\"=>bytes{0x00,0x01,0x02,0x03}}]},\"0\",{\"String\"=>\"s\",\"boolean\"=>false},(\"booleans\"=>[true,false,undefined]),\"1\",[undefined,true,7,{},[["
+ "OBJECT,LIST,PROPERTY,STRING,INT,LONG,DOUBLE,BIG_INTEGER,BIG_DECIMAL,BYTES,EXPRESSION,TYPE,BOOLEAN,UNDEFINED]]]]" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexListWithWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[ { \r\"list\"\t=> [\r{\t\"expr\" => expression \t\r\n\"\" , \"BTS\" => bytes{ 0x00 , 0x01 , 0x02 , 0x03 } } ] } , \"0\" \t\r\n, \t\r\n{ \"String\" => \"s\" , \"boolean\" \r=> false } , (\"booleans\" => [ true , false , undefined]) , \"1\", [ undefined , true,7,{},[["
+ "OBJECT \t\r\n, \t\nLIST \t\n, \t\nPROPERTY \t\n, \t\nSTRING \t\n, \t\nINT \t\n, \t\nLONG \t\n, \t\nDOUBLE \t\n, \t\nBIG_INTEGER \t\n, \t\nBIG_DECIMAL \t\n, \t\nBYTES \t\n, \t\nEXPRESSION \t\n, \t\nTYPE \t\n, \t\nBOOLEAN \t\n, \t\nUNDEFINED ] ] ] ]" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexListWithoutWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[{\"list\"=>[{\"expr\"=>expression\"\",\"BTS\"=>bytes{0x00,0x01,0x02,0x03,},},]},\"0\",{\"String\"=>\"s\",\"boolean\"=>false},(\"booleans\"=>[true,false,undefined,]),\"1\",[undefined,true,7,{},[["
+ "OBJECT,LIST,PROPERTY,STRING,INT,LONG,DOUBLE,BIG_INTEGER,BIG_DECIMAL,BYTES,EXPRESSION,TYPE,BOOLEAN,UNDEFINED,]]],]" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexListWithWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "[ { \r\"list\"\t=> [\r{\t\"expr\" => expression \t\r\n\"\" , \"BTS\" => bytes{ 0x00 , 0x01 , 0x02 , 0x03 , } } , ] , } , \"0\" \t\r\n, \t\r\n{ \"String\" => \"s\" , \"boolean\" \r=> false , } , (\"booleans\" => [ true , false , undefined, ]) , \"1\", [ undefined , true,7,{},[["
+ "OBJECT \t\r\n, \t\nLIST \t\n, \t\nPROPERTY \t\n, \t\nSTRING \t\n, \t\nINT \t\n, \t\nLONG \t\n, \t\nDOUBLE \t\n, \t\nBIG_INTEGER \t\n, \t\nBIG_DECIMAL \t\n, \t\nBYTES \t\n, \t\nEXPRESSION \t\n, \t\nTYPE \t\n, \t\nBOOLEAN \t\n, \t\nUNDEFINED , ] ] ], ]" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexObjectWithoutWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{\"the Most Complex Object\"=>[{\"list\"=>[{\"expr\"=>expression\"\",\"BTS\"=>bytes{0x00,0x01,0x02,0x03}}]},\"0\",{\"String\"=>\"s\",\"boolean\"=>false},(\"booleans\"=>[true,false,undefined]),\"1\",[undefined,true,7,{},[["
+ "OBJECT,LIST,PROPERTY,STRING,INT,LONG,DOUBLE,BIG_INTEGER,BIG_DECIMAL,BYTES,EXPRESSION,TYPE,BOOLEAN,UNDEFINED]]]]}" );
assertObjectStartState( reader );
assertStringState( reader, "the Most Complex Object" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexObjectWithWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{ \"the Most Complex Object\" => [ { \r\"list\"\t=> [\r{\t\"expr\" => expression \t\r\n\"\" , \"BTS\" => bytes{ 0x00 , 0x01 , 0x02 , 0x03 } } ] } , \"0\" \t\r\n, \t\r\n{ \"String\" => \"s\" , \"boolean\" \r=> false } , (\"booleans\" => [ true , false , undefined]) , \"1\", [ undefined , true,7,{},[["
+ "OBJECT \t\r\n, \t\nLIST \t\n, \t\nPROPERTY \t\n, \t\nSTRING \t\n, \t\nINT \t\n, \t\nLONG \t\n, \t\nDOUBLE \t\n, \t\nBIG_INTEGER \t\n, \t\nBIG_DECIMAL \t\n, \t\nBYTES \t\n, \t\nEXPRESSION \t\n, \t\nTYPE \t\n, \t\nBOOLEAN \t\n, \t\nUNDEFINED ] ] ] ] }" );
assertObjectStartState( reader );
assertStringState( reader, "the Most Complex Object" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexObjectWithoutWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{\"the Most Complex Object\"=>[{\"list\"=>[{\"expr\"=>expression\"\",\"BTS\"=>bytes{0x00,0x01,0x02,0x03,},},]},\"0\",{\"String\"=>\"s\",\"boolean\"=>false},(\"booleans\"=>[true,false,undefined,]),\"1\",[undefined,true,7,{},[["
+ "OBJECT,LIST,PROPERTY,STRING,INT,LONG,DOUBLE,BIG_INTEGER,BIG_DECIMAL,BYTES,EXPRESSION,TYPE,BOOLEAN,UNDEFINED,]]],]}" );
assertObjectStartState( reader );
assertStringState( reader, "the Most Complex Object" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostObjectListWithWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "{ \"the Most Complex Object\" => [ { \r\"list\"\t=> [\r{\t\"expr\" => expression \t\r\n\"\" , \"BTS\" => bytes{ 0x00 , 0x01 , 0x02 , 0x03 , } } , ] , } , \"0\" \t\r\n, \t\r\n{ \"String\" => \"s\" , \"boolean\" \r=> false , } , (\"booleans\" => [ true , false , undefined, ]) , \"1\", [ undefined , true,7,{},[["
+ "OBJECT \t\r\n, \t\nLIST \t\n, \t\nPROPERTY \t\n, \t\nSTRING \t\n, \t\nINT \t\n, \t\nLONG \t\n, \t\nDOUBLE \t\n, \t\nBIG_INTEGER \t\n, \t\nBIG_DECIMAL \t\n, \t\nBYTES \t\n, \t\nEXPRESSION \t\n, \t\nTYPE \t\n, \t\nBOOLEAN \t\n, \t\nUNDEFINED , ] ] ], ], }" );
assertObjectStartState( reader );
assertStringState( reader, "the Most Complex Object" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexPropertyWithoutWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "(\"the Most Complex Property\"=>{\"bar\"=>[{\"list\"=>[{\"expr\"=>expression\"\",\"BTS\"=>bytes{0x00,0x01,0x02,0x03}}]},\"0\",{\"String\"=>\"s\",\"boolean\"=>false},(\"booleans\"=>[true,false,undefined]),\"1\",[undefined,true,7,{},[["
+ "OBJECT,LIST,PROPERTY,STRING,INT,LONG,DOUBLE,BIG_INTEGER,BIG_DECIMAL,BYTES,EXPRESSION,TYPE,BOOLEAN,UNDEFINED]]]]})" );
assertPropertyStartState( reader );
assertStringState( reader, "the Most Complex Property" );
assertObjectStartState( reader );
assertStringState( reader, "bar" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexPropertyWithWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "( \"the Most Complex Property\" => { \"bar\" => [ { \r\"list\"\t=> [\r{\t\"expr\" => expression \t\r\n\"\" , \"BTS\" => bytes{ 0x00 , 0x01 , 0x02 , 0x03 } } ] } , \"0\" \t\r\n, \t\r\n{ \"String\" => \"s\" , \"boolean\" \r=> false } , (\"booleans\" => [ true , false , undefined]) , \"1\", [ undefined , true,7,{},[["
+ "OBJECT \t\r\n, \t\nLIST \t\n, \t\nPROPERTY \t\n, \t\nSTRING \t\n, \t\nINT \t\n, \t\nLONG \t\n, \t\nDOUBLE \t\n, \t\nBIG_INTEGER \t\n, \t\nBIG_DECIMAL \t\n, \t\nBYTES \t\n, \t\nEXPRESSION \t\n, \t\nTYPE \t\n, \t\nBOOLEAN \t\n, \t\nUNDEFINED ] ] ] ] } )" );
assertPropertyStartState( reader );
assertStringState( reader, "the Most Complex Property" );
assertObjectStartState( reader );
assertStringState( reader, "bar" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexPropertyWithoutWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "(\"the Most Complex Property\"=>{\"bar\"=>[{\"list\"=>[{\"expr\"=>expression\"\",\"BTS\"=>bytes{0x00,0x01,0x02,0x03,},},]},\"0\",{\"String\"=>\"s\",\"boolean\"=>false},(\"booleans\"=>[true,false,undefined,]),\"1\",[undefined,true,7,{},[["
+ "OBJECT,LIST,PROPERTY,STRING,INT,LONG,DOUBLE,BIG_INTEGER,BIG_DECIMAL,BYTES,EXPRESSION,TYPE,BOOLEAN,UNDEFINED,]]],]})" );
assertPropertyStartState( reader );
assertStringState( reader, "the Most Complex Property" );
assertObjectStartState( reader );
assertStringState( reader, "bar" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void theMostComplexPropertyListWithWhitespacesWithComma() throws IOException, ModelException {
final ModelReader reader = getModelReader( "( \"the Most Complex Property\" => { \"bar\" => [ { \r\"list\"\t=> [\r{\t\"expr\" => expression \t\r\n\"\" , \"BTS\" => bytes{ 0x00 , 0x01 , 0x02 , 0x03 , } } , ] , } , \"0\" \t\r\n, \t\r\n{ \"String\" => \"s\" , \"boolean\" \r=> false , } , (\"booleans\" => [ true , false , undefined, ]) , \"1\", [ undefined , true,7,{},[["
+ "OBJECT \t\r\n, \t\nLIST \t\n, \t\nPROPERTY \t\n, \t\nSTRING \t\n, \t\nINT \t\n, \t\nLONG \t\n, \t\nDOUBLE \t\n, \t\nBIG_INTEGER \t\n, \t\nBIG_DECIMAL \t\n, \t\nBYTES \t\n, \t\nEXPRESSION \t\n, \t\nTYPE \t\n, \t\nBOOLEAN \t\n, \t\nUNDEFINED , ] ] ], ], })" );
assertPropertyStartState( reader );
assertStringState( reader, "the Most Complex Property" );
assertObjectStartState( reader );
assertStringState( reader, "bar" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "list" );
assertListStartState( reader );
assertObjectStartState( reader );
assertStringState( reader, "expr" );
assertExpressionState( reader, "" );
assertStringState( reader, "BTS" );
assertBytesState( reader, new byte[] { 0, 1, 2, 3 } );
assertObjectEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertStringState( reader, "0" );
assertObjectStartState( reader );
assertStringState( reader, "String" );
assertStringState( reader, "s" );
assertStringState( reader, "boolean" );
assertBooleanState( reader, false );
assertObjectEndState( reader );
assertPropertyStartState( reader );
assertStringState( reader, "booleans" );
assertListStartState( reader );
assertBooleanState( reader, true );
assertBooleanState( reader, false );
assertUndefinedState( reader );
assertListEndState( reader );
assertPropertyEndState( reader );
assertStringState( reader, "1" );
assertListStartState( reader );
assertUndefinedState( reader );
assertBooleanState( reader, true );
assertNumberState( reader, 7 );
assertObjectStartState( reader );
assertObjectEndState( reader );
assertListStartState( reader );
assertListStartState( reader );
assertTypeState( reader, ModelType.OBJECT );
assertTypeState( reader, ModelType.LIST );
assertTypeState( reader, ModelType.PROPERTY );
assertTypeState( reader, ModelType.STRING );
assertTypeState( reader, ModelType.INT );
assertTypeState( reader, ModelType.LONG );
assertTypeState( reader, ModelType.DOUBLE );
assertTypeState( reader, ModelType.BIG_INTEGER );
assertTypeState( reader, ModelType.BIG_DECIMAL );
assertTypeState( reader, ModelType.BYTES );
assertTypeState( reader, ModelType.EXPRESSION );
assertTypeState( reader, ModelType.TYPE );
assertTypeState( reader, ModelType.BOOLEAN );
assertTypeState( reader, ModelType.UNDEFINED );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertListEndState( reader );
assertObjectEndState( reader );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simplePropertyWithWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "(\r\n\t\"a\" => \"b\"\r\n)" );
assertPropertyStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
@Test
public void simplePropertyWithoutWhitespaces() throws IOException, ModelException {
final ModelReader reader = getModelReader( "(\"a\"=>\"b\")" );
assertPropertyStartState( reader );
assertStringState( reader, "a" );
assertStringState( reader, "b" );
assertPropertyEndState( reader );
assertFinalState( reader );
reader.close();
assertClosedState( reader );
}
}
|
#!/bin/sh
# ** AUTO GENERATED **
# 2.2.5 Ensure DHCP Server is not installed (Automated)
rpm -q dhcp | grep -E "package dhcp is not installed" || exit $1
|
/* basic frontend user-auth control */
/* based on resourceCode */
export default {
config: [
{
key: 'customer',
title: '',
resourceCode: '',
path: '',
children: []
}
]
}
|
#!/bin/bash
rm *-light.svg
for file in *.svg; do
fname=$(basename $file .svg)
sed 's/currentColor/white/g' $file > "$fname-light.svg"
done
|
#!/bin/bash
# Runs a single srb init test from gems/sorbet/test/snapshot/{partial,total}/*
# --- begin runfiles.bash initialization v2 ---
# Copy-pasted from the Bazel Bash runfiles library v2.
set -uo pipefail; f=bazel_tools/tools/bash/runfiles/runfiles.bash
# shellcheck disable=SC1090
source "${RUNFILES_DIR:-/dev/null}/$f" 2>/dev/null || \
source "$(grep -sm1 "^$f " "${RUNFILES_MANIFEST_FILE:-/dev/null}" | cut -f2- -d' ')" 2>/dev/null || \
source "$0.runfiles/$f" 2>/dev/null || \
source "$(grep -sm1 "^$f " "$0.runfiles_manifest" | cut -f2- -d' ')" 2>/dev/null || \
source "$(grep -sm1 "^$f " "$0.exe.runfiles_manifest" | cut -f2- -d' ')" 2>/dev/null || \
{ echo>&2 "ERROR: cannot find $f"; exit 1; }; f=; set -e
# --- end runfiles.bash initialization v2 ---
# Explicitly setting this after runfiles initialization
set -euo pipefail
shopt -s dotglob
# This script is always invoked by bazel at the repository root
repo_root="$PWD"
# Fix up runfiles dir so that it's stable when we change directories
if [ -n "${RUNFILES_DIR:-}" ]; then
export RUNFILES_DIR="$repo_root/$RUNFILES_DIR"
fi
if [ -n "${RUNFILES_MANIFEST_FILE:-}" ]; then
export RUNFILES_MANIFEST_FILE="$repo_root/$RUNFILES_MANIFEST_FILE"
fi
# ----- Option parsing -----
# these positional arguments are supplied in snapshot.bzl
ruby_package=$1
output_archive="${repo_root}/$2"
test_name=$3
# This is the root of the test -- the src and expected directories are
# sub-directories of this one.
test_dir="${repo_root}/gems/sorbet/test/snapshot/${test_name}"
# NOTE: using rlocation here because this script gets run from a genrule
# shellcheck source=SCRIPTDIR/logging.sh
source "$(rlocation com_stripe_ruby_typer/gems/sorbet/test/snapshot/logging.sh)"
# shellcheck source=SCRIPTDIR/hermetic_tar.sh
source "$(rlocation com_stripe_ruby_typer/gems/sorbet/test/snapshot/hermetic_tar.sh)"
# ----- Environment setup and validation -----
sandbox="$test_dir/$ruby_package"
if [ -d "$sandbox" ]; then
attn "├─ Cleaning up old test sandbox"
rm -rf "$sandbox"
fi
mkdir "$sandbox"
HOME="$sandbox"
export HOME
BUNDLE_PATH="$sandbox/bundler"
mkdir "$BUNDLE_PATH"
export BUNDLE_PATH
XDG_CACHE_HOME="$sandbox/cache"
export XDG_CACHE_HOME
if [[ "${test_name}" =~ partial/* ]]; then
is_partial=1
else
is_partial=
fi
info "├─ test_name: ${test_name}"
info "├─ output_archive: ${output_archive}"
info "├─ is_partial: ${is_partial:-0}"
# Add ruby to the path
RUBY_WRAPPER_LOC="$(rlocation "${ruby_package}/ruby")"
PATH="$(dirname "$RUBY_WRAPPER_LOC"):$PATH"
export PATH
# Disable ruby warnings to get consistent output between different ruby versions
RUBYOPT="-W0"
export RUBYOPT
info "├─ ruby: $(command -v ruby)"
info "├─ ruby --version: $(ruby --version)"
# Add bundler to the path
BUNDLER_LOC="$(dirname "$(rlocation "${ruby_package}/bundle")")"
PATH="$BUNDLER_LOC:$PATH"
export PATH
info "├─ bundle: $(command -v bundle)"
info "├─ bundle --version: $(bundle --version)"
# This is a bit fragile, but it's not clear how to find gems/gems otherwise.
GEMS_LOC="$(dirname "$(rlocation gems/gems/cantor-1.2.1.gem)")"
# Use the sorbet executable built by bazel
SRB_SORBET_EXE="$(rlocation com_stripe_ruby_typer/main/sorbet)"
export SRB_SORBET_EXE
srb="${repo_root}/gems/sorbet/bin/srb"
info "├─ sorbet: $SRB_SORBET_EXE"
info "├─ sorbet --version: $("$SRB_SORBET_EXE" --version)"
SORBET_TYPED_REV="$(rlocation com_stripe_ruby_typer/gems/sorbet/test/snapshot/sorbet-typed.rev)"
SRB_SORBET_TYPED_REVISION="$(<"$SORBET_TYPED_REV")"
export SRB_SORBET_TYPED_REVISION
if [ "$SRB_SORBET_TYPED_REVISION" = "" ]; then
error "└─ empty sorbet-typed revision from: ${SORBET_TYPED_REV}"
exit 1
else
info "├─ sorbet-typed: $SRB_SORBET_TYPED_REVISION"
fi
# ----- Build the test sandbox -----
# NOTE: this builds a replica of the `src` tree in the `actual` directory, and
# then uses that as a workspace.
actual="$sandbox/actual"
cp -r "${test_dir}/src/" "$actual"
if [ -d "${test_dir}/gems" ]; then
cp -r "${test_dir}/gems" "$sandbox"
fi
# ----- Run the test -----
(
cd "$actual"
# Setup the vendor/cache directory to include all gems required for any test
info "├─ Setting up vendor/cache"
mkdir vendor
ln -sf "$GEMS_LOC" "vendor/cache"
ruby_loc=$(bundle exec which ruby | sed -e 's,toolchain/bin/,,')
if [[ "$ruby_loc" == "$RUBY_WRAPPER_LOC" ]] ; then
info "├─ Bundle was able to find ruby"
else
attn "├─ ruby in path: ${ruby_loc}"
attn "├─ expected ruby: ${RUBY_WRAPPER_LOC}"
error "└─ Bundle failed to find ruby"
exit 1
fi
# Configuring output to vendor/bundle
# Setting no-prune to not delete unused gems in vendor/cache
# Passing --local to never consult rubygems.org
info "├─ Installing dependencies to BUNDLE_PATH"
bundle config set no_prune true
bundle install --verbose --local
info "├─ Checking srb commands"
bundle check
# By default we only run `srb init` for each test but they can contain a
# `test.sh` file with the list of commands to run.
test_cmd=("bundle" "exec" "$srb" "init")
test_script="test.sh"
if [ -f "$test_script" ]; then
test_cmd=("./$test_script" "$srb")
chmod +x "$test_script"
fi
# Uses /dev/null for stdin so any binding.pry would exit immediately
# (otherwise, pry will be waiting for input, but it's impossible to tell
# because the pry output is hiding in the *.log files)
#
# note: redirects stderr before the pipe
info "├─ Running srb"
# shellcheck disable=SC2048
if ! SRB_YES=1 ${test_cmd[*]} < /dev/null 2> "err.log" > "out.log"; then
error "├─ srb failed."
error "├─ stdout (out.log):"
cat "out.log"
error "├─ stderr (err.log):"
cat "err.log"
error "└─ (end stderr)"
exit 1
fi
# FIXME: Removing hidden-definitions in actual to hide them from diff output.
rm -rf "sorbet/rbi/hidden-definitions"
# Remove empty folders inside sorbet, because they can't be checked into git,
# so they'll always show up as present in actual but absent in expected.
find ./sorbet -empty -type d -delete
# Fix up the logs to not have sandbox directories present.
info "├─ Fixing up err.log"
sed -i.bak \
-e "s,${TMPDIR}[^ ]*/\([^/]*\),<tmp>/\1,g" \
-e "s,${XDG_CACHE_HOME},<cache>,g" \
-e "s,${HOME},<home>,g" \
"err.log"
info "├─ Fixing up out.log"
sed -i.bak \
-e 's/with [0-9]* modules and [0-9]* aliases/with X modules and Y aliases/' \
-e "s,${TMPDIR}[^ ]*/\([^/]*\),<tmp>/\1,g" \
-e "s,${XDG_CACHE_HOME},<cache>,g" \
-e "s,${HOME},<home>,g" \
"out.log"
info "├─ archiving results"
# archive the test
output="$(mktemp -d)"
cp -r sorbet err.log out.log "$output"
hermetic_tar "$output" "$output_archive"
rm -rf "$output"
)
# cleanup
rm -rf "$sandbox"
success "└─ done"
|
#!/bin/bash
SCRIPT=$(readlink -f "$0") && cd $(dirname "$SCRIPT")
# --- Script Init ---
set -e
set -o pipefail
mkdir -p log
rm -R -f log/*
# --- Setup run dirs ---
find output/* ! -name '*summary-info*' -exec rm -R -f {} +
mkdir output/full_correlation/
rm -R -f fifo/*
mkdir fifo/full_correlation/
rm -R -f work/*
mkdir work/kat/
mkdir work/full_correlation/
mkdir work/full_correlation/kat/
mkdir work/il_S1_summaryaalcalc
mkdir work/il_S2_summaryaalcalc
mkdir work/full_correlation/il_S1_summaryaalcalc
mkdir work/full_correlation/il_S2_summaryaalcalc
mkfifo fifo/full_correlation/gul_fc_P1
mkfifo fifo/il_P1
mkfifo fifo/il_S1_summary_P1
mkfifo fifo/il_S1_eltcalc_P1
mkfifo fifo/il_S1_summarycalc_P1
mkfifo fifo/il_S1_pltcalc_P1
mkfifo fifo/il_S2_summary_P1
mkfifo fifo/il_S2_eltcalc_P1
mkfifo fifo/il_S2_summarycalc_P1
mkfifo fifo/il_S2_pltcalc_P1
mkfifo fifo/full_correlation/il_P1
mkfifo fifo/full_correlation/il_S1_summary_P1
mkfifo fifo/full_correlation/il_S1_eltcalc_P1
mkfifo fifo/full_correlation/il_S1_summarycalc_P1
mkfifo fifo/full_correlation/il_S1_pltcalc_P1
mkfifo fifo/full_correlation/il_S2_summary_P1
mkfifo fifo/full_correlation/il_S2_eltcalc_P1
mkfifo fifo/full_correlation/il_S2_summarycalc_P1
mkfifo fifo/full_correlation/il_S2_pltcalc_P1
# --- Do insured loss computes ---
eltcalc < fifo/il_S1_eltcalc_P1 > work/kat/il_S1_eltcalc_P1 & pid1=$!
summarycalctocsv < fifo/il_S1_summarycalc_P1 > work/kat/il_S1_summarycalc_P1 & pid2=$!
pltcalc < fifo/il_S1_pltcalc_P1 > work/kat/il_S1_pltcalc_P1 & pid3=$!
eltcalc < fifo/il_S2_eltcalc_P1 > work/kat/il_S2_eltcalc_P1 & pid4=$!
summarycalctocsv < fifo/il_S2_summarycalc_P1 > work/kat/il_S2_summarycalc_P1 & pid5=$!
pltcalc < fifo/il_S2_pltcalc_P1 > work/kat/il_S2_pltcalc_P1 & pid6=$!
tee < fifo/il_S1_summary_P1 fifo/il_S1_eltcalc_P1 fifo/il_S1_summarycalc_P1 fifo/il_S1_pltcalc_P1 work/il_S1_summaryaalcalc/P1.bin > /dev/null & pid7=$!
tee < fifo/il_S2_summary_P1 fifo/il_S2_eltcalc_P1 fifo/il_S2_summarycalc_P1 fifo/il_S2_pltcalc_P1 work/il_S2_summaryaalcalc/P1.bin > /dev/null & pid8=$!
summarycalc -f -1 fifo/il_S1_summary_P1 -2 fifo/il_S2_summary_P1 < fifo/il_P1 &
# --- Do insured loss computes ---
eltcalc < fifo/full_correlation/il_S1_eltcalc_P1 > work/full_correlation/kat/il_S1_eltcalc_P1 & pid9=$!
summarycalctocsv < fifo/full_correlation/il_S1_summarycalc_P1 > work/full_correlation/kat/il_S1_summarycalc_P1 & pid10=$!
pltcalc < fifo/full_correlation/il_S1_pltcalc_P1 > work/full_correlation/kat/il_S1_pltcalc_P1 & pid11=$!
eltcalc < fifo/full_correlation/il_S2_eltcalc_P1 > work/full_correlation/kat/il_S2_eltcalc_P1 & pid12=$!
summarycalctocsv < fifo/full_correlation/il_S2_summarycalc_P1 > work/full_correlation/kat/il_S2_summarycalc_P1 & pid13=$!
pltcalc < fifo/full_correlation/il_S2_pltcalc_P1 > work/full_correlation/kat/il_S2_pltcalc_P1 & pid14=$!
tee < fifo/full_correlation/il_S1_summary_P1 fifo/full_correlation/il_S1_eltcalc_P1 fifo/full_correlation/il_S1_summarycalc_P1 fifo/full_correlation/il_S1_pltcalc_P1 work/full_correlation/il_S1_summaryaalcalc/P1.bin > /dev/null & pid15=$!
tee < fifo/full_correlation/il_S2_summary_P1 fifo/full_correlation/il_S2_eltcalc_P1 fifo/full_correlation/il_S2_summarycalc_P1 fifo/full_correlation/il_S2_pltcalc_P1 work/full_correlation/il_S2_summaryaalcalc/P1.bin > /dev/null & pid16=$!
summarycalc -f -1 fifo/full_correlation/il_S1_summary_P1 -2 fifo/full_correlation/il_S2_summary_P1 < fifo/full_correlation/il_P1 &
fmcalc -a2 < fifo/full_correlation/gul_fc_P1 > fifo/full_correlation/il_P1 &
eve 1 1 | getmodel | gulcalc -S0 -L0 -r -j fifo/full_correlation/gul_fc_P1 -a1 -i - | fmcalc -a2 > fifo/il_P1 &
wait $pid1 $pid2 $pid3 $pid4 $pid5 $pid6 $pid7 $pid8 $pid9 $pid10 $pid11 $pid12 $pid13 $pid14 $pid15 $pid16
# --- Do insured loss kats ---
kat work/kat/il_S1_eltcalc_P1 > output/il_S1_eltcalc.csv & kpid1=$!
kat work/kat/il_S1_pltcalc_P1 > output/il_S1_pltcalc.csv & kpid2=$!
kat work/kat/il_S1_summarycalc_P1 > output/il_S1_summarycalc.csv & kpid3=$!
kat work/kat/il_S2_eltcalc_P1 > output/il_S2_eltcalc.csv & kpid4=$!
kat work/kat/il_S2_pltcalc_P1 > output/il_S2_pltcalc.csv & kpid5=$!
kat work/kat/il_S2_summarycalc_P1 > output/il_S2_summarycalc.csv & kpid6=$!
# --- Do insured loss kats for fully correlated output ---
kat work/full_correlation/kat/il_S1_eltcalc_P1 > output/full_correlation/il_S1_eltcalc.csv & kpid7=$!
kat work/full_correlation/kat/il_S1_pltcalc_P1 > output/full_correlation/il_S1_pltcalc.csv & kpid8=$!
kat work/full_correlation/kat/il_S1_summarycalc_P1 > output/full_correlation/il_S1_summarycalc.csv & kpid9=$!
kat work/full_correlation/kat/il_S2_eltcalc_P1 > output/full_correlation/il_S2_eltcalc.csv & kpid10=$!
kat work/full_correlation/kat/il_S2_pltcalc_P1 > output/full_correlation/il_S2_pltcalc.csv & kpid11=$!
kat work/full_correlation/kat/il_S2_summarycalc_P1 > output/full_correlation/il_S2_summarycalc.csv & kpid12=$!
wait $kpid1 $kpid2 $kpid3 $kpid4 $kpid5 $kpid6 $kpid7 $kpid8 $kpid9 $kpid10 $kpid11 $kpid12
aalcalc -Kil_S1_summaryaalcalc > output/il_S1_aalcalc.csv & lpid1=$!
aalcalc -Kil_S2_summaryaalcalc > output/il_S2_aalcalc.csv & lpid2=$!
aalcalc -Kfull_correlation/il_S1_summaryaalcalc > output/full_correlation/il_S1_aalcalc.csv & lpid3=$!
aalcalc -Kfull_correlation/il_S2_summaryaalcalc > output/full_correlation/il_S2_aalcalc.csv & lpid4=$!
wait $lpid1 $lpid2 $lpid3 $lpid4
rm -R -f work/*
rm -R -f fifo/*
|
mkdir -p releases
rm releases/*
PROGRAM_NAME="upduck"
GOOS=windows go build -o "releases/$PROGRAM_NAME-windows.exe"
GOOS=linux go build -o "releases/$PROGRAM_NAME-linux"
GOOS=linux GOARCH=arm GOARM=5 go build -o "releases/$PROGRAM_NAME-raspberrypi-armv5"
GOOS=linux GOARCH=arm GOARM=6 go build -o "releases/$PROGRAM_NAME-raspberrypi-armv6"
GOOS=linux GOARCH=arm GOARM=7 go build -o "releases/$PROGRAM_NAME-raspberrypi-armv7"
# Raspberry Pi 4
GOOS=linux GOARCH=arm64 go build -o "releases/$PROGRAM_NAME-raspberrypi-aarch64"
|
<filename>src/src/main/java/com/cogentinfo/abc_insurance/model/Address.java<gh_stars>0
package com.cogentinfo.abc_insurance.model;
import lombok.Getter;
import lombok.Setter;
import javax.persistence.Entity;
import javax.persistence.Id;
import java.io.Serializable;
import java.util.UUID;
@Entity
public class Address implements Serializable{
@Id
private String id;
@Getter @Setter private String street;
@Getter @Setter private String aptNo;
@Getter @Setter private String city;
@Getter @Setter private String state;
@Getter @Setter private String zipcode;
public Address()
{
this.id= UUID.randomUUID().toString();
}
}
|
// import App from 'next/app'
import Router from "next/router";
import withGA from "next-ga";
import '../css/base.css'
import { LanguageProvider } from '../components/LanguageSelector'
function MyApp({ Component, pageProps }) {
return (
<LanguageProvider>
<Component {...pageProps} />
</LanguageProvider>
)
}
// Only uncomment this method if you have blocking data requirements for
// every single page in your application. This disables the ability to
// perform automatic static optimization, causing every page in your app to
// be server-side rendered.
//
// MyApp.getInitialProps = async (appContext) => {
// // calls page's `getInitialProps` and fills `appProps.pageProps`
// const appProps = await App.getInitialProps(appContext);
//
// return { ...appProps }
// }
// pass your GA code as first argument
export default withGA("UA-1137676-12", Router)(MyApp); |
#!/bin/bash
# https://www.linode.com/docs/security/securing-your-server/
adduser dev
adduser dev sudo
mkdir /home/dev/.ssh
cp authorized_keys /home/dev/.ssh/authorized_keys
# Now check that password loging with ssh is allowd, otherwise enable for the following operation:
# Now locally use
# ssh-copy-id dev@<ip>
# to copy local SSh key
sed -i 's/PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config
sed -i 's/PermitRootLogin yes/PermitRootLogin no/' /etc/ssh/sshd_config
echo 'AddressFamily inet' | tee -a /etc/ssh/sshd_config
systemctl restart sshd
|
<gh_stars>10-100
// 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.
var ROOT = WScript.ScriptFullName.split('\\cordova\\lib\\cordova.js').join(''),
shell = WScript.CreateObject("WScript.Shell"),
fso = WScript.CreateObject('Scripting.FileSystemObject');
//device_id for targeting specific device
var device_id;
//build types
var NONE = 0,
DEBUG = '--debug',
RELEASE = '--release',
NO_BUILD = '--nobuild';
var build_type = NONE;
//deploy tpyes
var NONE = 0,
EMULATOR = 1,
DEVICE = 2,
TARGET = 3;
var deploy_type = NONE;
// log to stdout or stderr
function Log(msg, error) {
if (error) {
WScript.StdErr.WriteLine(msg);
}
else {
WScript.StdOut.WriteLine(msg);
}
}
// executes a commmand in the shell, returning stdout
function exec(command) {
var oExec=shell.Exec(command);
var output = new String();
while (oExec.Status == 0) {
if (!oExec.StdOut.AtEndOfStream) {
var line = oExec.StdOut.ReadLine();
output += line;
}
WScript.sleep(100);
}
return output;
}
// executes a command in the shell, returns stdout or stderr if error
function exec_out(command) {
var oExec=shell.Exec(command);
var output = new String();
while (oExec.Status == 0) {
if (!oExec.StdOut.AtEndOfStream) {
var line = oExec.StdOut.ReadLine();
// XXX: Change to verbose mode
// WScript.StdOut.WriteLine(line);
output += line;
}
WScript.sleep(100);
}
//Check to make sure our scripts did not encounter an error
if (!oExec.StdErr.AtEndOfStream) {
var line = oExec.StdErr.ReadAll();
return {'error' : true, 'output' : line};
}
return {'error' : false, 'output' : output};
}
// executes a commmand in the shell and outputs stdout and fails on stderr
function exec_verbose(command) {
//Log("Command: " + command);
var oShell=shell.Exec(command);
while (oShell.Status == 0) {
//Wait a little bit so we're not super looping
WScript.sleep(100);
//Print any stdout output from the script
if (!oShell.StdOut.AtEndOfStream) {
var line = oShell.StdOut.ReadLine();
Log(line);
}
}
//Check to make sure our scripts did not encounter an error
if (!oShell.StdErr.AtEndOfStream) {
var line = oShell.StdErr.ReadAll();
Log(line, true);
WScript.Quit(2);
}
}
function version(path) {
var cordovajs_path = path + "\\assets\\www\\cordova.js";
if(fso.FileExists(cordovajs_path)) {
var f = fso.OpenTextFile(cordovajs_path, 1,2);
var cordovajs = f.ReadAll();
f.Close();
var version_regex = /^.*CORDOVA_JS_BUILD_LABEL.*$/m;
var version_line = cordovajs.match(version_regex) + "";
var version = version_line.match(/(\d+)\.(\d+)\.(\d+)(rc\d)?/) + "";
// TODO : figure out why this isn't matching properly so we can remove this substring workaround.
Log(version.substr(0, ((version.length/2) -1)));
} else {
Log("Error : Could not find cordova js.", true);
Log("Expected Location : " + cordovajs_path, true);
WScript.Quit(2);
}
}
function get_devices() {
var device_list = []
var local_devices = shell.Exec("%comspec% /c adb devices").StdOut.ReadAll();
if (local_devices.match(/\w+\tdevice/)) {
devices = local_devices.split('\r\n');
//format (ID DESCRIPTION)
for (i in devices) {
if (devices[i].match(/\w+\tdevice/) && !devices[i].match(/emulator/)) {
device_list.push(devices[i].replace(/\t/, ' '));
}
}
}
return device_list
}
function list_devices() {
var devices = get_devices();
if (devices.length > 0) {
for (i in devices) {
Log(devices[i]);
}
}
else {
Log('No devices found, if your device is connected and not showing,');
Log(' then try and install the drivers for your device.');
Log(' http://developer.android.com/tools/extras/oem-usb.html');
}
}
function get_emulator_images() {
var avd_list = [];
var local_emulators = shell.Exec("%comspec% /c android list avds").StdOut.ReadAll();
if (local_emulators.match(/Name\:/)) {
emulators = local_emulators.split('\n');
var count = 0;
var output = '';
for (i in emulators) {
// Find the line with the emulator name.
if (emulators[i].match(/Name\:/)) {
// strip description
var emulator_name = emulators[i].replace(/\s*Name\:\s/, '') + ' ';
avd_list.push(emulator_name);
}
}
}
return avd_list;
}
function list_emulator_images() {
var images = get_emulator_images();
if (images.length > 0) {
for(i in images) {
Log(images[i]);
}
}
else {
Log('No emulators found, if you would like to create an emulator follow the instructions');
Log(' provided here : http://developer.android.com/tools/devices/index.html');
Log(' Or run \'android create avd --name <name> --target <targetID>\' in on the command line.');
}
}
function get_started_emulators() {
var started_emulators = [];
var local_devices = shell.Exec("%comspec% /c adb devices").StdOut.ReadAll();
if (local_devices.match(/emulator/)) {
devices = local_devices.split('\r\n');
//format (ID DESCRIPTION)
for (i in devices) {
if (devices[i].match(/\w+\tdevice/) && devices[i].match(/emulator/)) {
started_emulators.push(devices[i].replace(/\t/, ' '));
}
}
}
return started_emulators
}
function list_started_emulators() {
var images = get_started_emulators();
if (images.length > 0) {
for(i in images) {
Log(images[i]);
}
}
else {
Log('No started emulators found, if you would like to start an emulator call ');
Log('\'list-emulator-images\'');
Log(' to get the name of an emulator and then start the emulator with');
Log('\'start-emulator <Name>\'');
}
}
function create_emulator() {
//get targets
var targets = shell.Exec('android.bat list targets').StdOut.ReadAll().match(/id:\s\d+/g);
if(targets) {
exec('%comspec% /c android create avd --name cordova_emulator --target ' + targets[targets.length - 1].replace(/id: /, ""));
} else {
Log("You do not have any android targets setup. Please create at least one target with the `android` command so that an emulator can be created.", true);
WScript.Quit(69);
}
}
function start_emulator(name) {
var emulators = get_emulator_images();
var started_emulators = get_started_emulators();
var num_started = started_emulators.length;
var emulator_name;
var started = false;
if (name) {
for (i in emulators) {
if (emulators[i].substr(0,name.length) == name) {
Log("Starting emulator : " + name);
shell.Exec("%comspec% /c emulator -avd " + name + " &");
//shell.Run("%comspec% /c start cmd /c emulator -cpu-delay 0 -no-boot-anim -cache %Temp%\cache -avd " + name);
started = true;
}
}
}
else {
if (emulators.length > 0 && started_emulators.length == 0) {
emulator_name = emulators[0].split(' ', 1)[0];
start_emulator(emulator_name);
return;
} else if (started_emulators.length > 0) {
Log("Emulator already started : " + started_emulators[0].split(' ', 1));
return;
} else {
Log("Error : unable to start emulator, ensure you have emulators availible by checking \'list-emulator-images\'", true);
WScript.Quit(2);
}
}
if (!started) {
Log("Error : unable to start emulator, ensure you have emulators availible by checking \'list-emulator-images\'", true);
WScript.Quit(2);
}
else {
// wait for emulator to get the ID
Log('Waiting for emulator...');
var boot_anim = null;
var emulator_ID = null;
var new_started = null;
var i = 0;
while(emulator_ID == null && i < 10) {
new_started = get_started_emulators();
if(new_started.length > started_emulators.length) {
// find new emulator that was just started to get it's ID
for(var i = 0; i < new_started.length; i++) {
if (new_started[i] != started_emulators[i]) {
emulator_ID = new_started[i].split(' ', 1)[0];
boot_anim = exec_out('%comspec% /c adb -s ' + emulator_ID + ' shell getprop init.svc.bootanim');
break;
}
}
}
}
if (i == 10) {
Log('\nEmulator start timed out.');
WScript.Quit(2);
}
i = 0;
WScript.Stdout.Write('Booting up emulator (this may take a while).');
// use boot animation property to tell when boot is complete.
while (!boot_anim.output.match(/stopped/) && i < 100) {
boot_anim = exec_out('%comspec% /c adb -s ' + emulator_ID + ' shell getprop init.svc.bootanim');
i++;
WScript.Stdout.Write('.');
WScript.Sleep(2000);
}
if (i < 100) {
Log('\nBoot Complete!');
// Unlock the device
shell.Exec("%comspec% /c adb -s " + emulator_ID + " shell input keyevent 82");
} else {
Log('\nEmulator boot timed out. Failed to load emulator');
WScript.Quit(2);
}
}
}
function get_apk(path) {
// check if file .apk has been created
if (fso.FolderExists(path + '\\bin')) {
var path_to_apk;
var out_folder = fso.GetFolder(path + '\\bin');
var out_files = new Enumerator(out_folder.Files);
for (;!out_files.atEnd(); out_files.moveNext()) {
var path = out_files.item() + '';
if (fso.GetExtensionName(path) == 'apk' && !path.match(/unaligned/)) {
path_to_apk = out_files.item();
break;
}
}
if (path_to_apk) {
return path_to_apk;
}
else {
Log('Failed to find apk, make sure you project is built and there is an ', true);
Log(' apk in <project>\\bin\\. To build your project use \'<project>\\cordova\\build\'', true);
WScript.Quit(2);
}
}
}
function install_device(path) {
var devices = get_devices();
var use_target = false;
if (devices.length < 1) {
Log("Error : No devices found to install to, make sure there are devices", true);
Log(" availible by checking \'<project_dir>\\cordova\\lib\\list-devices\'", true);
WScript.Quit(2);
}
launch(path, devices[0].split(' ', 1)[0], true);
}
function install_emulator(path) {
var emulators = get_started_emulators();
var use_target = false;
if (emulators.length < 1) {
Log("Error : No emulators found to install to, make sure there are emulators", true);
Log(" availible by checking \'<project_dir>\\cordova\\lib\\list-started-emulators\'", true);
WScript.Quit(2);
}
launch(path, emulators[0].split(' ', 1)[0], false);
}
function install_target(path) {
if(device_id) {
var device = false;
var emulators = get_started_emulators();
var devices = get_devices();
var exists = false;
for (i in emulators) {
if (emulators[i].substr(0,device_id.length) == device_id) {
exists = true;
break;
}
}
for (i in devices) {
if (devices[i].substr(0,device_id.length) == device_id) {
exists = true;
device = true
break;
}
}
if (!exists) {
Log("Error : Unable to find target " + device_id, true);
Log("Please ensure the target exists by checking \'<project>\\cordova\\lib\\list-started-emulators'");
Log(" Or \'<project>\\cordova\\lib\\list-devices'");
}
launch(path, device_id, device);
}
else {
Log("You cannot install to a target without providing a valid target ID.", true);
WScript.Quit(2);
}
}
function launch(path, id, device) {
if(id) {
var path_to_apk = get_apk(path);
if (path_to_apk) {
var launch_name = exec_out("%comspec% /c java -jar "+path+"\\cordova\\appinfo.jar "+path+"\\AndroidManifest.xml");
if (launch_name.error) {
Log("Failed to get application name from appinfo.jar + AndroidManifest : ", true);
Log("Output : " + launch_name.output, true);
WScript.Quit(2);
}
if (device) {
// install on device (-d)
Log("Installing app on device...");
} else {
// install on emulator (-e)
Log("Installing app on emulator...");
}
var cmd = '%comspec% /c adb -s ' + id + ' install -r ' + path_to_apk;
var install = exec_out(cmd);
if ( install.error && install.output.match(/Failure/)) {
Log("Error : Could not install apk to emulator : ", true);
Log(install.output, true);
WScript.Quit(2);
}
else {
Log(install.output);
}
// launch the application
Log("Launching application...");
cmd = '%comspec% /c adb -s ' + id + ' shell am start -W -a android.intent.action.MAIN -n ' + launch_name.output;
exec_verbose(cmd);
}
else {
Log('Failed to find apk, make sure you project is built and there is an ', true);
Log(' apk in <project>\\bin\\. To build your project use \'<project>\\cordova\\build\'', true);
WScript.Quit(2);
}
}
else {
Log("You cannot install to a target without providing a valid target ID.", true);
WScript.Quit(2);
}
}
function clean(path) {
Log("Cleaning project...");
exec("%comspec% /c ant.bat clean -f "+path+"\\build.xml 2>&1");
}
function log() {
// filter out nativeGetEnabledTags spam from latest sdk bug.
shell.Run("%comspec% /c adb logcat | grep -v nativeGetEnabledTags");
}
function build(path) {
switch (build_type) {
case DEBUG :
clean(path);
Log("Building project...");
exec_verbose("%comspec% /c ant.bat debug -f "+path+"\\build.xml 2>&1");
break;
case RELEASE :
clean(path);
Log("Building project...");
exec_verbose("%comspec% /c ant.bat release -f "+path+"\\build.xml 2>&1");
break;
case NO_BUILD :
Log("Skipping build process.");
break;
case NONE :
clean(path);
Log("WARNING: [ --debug | --release | --nobuild ] not specified, defaulting to --debug.");
exec_verbose("%comspec% /c ant.bat debug -f "+path+"\\build.xml 2>&1");
break;
default :
Log("Build option not recognized: " + build_type, true);
WScript.Quit(2);
break;
}
}
function run(path) {
switch(deploy_type) {
case EMULATOR :
build(path);
if(get_started_emulators().length == 0) {
start_emulator();
}
//TODO : Start emulator if one isn't started, and create one if none exists.
install_emulator(path);
break;
case DEVICE :
build(path);
install_device(path);
break;
case TARGET :
build(path);
install_target(path);
break;
case NONE :
if (get_devices().length > 0) {
Log("WARNING: [ --target=<ID> | --emulator | --device ] not specified, defaulting to --device");
deploy_type = DEVICE;
} else {
Log("WARNING: [ --target=<ID> | --emulator | --device ] not specified, defaulting to --emulator");
deploy_type = EMULATOR;
}
run(path);
break;
default :
Log("Deploy option not recognized: " + deploy_type, true);
WScript.Quit(2);
break;
}
}
var args = WScript.Arguments;
if (args.count() == 0) {
Log("Error: no args provided.");
WScript.Quit(2);
}
else {
// parse command
switch(args(0)) {
case "version" :
version(ROOT);
break;
case "build" :
if(args.Count() > 1) {
if (args(1) == "--release") {
build_type = RELEASE;
}
else if (args(1) == "--debug") {
build_type = DEBUG;
}
else if (args(1) == "--nobuild") {
build_type = NO_BUILD;
}
else {
Log('Error: \"' + args(i) + '\" is not recognized as a build option', true);
WScript.Quit(2);
}
}
build(ROOT);
break;
case "clean" :
clean();
break;
case "list-devices" :
list_devices();
break;
case "list-emulator-images" :
list_emulator_images();
break;
case "list-started-emulators" :
list_started_emulators();
break;
case "start-emulator" :
if (args.Count() > 1) {
start_emulator(args(1))
} else {
start_emulator();
}
break;
case "install-emulator" :
if (args.Count() == 2) {
if (args(1).substr(0,9) == "--target=") {
device_id = args(1).split('--target=').join('');
install_emulator(ROOT);
} else {
Log('Error: \"' + args(1) + '\" is not recognized as an install option', true);
WScript.Quit(2);
}
} else {
install_emulator(ROOT);
}
break;
case "install-device" :
if (args.Count() == 2) {
if (args(1).substr(0,9) == "--target=") {
device_id = args(1).split('--target=').join('');
install_target(ROOT);
} else {
Log('Error: \"' + args(1) + '\" is not recognized as an install option', true);
WScript.Quit(2);
}
} else {
install_device(ROOT);
}
break;
case "run" :
//parse args
for(var i = 1; i < args.Count(); i++) {
if (args(i) == "--release") {
build_type = RELEASE;
}
else if (args(i) == "--debug") {
build_type = DEBUG;
}
else if (args(i) == "--nobuild") {
build_type = NO_BUILD;
}
else if (args(i) == "--emulator" || args(i) == "-e") {
deploy_type = EMULATOR;
}
else if (args(i) == "--device" || args(i) == "-d") {
deploy_type = DEVICE;
}
else if (args(i).substr(0,9) == "--target=") {
device_id = args(i).split("--target=").join("");
deploy_type = TARGET;
}
else {
Log('Error: \"' + args(i) + '\" is not recognized as a run option', true);
WScript.Quit(2);
}
}
run(ROOT);
break;
default :
Log("Cordova does not regognize the command " + args(0), true);
WScript.Quit(2);
break;
}
}
|
from typing import List, Tuple
import math
def getCameraDistances(camera_name: str, ps: List[Tuple[int, int]]) -> List[float]:
focal_length = 50
image_width = 100
image_height = 75
distances = []
for x, y in ps:
angle = math.atan2(image_width / 2 - x, focal_length) # Calculate the angle using arctan
distance = focal_length / math.tan(angle) # Calculate the distance using the formula
distances.append(distance)
return distances |
#
for i in tranalyze trcombine trconvert trdelabel trdelete trdot trfold trfoldlit trformat trgen trgroup trinsert trjson trkleene trmove trparse trprint trrename trreplace trrr trrup trsplit trsponge trst trstrip trtext trtokens trtree trull trunfold trungroup trwdog trxgrep trxml trxml2
do
dotnet tool install -g $i
done
|
<gh_stars>1-10
package me.xiddy.jrequests;
import okhttp3.Response;
import java.io.IOException;
public class JSession {
public JSession() {}
public JResponse request(String method, String url) throws IOException {
// Make new request
JRequest request = new JRequest(method, url, null, null, null, null);
// Execute the request
JResponse response = this.send(request);
// Set the request to the response
response.request = request;
// Return the response
return response;
}
public JResponse get(String url) throws IOException {
return this.request("GET", url);
}
public JResponse post(String url) throws IOException {
return this.request("POST", url);
}
public JResponse put(String url) throws IOException {
return this.request("PUT", url);
}
public JResponse send(JRequest request) throws IOException {
Response response = JClient.getClient().newCall(request.toRequest()).execute();
return new JResponse(response);
}
}
|
import {
BufferAttribute,
BufferGeometry,
DynamicDrawUsage,
Color,
Group,
MeshPhongMaterial,
NormalBlending,
DoubleSide,
LineBasicMaterial,
ShaderMaterial,
LineSegments,
Points,
Mesh,
Vector3,
AdditiveBlending,
} from 'three'
import { cellColors } from './colorGenerators'
import { pointsVertexShader, pointsFragmentShader } from './helpers'
export const defaultColors = new Array(128)
.fill()
.map((_, i) => `hsl(${(i * 29) % 360}, 60%, 60%)`)
const defaults = {
faces: {
enabled: true,
useColors: true,
colorGenerator: cellColors,
colors: defaultColors,
reuse: 'none',
split: 'cells',
splitScale: 100, // Need split cells or faces
material: new MeshPhongMaterial({
transparent: true,
opacity: 0.25,
blending: NormalBlending,
depthWrite: false,
side: DoubleSide,
vertexColors: true,
}),
},
edges: {
enabled: true,
useColors: true,
colorGenerator: cellColors,
colors: defaultColors,
reuse: 'faces',
split: 'cells',
splitScale: 100, // Need split cells or faces
material: new LineBasicMaterial({
transparent: true,
opacity: 0.25,
blending: AdditiveBlending,
depthWrite: false,
vertexColors: true,
linewidth: 2,
}),
},
points: {
enabled: false,
useColors: true,
colorGenerator: cellColors,
colors: defaultColors,
reuse: 'faces',
split: 'none',
splitScale: 100, // Need split cells or faces
material: new ShaderMaterial({
uniforms: {
size: { value: 5 },
opacity: { value: 0.25 },
},
vertexShader: pointsVertexShader,
fragmentShader: pointsFragmentShader,
transparent: true,
blending: AdditiveBlending,
}),
},
}
const reuses = ['all', 'faces', 'none']
const splits = ['none', 'cells', 'faces']
export default class HyperMesh extends Group {
constructor(
shape,
{ all = {}, faces = {}, edges = {}, points = {} } = {
all: {},
faces: {},
edges: {},
points: {},
}
) {
super()
this.shape = shape
this.config = {
faces: {
...defaults.faces,
...faces,
...all,
},
edges: {
...defaults.edges,
...edges,
...all,
},
points: {
...defaults.points,
...points,
...all,
},
}
this.parts = {}
const meshes = {
faces: Mesh,
edges: LineSegments,
points: Points,
}
;['points', 'edges', 'faces'].map((type, order) => {
if (this.config[type].enabled) {
const unfoldOrder =
typeof this.config[type].reuse === 'string'
? reuses.indexOf(this.config[type].reuse)
: this.config[type].reuse
let geometryOrder =
typeof this.config[type].split === 'string'
? splits.indexOf(this.config[type].split)
: this.config[type].split
if (geometryOrder > unfoldOrder) {
console.warn(
`Geometry order ${geometryOrder} can’t be superior to unfold order ${unfoldOrder}`
)
geometryOrder = unfoldOrder
}
const verticesIndices = this.getVerticesIndices(
unfoldOrder,
geometryOrder
)
const indices = this.getIndices(unfoldOrder, geometryOrder, order + 1)
const geometry = this.buildGeometry(
verticesIndices,
this.config[type].useColors,
type
)
indices && this.setIndices(geometry, indices)
this[type] = this.createMesh(
geometry,
this.config[type].material,
meshes[type]
)
if (this.config[type].useColors) {
this.setColor(
geometry,
verticesIndices,
unfoldOrder,
geometryOrder,
this.config[type].colorGenerator,
this.config[type].colors,
type
)
}
this.parts[type] = {
geometry,
verticesIndices,
}
this.add(this[type])
}
})
}
initGeometry(size, withColors) {}
getVerticesIndices(unfoldOrder, geometryOrder) {
const unfoldFace = faceIndex => this.shape.faces[faceIndex]
if (unfoldOrder === 0) {
// All vertices are added once in buffer geometry and reused across faces / cells
if (geometryOrder === 0) {
return new Array(this.shape.vertices.length).fill().map((_, i) => i)
}
} else if (unfoldOrder === 1) {
// Vertices are reused in cells, partial unfold
if (geometryOrder === 0) {
return this.shape.cells
.map(cell => [...new Set(cell.map(unfoldFace).flat())])
.flat()
}
if (geometryOrder === 1) {
return this.shape.cells.map(cell => [
...new Set(cell.map(unfoldFace).flat()),
])
}
} else if (unfoldOrder === 2) {
// Vertices are never reused, full unfold
if (geometryOrder === 0) {
return this.shape.cells.map(cell => cell.map(unfoldFace).flat()).flat()
}
if (geometryOrder === 1) {
return this.shape.cells.map(cell => cell.map(unfoldFace).flat())
} else if (geometryOrder === 2) {
return this.shape.cells.map(cell => cell.map(unfoldFace))
}
}
}
setColor(
geometry,
verticesIndices,
unfoldOrder,
geometryOrder,
colorGenerator,
colors,
type
) {
const colorGetter = colorGenerator({
shape: this.shape,
colors: colors.map(color => new Color(color)),
})
const unfoldFace = faceIndex => this.shape.faces[faceIndex]
if (unfoldOrder === 0) {
if (geometryOrder === 0) {
let pos = 0
verticesIndices.forEach(vertexIndex => {
const [r, g, b] = colorGetter({
vertex: vertexIndex,
type,
}).toArray()
geometry.attributes.color.array[pos++] = r
geometry.attributes.color.array[pos++] = g
geometry.attributes.color.array[pos++] = b
})
geometry.attributes.color.needsUpdate = true
}
} else if (unfoldOrder === 1) {
if (geometryOrder === 0) {
let pos = 0
this.shape.cells.forEach((cell, cellIndex) => {
;[...new Set(cell.map(unfoldFace).flat())].map(vertexIndex => {
const [r, g, b] = colorGetter({
cell: cellIndex,
vertex: vertexIndex,
type,
}).toArray()
geometry.attributes.color.array[pos++] = r
geometry.attributes.color.array[pos++] = g
geometry.attributes.color.array[pos++] = b
})
})
geometry.attributes.color.needsUpdate = true
}
if (geometryOrder === 1) {
this.shape.cells.forEach((cell, cellIndex) => {
let pos = 0
;[...new Set(cell.map(unfoldFace).flat())].map(vertexIndex => {
const [r, g, b] = colorGetter({
cell: cellIndex,
vertex: vertexIndex,
type,
}).toArray()
geometry[cellIndex].attributes.color.array[pos++] = r
geometry[cellIndex].attributes.color.array[pos++] = g
geometry[cellIndex].attributes.color.array[pos++] = b
})
geometry[cellIndex].attributes.color.needsUpdate = true
})
}
} else if (unfoldOrder === 2) {
// Vertices are never reused, full unfold
if (geometryOrder === 0) {
let pos = 0
this.shape.cells.forEach((cell, cellIndex) => {
cell.map(unfoldFace).map((face, faceIndex) => {
face.forEach(vertexIndex => {
const [r, g, b] = colorGetter({
cell: cellIndex,
face: faceIndex,
vertex: vertexIndex,
type,
}).toArray()
geometry.attributes.color.array[pos++] = r
geometry.attributes.color.array[pos++] = g
geometry.attributes.color.array[pos++] = b
})
})
})
geometry.attributes.color.needsUpdate = true
} else if (geometryOrder === 1) {
this.shape.cells.forEach((cell, cellIndex) => {
let pos = 0
cell.map(unfoldFace).map((face, faceIndex) => {
face.forEach(vertexIndex => {
const [r, g, b] = colorGetter({
cell: cellIndex,
face: faceIndex,
vertex: vertexIndex,
type,
}).toArray()
geometry[cellIndex].attributes.color.array[pos++] = r
geometry[cellIndex].attributes.color.array[pos++] = g
geometry[cellIndex].attributes.color.array[pos++] = b
})
})
geometry[cellIndex].attributes.color.needsUpdate = true
})
} else if (geometryOrder === 2) {
this.shape.cells.forEach((cell, cellIndex) => {
cell.map(unfoldFace).map((face, faceIndex) => {
let pos = 0
face.forEach(vertexIndex => {
const [r, g, b] = colorGetter({
cell: cellIndex,
face: faceIndex,
vertex: vertexIndex,
type,
}).toArray()
geometry[cellIndex][faceIndex].attributes.color.array[pos++] = r
geometry[cellIndex][faceIndex].attributes.color.array[pos++] = g
geometry[cellIndex][faceIndex].attributes.color.array[pos++] = b
})
geometry[cellIndex][faceIndex].attributes.color.needsUpdate = true
})
})
}
}
}
getIndices(unfoldOrder, geometryOrder, indicesOrder) {
const unfoldFace = faceIndex => this.shape.faces[faceIndex]
let indices
if (indicesOrder === 0 || indicesOrder === 1) {
indices = null
} else if (indicesOrder === 2) {
// edges
indices = []
if (unfoldOrder === 0) {
if (geometryOrder === 0) {
this.shape.cells.forEach(cell =>
cell.map(unfoldFace).forEach(face => {
face.forEach((vertexIndex, i) => {
indices.push(vertexIndex, face[(i + 1) % face.length])
})
})
)
}
} else if (unfoldOrder === 1) {
if (geometryOrder === 0) {
let verticeShift = 0
this.shape.cells.forEach(cell => {
const verticesIndices = [...new Set(cell.map(unfoldFace).flat())]
cell.map(unfoldFace).forEach(face => {
face.forEach((vertexIndex, i) => {
indices.push(
verticeShift + verticesIndices.indexOf(vertexIndex),
verticeShift +
verticesIndices.indexOf(face[(i + 1) % face.length])
)
})
})
verticeShift += verticesIndices.length
})
} else if (geometryOrder === 1) {
this.shape.cells.forEach((cell, cellIndex) => {
const verticesIndices = [...new Set(cell.map(unfoldFace).flat())]
const subIndices = []
cell.map(unfoldFace).forEach(face => {
face.forEach((vertexIndex, i) => {
subIndices.push(
verticesIndices.indexOf(vertexIndex),
verticesIndices.indexOf(face[(i + 1) % face.length])
)
})
})
indices.push(subIndices)
})
}
} else if (unfoldOrder === 2) {
if (geometryOrder === 0) {
let verticeShift = 0
this.shape.cells.forEach(cell => {
cell.map(unfoldFace).forEach(face => {
face.forEach((_, i) => {
indices.push(
verticeShift + i,
verticeShift + ((i + 1) % face.length)
)
})
verticeShift += face.length
})
})
} else if (geometryOrder === 1) {
this.shape.cells.forEach(cell => {
let verticeShift = 0
const subIndices = []
cell.map(unfoldFace).forEach(face => {
face.forEach((_, i) => {
subIndices.push(
verticeShift + i,
verticeShift + ((i + 1) % face.length)
)
})
verticeShift += face.length
})
indices.push(subIndices)
})
} else if (geometryOrder === 2) {
this.shape.cells.forEach(cell => {
const subIndices = []
cell.map(unfoldFace).forEach(face => {
const subSubIndices = []
face.forEach((_, i) => {
subSubIndices.push(i, (i + 1) % face.length)
})
subIndices.push(subSubIndices)
})
indices.push(subIndices)
})
}
}
} else if (indicesOrder === 3) {
// faces
indices = []
if (unfoldOrder === 0) {
this.shape.cells.forEach(cell =>
cell.map(unfoldFace).forEach(face => {
new Array(face.length - 2).fill().forEach((_, i) => {
indices.push(face[0], face[i + 1], face[i + 2])
})
})
)
} else if (unfoldOrder === 1) {
if (geometryOrder === 0) {
let verticeShift = 0
this.shape.cells.forEach(cell => {
const verticesIndices = [...new Set(cell.map(unfoldFace).flat())]
cell.map(unfoldFace).forEach(face => {
new Array(face.length - 2).fill().forEach((_, i) => {
indices.push(
verticeShift + verticesIndices.indexOf(face[0]),
verticeShift + verticesIndices.indexOf(face[i + 1]),
verticeShift + verticesIndices.indexOf(face[i + 2])
)
})
})
verticeShift += verticesIndices.length
})
} else if (geometryOrder === 1) {
this.shape.cells.forEach((cell, cellIndex) => {
const verticesIndices = [...new Set(cell.map(unfoldFace).flat())]
const subIndices = []
cell.map(unfoldFace).forEach(face => {
new Array(face.length - 2).fill().forEach((_, i) => {
subIndices.push(
verticesIndices.indexOf(face[0]),
verticesIndices.indexOf(face[i + 1]),
verticesIndices.indexOf(face[i + 2])
)
})
})
indices.push(subIndices)
})
}
} else if (unfoldOrder === 2) {
if (geometryOrder === 0) {
let verticeShift = 0
this.shape.cells.forEach(cell => {
cell.map(unfoldFace).forEach(face => {
new Array(face.length - 2).fill().forEach((_, i) => {
indices.push(
verticeShift,
verticeShift + i + 1,
verticeShift + i + 2
)
})
verticeShift += face.length
})
})
} else if (geometryOrder === 1) {
this.shape.cells.forEach(cell => {
let verticeShift = 0
const subIndices = []
cell.map(unfoldFace).forEach(face => {
new Array(face.length - 2).fill().forEach((_, i) => {
subIndices.push(
verticeShift,
verticeShift + i + 1,
verticeShift + i + 2
)
})
verticeShift += face.length
})
indices.push(subIndices)
})
} else if (geometryOrder === 2) {
this.shape.cells.forEach(cell => {
const subIndices = []
cell.map(unfoldFace).forEach(face => {
const subSubIndices = []
new Array(face.length - 2).fill().forEach((_, i) => {
subSubIndices.push(0, i + 1, i + 2)
})
subIndices.push(subSubIndices)
})
indices.push(subIndices)
})
}
}
}
return indices
}
buildGeometry(verticesIndices, useColors, type, level = 0) {
const [vertexIndiceOrArray] = verticesIndices
if (Array.isArray(vertexIndiceOrArray)) {
return verticesIndices.map(x =>
this.buildGeometry(x, useColors, type, level + 1)
)
}
const size = verticesIndices.length
const geometry = new BufferGeometry()
geometry.setAttribute(
'position',
new BufferAttribute(new Float32Array(3 * size), 3).setUsage(
DynamicDrawUsage
)
)
if (useColors) {
geometry.setAttribute(
'color',
new BufferAttribute(new Float32Array(3 * size), 3).setUsage(
DynamicDrawUsage
)
)
}
geometry.name = `${type} geometry, level ${level}`
return geometry
}
setIndices(geometry, indices) {
if (Array.isArray(geometry)) {
return geometry.map((x, i) => this.setIndices(x, indices[i]))
}
return geometry.setIndex(indices)
}
createMesh(geometry, material, MeshClass) {
if (Array.isArray(geometry)) {
const group = new Group()
group.add(
...geometry.map((x, i) =>
this.createMesh(
x,
Array.isArray(material) ? material[i] : material,
MeshClass
)
)
)
return group
}
return new MeshClass(geometry, material)
}
walk(geometry, verticesIndices, cb) {
if (Array.isArray(geometry)) {
return geometry.forEach((x, i) => this.walk(x, verticesIndices[i], cb))
}
cb(geometry, verticesIndices)
}
setPoint(geometry, verticesIndices, type, vertices) {
this.walk(geometry, verticesIndices, (geometry, verticesIndices) => {
let pos = 0
verticesIndices.forEach(vertexIndex => {
const [x, y, z] = vertices[vertexIndex]
geometry.attributes.position.array[pos++] = x
geometry.attributes.position.array[pos++] = y
geometry.attributes.position.array[pos++] = z
})
geometry.attributes.position.needsUpdate = true
if (type === 'faces') {
geometry.computeVertexNormals()
geometry.attributes.normal.needsUpdate = true
}
})
}
recenter(mesh, splitScale) {
if (mesh.isGroup) {
return mesh.children.map(child => this.recenter(child, splitScale))
}
const center = new Vector3()
mesh.geometry.computeBoundingBox()
mesh.geometry.boundingBox.getCenter(center)
mesh.geometry.center()
mesh.position.copy(center)
mesh.scale.setScalar(splitScale / 100)
// mesh.scale.setScalar(Math.min(splitScale / 100, 0.999))
}
update(hyperRenderer) {
hyperRenderer.prepare(this.shape.vertices)
const vertices = this.shape.vertices.map(
hyperRenderer.project.bind(hyperRenderer)
)
Object.entries(this.parts).forEach(([type, part]) => {
if (this.config[type].enabled) {
this.setPoint(part.geometry, part.verticesIndices, type, vertices)
this.recenter(this[type], this.config[type].splitScale)
}
})
}
}
|
<reponame>supanadit/restsuite
package com.supanadit.restsuite.panel.sse;
import com.here.oksse.OkSse;
import com.here.oksse.ServerSentEvent;
import com.supanadit.restsuite.component.input.InputSseURL;
import net.miginfocom.swing.MigLayout;
import okhttp3.Request;
import okhttp3.Response;
import javax.swing.*;
public class ServerSentEventPanel extends JPanel {
ServerSentEvent sse;
OkSse okSse;
String connectDisconnect = "Connect";
boolean isConnected = false;
JButton connectDisconnectButton;
InputSseURL inputURL;
int connection = 0;
public ServerSentEventPanel() {
setLayout(new MigLayout("insets 10 10 10 10"));
inputURL = new InputSseURL();
connectDisconnectButton = new JButton(connectDisconnect);
add(inputURL, "growx,pushx");
add(connectDisconnectButton, "wrap");
add(new JLabel("Message"), "pushx,growx,wrap");
JTextArea messageTextArea = new JTextArea();
add(new JScrollPane(messageTextArea), "push,grow,span");
ServerSentEvent.Listener listener = new ServerSentEvent.Listener() {
@Override
public void onOpen(ServerSentEvent sse, Response response) {
connectDisconnectButton.setEnabled(true);
connectDisconnectButton.setText("Disconnect");
System.out.println("A connection just opened");
if (connection == 0) {
messageTextArea.append("Connected to ".concat(inputURL.getText()).concat("\n"));
connection += 1;
}
}
@Override
public void onMessage(ServerSentEvent sse, String id, String event, String message) {
messageTextArea.append(message.concat("\n"));
}
@Override
public void onComment(ServerSentEvent sse, String comment) {
// When a comment is received
System.out.printf("Have a comment %s \n", comment);
}
@Override
public boolean onRetryTime(ServerSentEvent sse, long milliseconds) {
System.out.println("Retry Time");
return true; // True to use the new retry time received by SSE
}
@Override
public boolean onRetryError(ServerSentEvent sse, Throwable throwable, Response response) {
boolean continueProcess = true;
if (throwable.getCause() != null) {
continueProcess = false;
messageTextArea.append(throwable.getMessage().concat("\n"));
setStatus(false);
}
return continueProcess;
}
@Override
public void onClosed(ServerSentEvent sse) {
inputURL.setEnabled(true);
connectDisconnectButton.setEnabled(true);
connectDisconnectButton.setText("Connect");
connection = 0;
messageTextArea.append("Disconnected from ".concat(inputURL.getText()).concat("\n"));
System.out.println("Connection is Closed");
}
@Override
public Request onPreRetry(ServerSentEvent serverSentEvent, Request request) {
System.out.println("Pre Requesting");
return request;
}
};
connectDisconnectButton.addActionListener(e -> {
if (!isConnected) {
String url = inputURL.getText();
if (!url.isEmpty()) {
Request request = new Request.Builder().url(inputURL.getText()).build();
okSse = new OkSse();
sse = okSse.newServerSentEvent(request, listener);
setStatus(true);
inputURL.setEnabled(false);
// Connection Button Logic
connectDisconnectButton.setEnabled(false);
connectDisconnectButton.setText("Connecting");
}
} else {
connectDisconnectButton.setEnabled(false);
connectDisconnectButton.setText("Disconnecting");
setStatus(false);
}
});
}
public void setStatus(boolean status) {
isConnected = status;
if (!isConnected) {
if (sse != null) {
sse.close();
}
}
}
}
|
CUDA_VISIBLE_DEVICES=2
spec='python driver.py --dataset kiba --hyper_param_search
--max_iter 38 --evaluate_freq 3 --patience 3 --model tf_regression
--early_stopping --prot_desc_path davis_data/prot_desc.csv --no_concord
--prot_desc_path metz_data/prot_desc.csv --prot_desc_path KIBA_data/prot_desc.csv
--prot_desc_path full_toxcast/prot_desc.csv --no_r2
--log_file GPhypersearch_t4_kiba.log --model_dir ./model_dir4_kiba_sch
--arithmetic_mean --verbose_search --aggregate toxcast '
eval $spec
|
import numpy as np
def calculate_convex_hull_area(points):
def get_convex_hull_barycenter(s, pts):
# Implementation of get_convex_hull_barycenter function is not provided
pass
# Assuming the existence of coverU, coverV, coverUV, Fbats, pts, BLACK, filtration_from_bats, and TextMobject
# Calculate the convex hull barycenter for each cover
bcU = np.array([get_convex_hull_barycenter(s, pts) for s in coverU])
bcV = np.array([get_convex_hull_barycenter(s, pts) for s in coverV])
bcUV = np.array([get_convex_hull_barycenter(s, pts) for s in coverUV])
# Calculate the area of the convex hull for the given points
# Assuming filtration_from_bats and shift functions are related to visualization and not relevant to the area calculation
# Return the area of the convex hull formed by the input points
return area_of_convex_hull |
. prep-MATE
echo -e ""
echo -e "\033[1;33mInstalling xrdp and tightvncserver\033[0m"
sudo apt-get install -y xrdp tightvncserver
echo -e ""
echo -e "\033[1;33mConfiguring xrdp to use MATE instead of Cinnamon\033[0m"
sudo sed -i 's:^. /etc/X11/Xsession:#. /etc/X11/Xsession\nmate-session:' /etc/xrdp/startwm.sh
touch .Xauthority
sudo service xrdp restart
echo -e ""
echo -e "\033[1;33mInstalling Remmina remote desktop client (rdp + vnc)\033[0m"
sudo apt-get install -y remmina remmina-plugin-rdp remmina-plugin-vnc
|
<gh_stars>0
// Code generated by protoc-gen-go. DO NOT EDIT.
// source: steammessages.proto
package protobuf
import (
fmt "fmt"
proto "github.com/golang/protobuf/proto"
protobuf "github.com/golang/protobuf/protoc-gen-go/descriptor"
math "math"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package protobuf is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package protobuf to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
type GCProtoBufMsgSrc int32
const (
GCProtoBufMsgSrc_GCProtoBufMsgSrc_Unspecified GCProtoBufMsgSrc = 0
GCProtoBufMsgSrc_GCProtoBufMsgSrc_FromSystem GCProtoBufMsgSrc = 1
GCProtoBufMsgSrc_GCProtoBufMsgSrc_FromSteamID GCProtoBufMsgSrc = 2
GCProtoBufMsgSrc_GCProtoBufMsgSrc_FromGC GCProtoBufMsgSrc = 3
GCProtoBufMsgSrc_GCProtoBufMsgSrc_ReplySystem GCProtoBufMsgSrc = 4
)
var GCProtoBufMsgSrc_name = map[int32]string{
0: "GCProtoBufMsgSrc_Unspecified",
1: "GCProtoBufMsgSrc_FromSystem",
2: "GCProtoBufMsgSrc_FromSteamID",
3: "GCProtoBufMsgSrc_FromGC",
4: "GCProtoBufMsgSrc_ReplySystem",
}
var GCProtoBufMsgSrc_value = map[string]int32{
"GCProtoBufMsgSrc_Unspecified": 0,
"GCProtoBufMsgSrc_FromSystem": 1,
"GCProtoBufMsgSrc_FromSteamID": 2,
"GCProtoBufMsgSrc_FromGC": 3,
"GCProtoBufMsgSrc_ReplySystem": 4,
}
func (x GCProtoBufMsgSrc) Enum() *GCProtoBufMsgSrc {
p := new(GCProtoBufMsgSrc)
*p = x
return p
}
func (x GCProtoBufMsgSrc) String() string {
return proto.EnumName(GCProtoBufMsgSrc_name, int32(x))
}
func (x *GCProtoBufMsgSrc) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(GCProtoBufMsgSrc_value, data, "GCProtoBufMsgSrc")
if err != nil {
return err
}
*x = GCProtoBufMsgSrc(value)
return nil
}
func (GCProtoBufMsgSrc) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{0}
}
type CMsgGCRoutingInfo_RoutingMethod int32
const (
CMsgGCRoutingInfo_RANDOM CMsgGCRoutingInfo_RoutingMethod = 0
CMsgGCRoutingInfo_DISCARD CMsgGCRoutingInfo_RoutingMethod = 1
CMsgGCRoutingInfo_CLIENT_STEAMID CMsgGCRoutingInfo_RoutingMethod = 2
CMsgGCRoutingInfo_PROTOBUF_FIELD_UINT64 CMsgGCRoutingInfo_RoutingMethod = 3
CMsgGCRoutingInfo_WEBAPI_PARAM_UINT64 CMsgGCRoutingInfo_RoutingMethod = 4
)
var CMsgGCRoutingInfo_RoutingMethod_name = map[int32]string{
0: "RANDOM",
1: "DISCARD",
2: "CLIENT_STEAMID",
3: "PROTOBUF_FIELD_UINT64",
4: "WEBAPI_PARAM_UINT64",
}
var CMsgGCRoutingInfo_RoutingMethod_value = map[string]int32{
"RANDOM": 0,
"DISCARD": 1,
"CLIENT_STEAMID": 2,
"PROTOBUF_FIELD_UINT64": 3,
"WEBAPI_PARAM_UINT64": 4,
}
func (x CMsgGCRoutingInfo_RoutingMethod) Enum() *CMsgGCRoutingInfo_RoutingMethod {
p := new(CMsgGCRoutingInfo_RoutingMethod)
*p = x
return p
}
func (x CMsgGCRoutingInfo_RoutingMethod) String() string {
return proto.EnumName(CMsgGCRoutingInfo_RoutingMethod_name, int32(x))
}
func (x *CMsgGCRoutingInfo_RoutingMethod) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(CMsgGCRoutingInfo_RoutingMethod_value, data, "CMsgGCRoutingInfo_RoutingMethod")
if err != nil {
return err
}
*x = CMsgGCRoutingInfo_RoutingMethod(value)
return nil
}
func (CMsgGCRoutingInfo_RoutingMethod) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{51, 0}
}
type CMsgGCMsgSetOptions_Option int32
const (
CMsgGCMsgSetOptions_NOTIFY_USER_SESSIONS CMsgGCMsgSetOptions_Option = 0
CMsgGCMsgSetOptions_NOTIFY_SERVER_SESSIONS CMsgGCMsgSetOptions_Option = 1
CMsgGCMsgSetOptions_NOTIFY_ACHIEVEMENTS CMsgGCMsgSetOptions_Option = 2
CMsgGCMsgSetOptions_NOTIFY_VAC_ACTION CMsgGCMsgSetOptions_Option = 3
)
var CMsgGCMsgSetOptions_Option_name = map[int32]string{
0: "NOTIFY_USER_SESSIONS",
1: "NOTIFY_SERVER_SESSIONS",
2: "NOTIFY_ACHIEVEMENTS",
3: "NOTIFY_VAC_ACTION",
}
var CMsgGCMsgSetOptions_Option_value = map[string]int32{
"NOTIFY_USER_SESSIONS": 0,
"NOTIFY_SERVER_SESSIONS": 1,
"NOTIFY_ACHIEVEMENTS": 2,
"NOTIFY_VAC_ACTION": 3,
}
func (x CMsgGCMsgSetOptions_Option) Enum() *CMsgGCMsgSetOptions_Option {
p := new(CMsgGCMsgSetOptions_Option)
*p = x
return p
}
func (x CMsgGCMsgSetOptions_Option) String() string {
return proto.EnumName(CMsgGCMsgSetOptions_Option_name, int32(x))
}
func (x *CMsgGCMsgSetOptions_Option) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(CMsgGCMsgSetOptions_Option_value, data, "CMsgGCMsgSetOptions_Option")
if err != nil {
return err
}
*x = CMsgGCMsgSetOptions_Option(value)
return nil
}
func (CMsgGCMsgSetOptions_Option) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{56, 0}
}
type CMsgDPPartnerMicroTxnsResponse_EErrorCode int32
const (
CMsgDPPartnerMicroTxnsResponse_k_MsgValid CMsgDPPartnerMicroTxnsResponse_EErrorCode = 0
CMsgDPPartnerMicroTxnsResponse_k_MsgInvalidAppID CMsgDPPartnerMicroTxnsResponse_EErrorCode = 1
CMsgDPPartnerMicroTxnsResponse_k_MsgInvalidPartnerInfo CMsgDPPartnerMicroTxnsResponse_EErrorCode = 2
CMsgDPPartnerMicroTxnsResponse_k_MsgNoTransactions CMsgDPPartnerMicroTxnsResponse_EErrorCode = 3
CMsgDPPartnerMicroTxnsResponse_k_MsgSQLFailure CMsgDPPartnerMicroTxnsResponse_EErrorCode = 4
CMsgDPPartnerMicroTxnsResponse_k_MsgPartnerInfoDiscrepancy CMsgDPPartnerMicroTxnsResponse_EErrorCode = 5
CMsgDPPartnerMicroTxnsResponse_k_MsgTransactionInsertFailed CMsgDPPartnerMicroTxnsResponse_EErrorCode = 7
CMsgDPPartnerMicroTxnsResponse_k_MsgAlreadyRunning CMsgDPPartnerMicroTxnsResponse_EErrorCode = 8
CMsgDPPartnerMicroTxnsResponse_k_MsgInvalidTransactionData CMsgDPPartnerMicroTxnsResponse_EErrorCode = 9
)
var CMsgDPPartnerMicroTxnsResponse_EErrorCode_name = map[int32]string{
0: "k_MsgValid",
1: "k_MsgInvalidAppID",
2: "k_MsgInvalidPartnerInfo",
3: "k_MsgNoTransactions",
4: "k_MsgSQLFailure",
5: "k_MsgPartnerInfoDiscrepancy",
7: "k_MsgTransactionInsertFailed",
8: "k_MsgAlreadyRunning",
9: "k_MsgInvalidTransactionData",
}
var CMsgDPPartnerMicroTxnsResponse_EErrorCode_value = map[string]int32{
"k_MsgValid": 0,
"k_MsgInvalidAppID": 1,
"k_MsgInvalidPartnerInfo": 2,
"k_MsgNoTransactions": 3,
"k_MsgSQLFailure": 4,
"k_MsgPartnerInfoDiscrepancy": 5,
"k_MsgTransactionInsertFailed": 7,
"k_MsgAlreadyRunning": 8,
"k_MsgInvalidTransactionData": 9,
}
func (x CMsgDPPartnerMicroTxnsResponse_EErrorCode) Enum() *CMsgDPPartnerMicroTxnsResponse_EErrorCode {
p := new(CMsgDPPartnerMicroTxnsResponse_EErrorCode)
*p = x
return p
}
func (x CMsgDPPartnerMicroTxnsResponse_EErrorCode) String() string {
return proto.EnumName(CMsgDPPartnerMicroTxnsResponse_EErrorCode_name, int32(x))
}
func (x *CMsgDPPartnerMicroTxnsResponse_EErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(CMsgDPPartnerMicroTxnsResponse_EErrorCode_value, data, "CMsgDPPartnerMicroTxnsResponse_EErrorCode")
if err != nil {
return err
}
*x = CMsgDPPartnerMicroTxnsResponse_EErrorCode(value)
return nil
}
func (CMsgDPPartnerMicroTxnsResponse_EErrorCode) EnumDescriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{60, 0}
}
type CMsgProtoBufHeader struct {
ClientSteamId *uint64 `protobuf:"fixed64,1,opt,name=client_steam_id,json=clientSteamId" json:"client_steam_id,omitempty"`
ClientSessionId *int32 `protobuf:"varint,2,opt,name=client_session_id,json=clientSessionId" json:"client_session_id,omitempty"`
SourceAppId *uint32 `protobuf:"varint,3,opt,name=source_app_id,json=sourceAppId" json:"source_app_id,omitempty"`
JobIdSource *uint64 `protobuf:"fixed64,10,opt,name=job_id_source,json=jobIdSource,def=18446744073709551615" json:"job_id_source,omitempty"`
JobIdTarget *uint64 `protobuf:"fixed64,11,opt,name=job_id_target,json=jobIdTarget,def=18446744073709551615" json:"job_id_target,omitempty"`
TargetJobName *string `protobuf:"bytes,12,opt,name=target_job_name,json=targetJobName" json:"target_job_name,omitempty"`
Eresult *int32 `protobuf:"varint,13,opt,name=eresult,def=2" json:"eresult,omitempty"`
ErrorMessage *string `protobuf:"bytes,14,opt,name=error_message,json=errorMessage" json:"error_message,omitempty"`
Ip *uint32 `protobuf:"varint,15,opt,name=ip" json:"ip,omitempty"`
GcMsgSrc *GCProtoBufMsgSrc `protobuf:"varint,200,opt,name=gc_msg_src,json=gcMsgSrc,enum=GCProtoBufMsgSrc,def=0" json:"gc_msg_src,omitempty"`
GcDirIndexSource *uint32 `protobuf:"varint,201,opt,name=gc_dir_index_source,json=gcDirIndexSource" json:"gc_dir_index_source,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgProtoBufHeader) Reset() { *m = CMsgProtoBufHeader{} }
func (m *CMsgProtoBufHeader) String() string { return proto.CompactTextString(m) }
func (*CMsgProtoBufHeader) ProtoMessage() {}
func (*CMsgProtoBufHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{0}
}
func (m *CMsgProtoBufHeader) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgProtoBufHeader.Unmarshal(m, b)
}
func (m *CMsgProtoBufHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgProtoBufHeader.Marshal(b, m, deterministic)
}
func (m *CMsgProtoBufHeader) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgProtoBufHeader.Merge(m, src)
}
func (m *CMsgProtoBufHeader) XXX_Size() int {
return xxx_messageInfo_CMsgProtoBufHeader.Size(m)
}
func (m *CMsgProtoBufHeader) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgProtoBufHeader.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgProtoBufHeader proto.InternalMessageInfo
const Default_CMsgProtoBufHeader_JobIdSource uint64 = 18446744073709551615
const Default_CMsgProtoBufHeader_JobIdTarget uint64 = 18446744073709551615
const Default_CMsgProtoBufHeader_Eresult int32 = 2
const Default_CMsgProtoBufHeader_GcMsgSrc GCProtoBufMsgSrc = GCProtoBufMsgSrc_GCProtoBufMsgSrc_Unspecified
func (m *CMsgProtoBufHeader) GetClientSteamId() uint64 {
if m != nil && m.ClientSteamId != nil {
return *m.ClientSteamId
}
return 0
}
func (m *CMsgProtoBufHeader) GetClientSessionId() int32 {
if m != nil && m.ClientSessionId != nil {
return *m.ClientSessionId
}
return 0
}
func (m *CMsgProtoBufHeader) GetSourceAppId() uint32 {
if m != nil && m.SourceAppId != nil {
return *m.SourceAppId
}
return 0
}
func (m *CMsgProtoBufHeader) GetJobIdSource() uint64 {
if m != nil && m.JobIdSource != nil {
return *m.JobIdSource
}
return Default_CMsgProtoBufHeader_JobIdSource
}
func (m *CMsgProtoBufHeader) GetJobIdTarget() uint64 {
if m != nil && m.JobIdTarget != nil {
return *m.JobIdTarget
}
return Default_CMsgProtoBufHeader_JobIdTarget
}
func (m *CMsgProtoBufHeader) GetTargetJobName() string {
if m != nil && m.TargetJobName != nil {
return *m.TargetJobName
}
return ""
}
func (m *CMsgProtoBufHeader) GetEresult() int32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgProtoBufHeader_Eresult
}
func (m *CMsgProtoBufHeader) GetErrorMessage() string {
if m != nil && m.ErrorMessage != nil {
return *m.ErrorMessage
}
return ""
}
func (m *CMsgProtoBufHeader) GetIp() uint32 {
if m != nil && m.Ip != nil {
return *m.Ip
}
return 0
}
func (m *CMsgProtoBufHeader) GetGcMsgSrc() GCProtoBufMsgSrc {
if m != nil && m.GcMsgSrc != nil {
return *m.GcMsgSrc
}
return Default_CMsgProtoBufHeader_GcMsgSrc
}
func (m *CMsgProtoBufHeader) GetGcDirIndexSource() uint32 {
if m != nil && m.GcDirIndexSource != nil {
return *m.GcDirIndexSource
}
return 0
}
type CMsgWebAPIKey struct {
Status *uint32 `protobuf:"varint,1,opt,name=status,def=255" json:"status,omitempty"`
AccountId *uint32 `protobuf:"varint,2,opt,name=account_id,json=accountId,def=0" json:"account_id,omitempty"`
PublisherGroupId *uint32 `protobuf:"varint,3,opt,name=publisher_group_id,json=publisherGroupId,def=0" json:"publisher_group_id,omitempty"`
KeyId *uint32 `protobuf:"varint,4,opt,name=key_id,json=keyId" json:"key_id,omitempty"`
Domain *string `protobuf:"bytes,5,opt,name=domain" json:"domain,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgWebAPIKey) Reset() { *m = CMsgWebAPIKey{} }
func (m *CMsgWebAPIKey) String() string { return proto.CompactTextString(m) }
func (*CMsgWebAPIKey) ProtoMessage() {}
func (*CMsgWebAPIKey) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{1}
}
func (m *CMsgWebAPIKey) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgWebAPIKey.Unmarshal(m, b)
}
func (m *CMsgWebAPIKey) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgWebAPIKey.Marshal(b, m, deterministic)
}
func (m *CMsgWebAPIKey) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgWebAPIKey.Merge(m, src)
}
func (m *CMsgWebAPIKey) XXX_Size() int {
return xxx_messageInfo_CMsgWebAPIKey.Size(m)
}
func (m *CMsgWebAPIKey) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgWebAPIKey.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgWebAPIKey proto.InternalMessageInfo
const Default_CMsgWebAPIKey_Status uint32 = 255
const Default_CMsgWebAPIKey_AccountId uint32 = 0
const Default_CMsgWebAPIKey_PublisherGroupId uint32 = 0
func (m *CMsgWebAPIKey) GetStatus() uint32 {
if m != nil && m.Status != nil {
return *m.Status
}
return Default_CMsgWebAPIKey_Status
}
func (m *CMsgWebAPIKey) GetAccountId() uint32 {
if m != nil && m.AccountId != nil {
return *m.AccountId
}
return Default_CMsgWebAPIKey_AccountId
}
func (m *CMsgWebAPIKey) GetPublisherGroupId() uint32 {
if m != nil && m.PublisherGroupId != nil {
return *m.PublisherGroupId
}
return Default_CMsgWebAPIKey_PublisherGroupId
}
func (m *CMsgWebAPIKey) GetKeyId() uint32 {
if m != nil && m.KeyId != nil {
return *m.KeyId
}
return 0
}
func (m *CMsgWebAPIKey) GetDomain() string {
if m != nil && m.Domain != nil {
return *m.Domain
}
return ""
}
type CMsgHttpRequest struct {
RequestMethod *uint32 `protobuf:"varint,1,opt,name=request_method,json=requestMethod" json:"request_method,omitempty"`
Hostname *string `protobuf:"bytes,2,opt,name=hostname" json:"hostname,omitempty"`
Url *string `protobuf:"bytes,3,opt,name=url" json:"url,omitempty"`
Headers []*CMsgHttpRequest_RequestHeader `protobuf:"bytes,4,rep,name=headers" json:"headers,omitempty"`
GetParams []*CMsgHttpRequest_QueryParam `protobuf:"bytes,5,rep,name=get_params,json=getParams" json:"get_params,omitempty"`
PostParams []*CMsgHttpRequest_QueryParam `protobuf:"bytes,6,rep,name=post_params,json=postParams" json:"post_params,omitempty"`
Body []byte `protobuf:"bytes,7,opt,name=body" json:"body,omitempty"`
AbsoluteTimeout *uint32 `protobuf:"varint,8,opt,name=absolute_timeout,json=absoluteTimeout" json:"absolute_timeout,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgHttpRequest) Reset() { *m = CMsgHttpRequest{} }
func (m *CMsgHttpRequest) String() string { return proto.CompactTextString(m) }
func (*CMsgHttpRequest) ProtoMessage() {}
func (*CMsgHttpRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{2}
}
func (m *CMsgHttpRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgHttpRequest.Unmarshal(m, b)
}
func (m *CMsgHttpRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgHttpRequest.Marshal(b, m, deterministic)
}
func (m *CMsgHttpRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgHttpRequest.Merge(m, src)
}
func (m *CMsgHttpRequest) XXX_Size() int {
return xxx_messageInfo_CMsgHttpRequest.Size(m)
}
func (m *CMsgHttpRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgHttpRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgHttpRequest proto.InternalMessageInfo
func (m *CMsgHttpRequest) GetRequestMethod() uint32 {
if m != nil && m.RequestMethod != nil {
return *m.RequestMethod
}
return 0
}
func (m *CMsgHttpRequest) GetHostname() string {
if m != nil && m.Hostname != nil {
return *m.Hostname
}
return ""
}
func (m *CMsgHttpRequest) GetUrl() string {
if m != nil && m.Url != nil {
return *m.Url
}
return ""
}
func (m *CMsgHttpRequest) GetHeaders() []*CMsgHttpRequest_RequestHeader {
if m != nil {
return m.Headers
}
return nil
}
func (m *CMsgHttpRequest) GetGetParams() []*CMsgHttpRequest_QueryParam {
if m != nil {
return m.GetParams
}
return nil
}
func (m *CMsgHttpRequest) GetPostParams() []*CMsgHttpRequest_QueryParam {
if m != nil {
return m.PostParams
}
return nil
}
func (m *CMsgHttpRequest) GetBody() []byte {
if m != nil {
return m.Body
}
return nil
}
func (m *CMsgHttpRequest) GetAbsoluteTimeout() uint32 {
if m != nil && m.AbsoluteTimeout != nil {
return *m.AbsoluteTimeout
}
return 0
}
type CMsgHttpRequest_RequestHeader struct {
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgHttpRequest_RequestHeader) Reset() { *m = CMsgHttpRequest_RequestHeader{} }
func (m *CMsgHttpRequest_RequestHeader) String() string { return proto.CompactTextString(m) }
func (*CMsgHttpRequest_RequestHeader) ProtoMessage() {}
func (*CMsgHttpRequest_RequestHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{2, 0}
}
func (m *CMsgHttpRequest_RequestHeader) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgHttpRequest_RequestHeader.Unmarshal(m, b)
}
func (m *CMsgHttpRequest_RequestHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgHttpRequest_RequestHeader.Marshal(b, m, deterministic)
}
func (m *CMsgHttpRequest_RequestHeader) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgHttpRequest_RequestHeader.Merge(m, src)
}
func (m *CMsgHttpRequest_RequestHeader) XXX_Size() int {
return xxx_messageInfo_CMsgHttpRequest_RequestHeader.Size(m)
}
func (m *CMsgHttpRequest_RequestHeader) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgHttpRequest_RequestHeader.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgHttpRequest_RequestHeader proto.InternalMessageInfo
func (m *CMsgHttpRequest_RequestHeader) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *CMsgHttpRequest_RequestHeader) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type CMsgHttpRequest_QueryParam struct {
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Value []byte `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgHttpRequest_QueryParam) Reset() { *m = CMsgHttpRequest_QueryParam{} }
func (m *CMsgHttpRequest_QueryParam) String() string { return proto.CompactTextString(m) }
func (*CMsgHttpRequest_QueryParam) ProtoMessage() {}
func (*CMsgHttpRequest_QueryParam) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{2, 1}
}
func (m *CMsgHttpRequest_QueryParam) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgHttpRequest_QueryParam.Unmarshal(m, b)
}
func (m *CMsgHttpRequest_QueryParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgHttpRequest_QueryParam.Marshal(b, m, deterministic)
}
func (m *CMsgHttpRequest_QueryParam) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgHttpRequest_QueryParam.Merge(m, src)
}
func (m *CMsgHttpRequest_QueryParam) XXX_Size() int {
return xxx_messageInfo_CMsgHttpRequest_QueryParam.Size(m)
}
func (m *CMsgHttpRequest_QueryParam) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgHttpRequest_QueryParam.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgHttpRequest_QueryParam proto.InternalMessageInfo
func (m *CMsgHttpRequest_QueryParam) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *CMsgHttpRequest_QueryParam) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type CMsgWebAPIRequest struct {
UNUSEDJobName *string `protobuf:"bytes,1,opt,name=UNUSED_job_name,json=UNUSEDJobName" json:"UNUSED_job_name,omitempty"`
InterfaceName *string `protobuf:"bytes,2,opt,name=interface_name,json=interfaceName" json:"interface_name,omitempty"`
MethodName *string `protobuf:"bytes,3,opt,name=method_name,json=methodName" json:"method_name,omitempty"`
Version *uint32 `protobuf:"varint,4,opt,name=version" json:"version,omitempty"`
ApiKey *CMsgWebAPIKey `protobuf:"bytes,5,opt,name=api_key,json=apiKey" json:"api_key,omitempty"`
Request *CMsgHttpRequest `protobuf:"bytes,6,opt,name=request" json:"request,omitempty"`
RoutingAppId *uint32 `protobuf:"varint,7,opt,name=routing_app_id,json=routingAppId" json:"routing_app_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgWebAPIRequest) Reset() { *m = CMsgWebAPIRequest{} }
func (m *CMsgWebAPIRequest) String() string { return proto.CompactTextString(m) }
func (*CMsgWebAPIRequest) ProtoMessage() {}
func (*CMsgWebAPIRequest) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{3}
}
func (m *CMsgWebAPIRequest) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgWebAPIRequest.Unmarshal(m, b)
}
func (m *CMsgWebAPIRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgWebAPIRequest.Marshal(b, m, deterministic)
}
func (m *CMsgWebAPIRequest) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgWebAPIRequest.Merge(m, src)
}
func (m *CMsgWebAPIRequest) XXX_Size() int {
return xxx_messageInfo_CMsgWebAPIRequest.Size(m)
}
func (m *CMsgWebAPIRequest) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgWebAPIRequest.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgWebAPIRequest proto.InternalMessageInfo
func (m *CMsgWebAPIRequest) GetUNUSEDJobName() string {
if m != nil && m.UNUSEDJobName != nil {
return *m.UNUSEDJobName
}
return ""
}
func (m *CMsgWebAPIRequest) GetInterfaceName() string {
if m != nil && m.InterfaceName != nil {
return *m.InterfaceName
}
return ""
}
func (m *CMsgWebAPIRequest) GetMethodName() string {
if m != nil && m.MethodName != nil {
return *m.MethodName
}
return ""
}
func (m *CMsgWebAPIRequest) GetVersion() uint32 {
if m != nil && m.Version != nil {
return *m.Version
}
return 0
}
func (m *CMsgWebAPIRequest) GetApiKey() *CMsgWebAPIKey {
if m != nil {
return m.ApiKey
}
return nil
}
func (m *CMsgWebAPIRequest) GetRequest() *CMsgHttpRequest {
if m != nil {
return m.Request
}
return nil
}
func (m *CMsgWebAPIRequest) GetRoutingAppId() uint32 {
if m != nil && m.RoutingAppId != nil {
return *m.RoutingAppId
}
return 0
}
type CMsgHttpResponse struct {
StatusCode *uint32 `protobuf:"varint,1,opt,name=status_code,json=statusCode" json:"status_code,omitempty"`
Headers []*CMsgHttpResponse_ResponseHeader `protobuf:"bytes,2,rep,name=headers" json:"headers,omitempty"`
Body []byte `protobuf:"bytes,3,opt,name=body" json:"body,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgHttpResponse) Reset() { *m = CMsgHttpResponse{} }
func (m *CMsgHttpResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgHttpResponse) ProtoMessage() {}
func (*CMsgHttpResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{4}
}
func (m *CMsgHttpResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgHttpResponse.Unmarshal(m, b)
}
func (m *CMsgHttpResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgHttpResponse.Marshal(b, m, deterministic)
}
func (m *CMsgHttpResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgHttpResponse.Merge(m, src)
}
func (m *CMsgHttpResponse) XXX_Size() int {
return xxx_messageInfo_CMsgHttpResponse.Size(m)
}
func (m *CMsgHttpResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgHttpResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgHttpResponse proto.InternalMessageInfo
func (m *CMsgHttpResponse) GetStatusCode() uint32 {
if m != nil && m.StatusCode != nil {
return *m.StatusCode
}
return 0
}
func (m *CMsgHttpResponse) GetHeaders() []*CMsgHttpResponse_ResponseHeader {
if m != nil {
return m.Headers
}
return nil
}
func (m *CMsgHttpResponse) GetBody() []byte {
if m != nil {
return m.Body
}
return nil
}
type CMsgHttpResponse_ResponseHeader struct {
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgHttpResponse_ResponseHeader) Reset() { *m = CMsgHttpResponse_ResponseHeader{} }
func (m *CMsgHttpResponse_ResponseHeader) String() string { return proto.CompactTextString(m) }
func (*CMsgHttpResponse_ResponseHeader) ProtoMessage() {}
func (*CMsgHttpResponse_ResponseHeader) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{4, 0}
}
func (m *CMsgHttpResponse_ResponseHeader) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgHttpResponse_ResponseHeader.Unmarshal(m, b)
}
func (m *CMsgHttpResponse_ResponseHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgHttpResponse_ResponseHeader.Marshal(b, m, deterministic)
}
func (m *CMsgHttpResponse_ResponseHeader) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgHttpResponse_ResponseHeader.Merge(m, src)
}
func (m *CMsgHttpResponse_ResponseHeader) XXX_Size() int {
return xxx_messageInfo_CMsgHttpResponse_ResponseHeader.Size(m)
}
func (m *CMsgHttpResponse_ResponseHeader) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgHttpResponse_ResponseHeader.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgHttpResponse_ResponseHeader proto.InternalMessageInfo
func (m *CMsgHttpResponse_ResponseHeader) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *CMsgHttpResponse_ResponseHeader) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type CMsgAMFindAccounts struct {
SearchType *uint32 `protobuf:"varint,1,opt,name=search_type,json=searchType" json:"search_type,omitempty"`
SearchString *string `protobuf:"bytes,2,opt,name=search_string,json=searchString" json:"search_string,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMFindAccounts) Reset() { *m = CMsgAMFindAccounts{} }
func (m *CMsgAMFindAccounts) String() string { return proto.CompactTextString(m) }
func (*CMsgAMFindAccounts) ProtoMessage() {}
func (*CMsgAMFindAccounts) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{5}
}
func (m *CMsgAMFindAccounts) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMFindAccounts.Unmarshal(m, b)
}
func (m *CMsgAMFindAccounts) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMFindAccounts.Marshal(b, m, deterministic)
}
func (m *CMsgAMFindAccounts) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMFindAccounts.Merge(m, src)
}
func (m *CMsgAMFindAccounts) XXX_Size() int {
return xxx_messageInfo_CMsgAMFindAccounts.Size(m)
}
func (m *CMsgAMFindAccounts) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMFindAccounts.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMFindAccounts proto.InternalMessageInfo
func (m *CMsgAMFindAccounts) GetSearchType() uint32 {
if m != nil && m.SearchType != nil {
return *m.SearchType
}
return 0
}
func (m *CMsgAMFindAccounts) GetSearchString() string {
if m != nil && m.SearchString != nil {
return *m.SearchString
}
return ""
}
type CMsgAMFindAccountsResponse struct {
SteamId []uint64 `protobuf:"fixed64,1,rep,name=steam_id,json=steamId" json:"steam_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMFindAccountsResponse) Reset() { *m = CMsgAMFindAccountsResponse{} }
func (m *CMsgAMFindAccountsResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgAMFindAccountsResponse) ProtoMessage() {}
func (*CMsgAMFindAccountsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{6}
}
func (m *CMsgAMFindAccountsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMFindAccountsResponse.Unmarshal(m, b)
}
func (m *CMsgAMFindAccountsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMFindAccountsResponse.Marshal(b, m, deterministic)
}
func (m *CMsgAMFindAccountsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMFindAccountsResponse.Merge(m, src)
}
func (m *CMsgAMFindAccountsResponse) XXX_Size() int {
return xxx_messageInfo_CMsgAMFindAccountsResponse.Size(m)
}
func (m *CMsgAMFindAccountsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMFindAccountsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMFindAccountsResponse proto.InternalMessageInfo
func (m *CMsgAMFindAccountsResponse) GetSteamId() []uint64 {
if m != nil {
return m.SteamId
}
return nil
}
type CMsgNotifyWatchdog struct {
Source *uint32 `protobuf:"varint,1,opt,name=source" json:"source,omitempty"`
AlertType *uint32 `protobuf:"varint,2,opt,name=alert_type,json=alertType" json:"alert_type,omitempty"`
AlertDestination *uint32 `protobuf:"varint,3,opt,name=alert_destination,json=alertDestination" json:"alert_destination,omitempty"`
Critical *bool `protobuf:"varint,4,opt,name=critical" json:"critical,omitempty"`
Time *uint32 `protobuf:"varint,5,opt,name=time" json:"time,omitempty"`
Appid *uint32 `protobuf:"varint,6,opt,name=appid" json:"appid,omitempty"`
Text *string `protobuf:"bytes,7,opt,name=text" json:"text,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgNotifyWatchdog) Reset() { *m = CMsgNotifyWatchdog{} }
func (m *CMsgNotifyWatchdog) String() string { return proto.CompactTextString(m) }
func (*CMsgNotifyWatchdog) ProtoMessage() {}
func (*CMsgNotifyWatchdog) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{7}
}
func (m *CMsgNotifyWatchdog) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgNotifyWatchdog.Unmarshal(m, b)
}
func (m *CMsgNotifyWatchdog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgNotifyWatchdog.Marshal(b, m, deterministic)
}
func (m *CMsgNotifyWatchdog) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgNotifyWatchdog.Merge(m, src)
}
func (m *CMsgNotifyWatchdog) XXX_Size() int {
return xxx_messageInfo_CMsgNotifyWatchdog.Size(m)
}
func (m *CMsgNotifyWatchdog) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgNotifyWatchdog.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgNotifyWatchdog proto.InternalMessageInfo
func (m *CMsgNotifyWatchdog) GetSource() uint32 {
if m != nil && m.Source != nil {
return *m.Source
}
return 0
}
func (m *CMsgNotifyWatchdog) GetAlertType() uint32 {
if m != nil && m.AlertType != nil {
return *m.AlertType
}
return 0
}
func (m *CMsgNotifyWatchdog) GetAlertDestination() uint32 {
if m != nil && m.AlertDestination != nil {
return *m.AlertDestination
}
return 0
}
func (m *CMsgNotifyWatchdog) GetCritical() bool {
if m != nil && m.Critical != nil {
return *m.Critical
}
return false
}
func (m *CMsgNotifyWatchdog) GetTime() uint32 {
if m != nil && m.Time != nil {
return *m.Time
}
return 0
}
func (m *CMsgNotifyWatchdog) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CMsgNotifyWatchdog) GetText() string {
if m != nil && m.Text != nil {
return *m.Text
}
return ""
}
type CMsgAMGetLicenses struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMGetLicenses) Reset() { *m = CMsgAMGetLicenses{} }
func (m *CMsgAMGetLicenses) String() string { return proto.CompactTextString(m) }
func (*CMsgAMGetLicenses) ProtoMessage() {}
func (*CMsgAMGetLicenses) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{8}
}
func (m *CMsgAMGetLicenses) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMGetLicenses.Unmarshal(m, b)
}
func (m *CMsgAMGetLicenses) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMGetLicenses.Marshal(b, m, deterministic)
}
func (m *CMsgAMGetLicenses) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMGetLicenses.Merge(m, src)
}
func (m *CMsgAMGetLicenses) XXX_Size() int {
return xxx_messageInfo_CMsgAMGetLicenses.Size(m)
}
func (m *CMsgAMGetLicenses) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMGetLicenses.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMGetLicenses proto.InternalMessageInfo
func (m *CMsgAMGetLicenses) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CMsgPackageLicense struct {
PackageId *uint32 `protobuf:"varint,1,opt,name=package_id,json=packageId" json:"package_id,omitempty"`
TimeCreated *uint32 `protobuf:"varint,2,opt,name=time_created,json=timeCreated" json:"time_created,omitempty"`
OwnerId *uint32 `protobuf:"varint,3,opt,name=owner_id,json=ownerId" json:"owner_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgPackageLicense) Reset() { *m = CMsgPackageLicense{} }
func (m *CMsgPackageLicense) String() string { return proto.CompactTextString(m) }
func (*CMsgPackageLicense) ProtoMessage() {}
func (*CMsgPackageLicense) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{9}
}
func (m *CMsgPackageLicense) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgPackageLicense.Unmarshal(m, b)
}
func (m *CMsgPackageLicense) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgPackageLicense.Marshal(b, m, deterministic)
}
func (m *CMsgPackageLicense) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgPackageLicense.Merge(m, src)
}
func (m *CMsgPackageLicense) XXX_Size() int {
return xxx_messageInfo_CMsgPackageLicense.Size(m)
}
func (m *CMsgPackageLicense) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgPackageLicense.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgPackageLicense proto.InternalMessageInfo
func (m *CMsgPackageLicense) GetPackageId() uint32 {
if m != nil && m.PackageId != nil {
return *m.PackageId
}
return 0
}
func (m *CMsgPackageLicense) GetTimeCreated() uint32 {
if m != nil && m.TimeCreated != nil {
return *m.TimeCreated
}
return 0
}
func (m *CMsgPackageLicense) GetOwnerId() uint32 {
if m != nil && m.OwnerId != nil {
return *m.OwnerId
}
return 0
}
type CMsgAMGetLicensesResponse struct {
License []*CMsgPackageLicense `protobuf:"bytes,1,rep,name=license" json:"license,omitempty"`
Result *uint32 `protobuf:"varint,2,opt,name=result" json:"result,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMGetLicensesResponse) Reset() { *m = CMsgAMGetLicensesResponse{} }
func (m *CMsgAMGetLicensesResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgAMGetLicensesResponse) ProtoMessage() {}
func (*CMsgAMGetLicensesResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{10}
}
func (m *CMsgAMGetLicensesResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMGetLicensesResponse.Unmarshal(m, b)
}
func (m *CMsgAMGetLicensesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMGetLicensesResponse.Marshal(b, m, deterministic)
}
func (m *CMsgAMGetLicensesResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMGetLicensesResponse.Merge(m, src)
}
func (m *CMsgAMGetLicensesResponse) XXX_Size() int {
return xxx_messageInfo_CMsgAMGetLicensesResponse.Size(m)
}
func (m *CMsgAMGetLicensesResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMGetLicensesResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMGetLicensesResponse proto.InternalMessageInfo
func (m *CMsgAMGetLicensesResponse) GetLicense() []*CMsgPackageLicense {
if m != nil {
return m.License
}
return nil
}
func (m *CMsgAMGetLicensesResponse) GetResult() uint32 {
if m != nil && m.Result != nil {
return *m.Result
}
return 0
}
type CMsgAMGetUserGameStats struct {
SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id,json=steamId" json:"steam_id,omitempty"`
GameId *uint64 `protobuf:"fixed64,2,opt,name=game_id,json=gameId" json:"game_id,omitempty"`
Stats []uint32 `protobuf:"varint,3,rep,name=stats" json:"stats,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMGetUserGameStats) Reset() { *m = CMsgAMGetUserGameStats{} }
func (m *CMsgAMGetUserGameStats) String() string { return proto.CompactTextString(m) }
func (*CMsgAMGetUserGameStats) ProtoMessage() {}
func (*CMsgAMGetUserGameStats) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{11}
}
func (m *CMsgAMGetUserGameStats) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMGetUserGameStats.Unmarshal(m, b)
}
func (m *CMsgAMGetUserGameStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMGetUserGameStats.Marshal(b, m, deterministic)
}
func (m *CMsgAMGetUserGameStats) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMGetUserGameStats.Merge(m, src)
}
func (m *CMsgAMGetUserGameStats) XXX_Size() int {
return xxx_messageInfo_CMsgAMGetUserGameStats.Size(m)
}
func (m *CMsgAMGetUserGameStats) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMGetUserGameStats.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMGetUserGameStats proto.InternalMessageInfo
func (m *CMsgAMGetUserGameStats) GetSteamId() uint64 {
if m != nil && m.SteamId != nil {
return *m.SteamId
}
return 0
}
func (m *CMsgAMGetUserGameStats) GetGameId() uint64 {
if m != nil && m.GameId != nil {
return *m.GameId
}
return 0
}
func (m *CMsgAMGetUserGameStats) GetStats() []uint32 {
if m != nil {
return m.Stats
}
return nil
}
type CMsgAMGetUserGameStatsResponse struct {
SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id,json=steamId" json:"steam_id,omitempty"`
GameId *uint64 `protobuf:"fixed64,2,opt,name=game_id,json=gameId" json:"game_id,omitempty"`
Eresult *int32 `protobuf:"varint,3,opt,name=eresult,def=2" json:"eresult,omitempty"`
Stats []*CMsgAMGetUserGameStatsResponse_Stats `protobuf:"bytes,4,rep,name=stats" json:"stats,omitempty"`
AchievementBlocks []*CMsgAMGetUserGameStatsResponse_Achievement_Blocks `protobuf:"bytes,5,rep,name=achievement_blocks,json=achievementBlocks" json:"achievement_blocks,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMGetUserGameStatsResponse) Reset() { *m = CMsgAMGetUserGameStatsResponse{} }
func (m *CMsgAMGetUserGameStatsResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgAMGetUserGameStatsResponse) ProtoMessage() {}
func (*CMsgAMGetUserGameStatsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{12}
}
func (m *CMsgAMGetUserGameStatsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMGetUserGameStatsResponse.Unmarshal(m, b)
}
func (m *CMsgAMGetUserGameStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMGetUserGameStatsResponse.Marshal(b, m, deterministic)
}
func (m *CMsgAMGetUserGameStatsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMGetUserGameStatsResponse.Merge(m, src)
}
func (m *CMsgAMGetUserGameStatsResponse) XXX_Size() int {
return xxx_messageInfo_CMsgAMGetUserGameStatsResponse.Size(m)
}
func (m *CMsgAMGetUserGameStatsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMGetUserGameStatsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMGetUserGameStatsResponse proto.InternalMessageInfo
const Default_CMsgAMGetUserGameStatsResponse_Eresult int32 = 2
func (m *CMsgAMGetUserGameStatsResponse) GetSteamId() uint64 {
if m != nil && m.SteamId != nil {
return *m.SteamId
}
return 0
}
func (m *CMsgAMGetUserGameStatsResponse) GetGameId() uint64 {
if m != nil && m.GameId != nil {
return *m.GameId
}
return 0
}
func (m *CMsgAMGetUserGameStatsResponse) GetEresult() int32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgAMGetUserGameStatsResponse_Eresult
}
func (m *CMsgAMGetUserGameStatsResponse) GetStats() []*CMsgAMGetUserGameStatsResponse_Stats {
if m != nil {
return m.Stats
}
return nil
}
func (m *CMsgAMGetUserGameStatsResponse) GetAchievementBlocks() []*CMsgAMGetUserGameStatsResponse_Achievement_Blocks {
if m != nil {
return m.AchievementBlocks
}
return nil
}
type CMsgAMGetUserGameStatsResponse_Stats struct {
StatId *uint32 `protobuf:"varint,1,opt,name=stat_id,json=statId" json:"stat_id,omitempty"`
StatValue *uint32 `protobuf:"varint,2,opt,name=stat_value,json=statValue" json:"stat_value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMGetUserGameStatsResponse_Stats) Reset() { *m = CMsgAMGetUserGameStatsResponse_Stats{} }
func (m *CMsgAMGetUserGameStatsResponse_Stats) String() string { return proto.CompactTextString(m) }
func (*CMsgAMGetUserGameStatsResponse_Stats) ProtoMessage() {}
func (*CMsgAMGetUserGameStatsResponse_Stats) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{12, 0}
}
func (m *CMsgAMGetUserGameStatsResponse_Stats) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Stats.Unmarshal(m, b)
}
func (m *CMsgAMGetUserGameStatsResponse_Stats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Stats.Marshal(b, m, deterministic)
}
func (m *CMsgAMGetUserGameStatsResponse_Stats) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Stats.Merge(m, src)
}
func (m *CMsgAMGetUserGameStatsResponse_Stats) XXX_Size() int {
return xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Stats.Size(m)
}
func (m *CMsgAMGetUserGameStatsResponse_Stats) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Stats.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Stats proto.InternalMessageInfo
func (m *CMsgAMGetUserGameStatsResponse_Stats) GetStatId() uint32 {
if m != nil && m.StatId != nil {
return *m.StatId
}
return 0
}
func (m *CMsgAMGetUserGameStatsResponse_Stats) GetStatValue() uint32 {
if m != nil && m.StatValue != nil {
return *m.StatValue
}
return 0
}
type CMsgAMGetUserGameStatsResponse_Achievement_Blocks struct {
AchievementId *uint32 `protobuf:"varint,1,opt,name=achievement_id,json=achievementId" json:"achievement_id,omitempty"`
AchievementBitId *uint32 `protobuf:"varint,2,opt,name=achievement_bit_id,json=achievementBitId" json:"achievement_bit_id,omitempty"`
UnlockTime *uint32 `protobuf:"fixed32,3,opt,name=unlock_time,json=unlockTime" json:"unlock_time,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) Reset() {
*m = CMsgAMGetUserGameStatsResponse_Achievement_Blocks{}
}
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) String() string {
return proto.CompactTextString(m)
}
func (*CMsgAMGetUserGameStatsResponse_Achievement_Blocks) ProtoMessage() {}
func (*CMsgAMGetUserGameStatsResponse_Achievement_Blocks) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{12, 1}
}
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Achievement_Blocks.Unmarshal(m, b)
}
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Achievement_Blocks.Marshal(b, m, deterministic)
}
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Achievement_Blocks.Merge(m, src)
}
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) XXX_Size() int {
return xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Achievement_Blocks.Size(m)
}
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Achievement_Blocks.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMGetUserGameStatsResponse_Achievement_Blocks proto.InternalMessageInfo
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) GetAchievementId() uint32 {
if m != nil && m.AchievementId != nil {
return *m.AchievementId
}
return 0
}
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) GetAchievementBitId() uint32 {
if m != nil && m.AchievementBitId != nil {
return *m.AchievementBitId
}
return 0
}
func (m *CMsgAMGetUserGameStatsResponse_Achievement_Blocks) GetUnlockTime() uint32 {
if m != nil && m.UnlockTime != nil {
return *m.UnlockTime
}
return 0
}
type CMsgGCGetCommandList struct {
AppId *uint32 `protobuf:"varint,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
CommandPrefix *string `protobuf:"bytes,2,opt,name=command_prefix,json=commandPrefix" json:"command_prefix,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCGetCommandList) Reset() { *m = CMsgGCGetCommandList{} }
func (m *CMsgGCGetCommandList) String() string { return proto.CompactTextString(m) }
func (*CMsgGCGetCommandList) ProtoMessage() {}
func (*CMsgGCGetCommandList) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{13}
}
func (m *CMsgGCGetCommandList) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCGetCommandList.Unmarshal(m, b)
}
func (m *CMsgGCGetCommandList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCGetCommandList.Marshal(b, m, deterministic)
}
func (m *CMsgGCGetCommandList) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCGetCommandList.Merge(m, src)
}
func (m *CMsgGCGetCommandList) XXX_Size() int {
return xxx_messageInfo_CMsgGCGetCommandList.Size(m)
}
func (m *CMsgGCGetCommandList) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCGetCommandList.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCGetCommandList proto.InternalMessageInfo
func (m *CMsgGCGetCommandList) GetAppId() uint32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
func (m *CMsgGCGetCommandList) GetCommandPrefix() string {
if m != nil && m.CommandPrefix != nil {
return *m.CommandPrefix
}
return ""
}
type CMsgGCGetCommandListResponse struct {
CommandName []string `protobuf:"bytes,1,rep,name=command_name,json=commandName" json:"command_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCGetCommandListResponse) Reset() { *m = CMsgGCGetCommandListResponse{} }
func (m *CMsgGCGetCommandListResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgGCGetCommandListResponse) ProtoMessage() {}
func (*CMsgGCGetCommandListResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{14}
}
func (m *CMsgGCGetCommandListResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCGetCommandListResponse.Unmarshal(m, b)
}
func (m *CMsgGCGetCommandListResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCGetCommandListResponse.Marshal(b, m, deterministic)
}
func (m *CMsgGCGetCommandListResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCGetCommandListResponse.Merge(m, src)
}
func (m *CMsgGCGetCommandListResponse) XXX_Size() int {
return xxx_messageInfo_CMsgGCGetCommandListResponse.Size(m)
}
func (m *CMsgGCGetCommandListResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCGetCommandListResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCGetCommandListResponse proto.InternalMessageInfo
func (m *CMsgGCGetCommandListResponse) GetCommandName() []string {
if m != nil {
return m.CommandName
}
return nil
}
type CGCMsgMemCachedGet struct {
Keys []string `protobuf:"bytes,1,rep,name=keys" json:"keys,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgMemCachedGet) Reset() { *m = CGCMsgMemCachedGet{} }
func (m *CGCMsgMemCachedGet) String() string { return proto.CompactTextString(m) }
func (*CGCMsgMemCachedGet) ProtoMessage() {}
func (*CGCMsgMemCachedGet) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{15}
}
func (m *CGCMsgMemCachedGet) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgMemCachedGet.Unmarshal(m, b)
}
func (m *CGCMsgMemCachedGet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgMemCachedGet.Marshal(b, m, deterministic)
}
func (m *CGCMsgMemCachedGet) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgMemCachedGet.Merge(m, src)
}
func (m *CGCMsgMemCachedGet) XXX_Size() int {
return xxx_messageInfo_CGCMsgMemCachedGet.Size(m)
}
func (m *CGCMsgMemCachedGet) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgMemCachedGet.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgMemCachedGet proto.InternalMessageInfo
func (m *CGCMsgMemCachedGet) GetKeys() []string {
if m != nil {
return m.Keys
}
return nil
}
type CGCMsgMemCachedGetResponse struct {
Values []*CGCMsgMemCachedGetResponse_ValueTag `protobuf:"bytes,1,rep,name=values" json:"values,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgMemCachedGetResponse) Reset() { *m = CGCMsgMemCachedGetResponse{} }
func (m *CGCMsgMemCachedGetResponse) String() string { return proto.CompactTextString(m) }
func (*CGCMsgMemCachedGetResponse) ProtoMessage() {}
func (*CGCMsgMemCachedGetResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{16}
}
func (m *CGCMsgMemCachedGetResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgMemCachedGetResponse.Unmarshal(m, b)
}
func (m *CGCMsgMemCachedGetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgMemCachedGetResponse.Marshal(b, m, deterministic)
}
func (m *CGCMsgMemCachedGetResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgMemCachedGetResponse.Merge(m, src)
}
func (m *CGCMsgMemCachedGetResponse) XXX_Size() int {
return xxx_messageInfo_CGCMsgMemCachedGetResponse.Size(m)
}
func (m *CGCMsgMemCachedGetResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgMemCachedGetResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgMemCachedGetResponse proto.InternalMessageInfo
func (m *CGCMsgMemCachedGetResponse) GetValues() []*CGCMsgMemCachedGetResponse_ValueTag {
if m != nil {
return m.Values
}
return nil
}
type CGCMsgMemCachedGetResponse_ValueTag struct {
Found *bool `protobuf:"varint,1,opt,name=found" json:"found,omitempty"`
Value []byte `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgMemCachedGetResponse_ValueTag) Reset() { *m = CGCMsgMemCachedGetResponse_ValueTag{} }
func (m *CGCMsgMemCachedGetResponse_ValueTag) String() string { return proto.CompactTextString(m) }
func (*CGCMsgMemCachedGetResponse_ValueTag) ProtoMessage() {}
func (*CGCMsgMemCachedGetResponse_ValueTag) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{16, 0}
}
func (m *CGCMsgMemCachedGetResponse_ValueTag) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgMemCachedGetResponse_ValueTag.Unmarshal(m, b)
}
func (m *CGCMsgMemCachedGetResponse_ValueTag) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgMemCachedGetResponse_ValueTag.Marshal(b, m, deterministic)
}
func (m *CGCMsgMemCachedGetResponse_ValueTag) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgMemCachedGetResponse_ValueTag.Merge(m, src)
}
func (m *CGCMsgMemCachedGetResponse_ValueTag) XXX_Size() int {
return xxx_messageInfo_CGCMsgMemCachedGetResponse_ValueTag.Size(m)
}
func (m *CGCMsgMemCachedGetResponse_ValueTag) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgMemCachedGetResponse_ValueTag.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgMemCachedGetResponse_ValueTag proto.InternalMessageInfo
func (m *CGCMsgMemCachedGetResponse_ValueTag) GetFound() bool {
if m != nil && m.Found != nil {
return *m.Found
}
return false
}
func (m *CGCMsgMemCachedGetResponse_ValueTag) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type CGCMsgMemCachedSet struct {
Keys []*CGCMsgMemCachedSet_KeyPair `protobuf:"bytes,1,rep,name=keys" json:"keys,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgMemCachedSet) Reset() { *m = CGCMsgMemCachedSet{} }
func (m *CGCMsgMemCachedSet) String() string { return proto.CompactTextString(m) }
func (*CGCMsgMemCachedSet) ProtoMessage() {}
func (*CGCMsgMemCachedSet) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{17}
}
func (m *CGCMsgMemCachedSet) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgMemCachedSet.Unmarshal(m, b)
}
func (m *CGCMsgMemCachedSet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgMemCachedSet.Marshal(b, m, deterministic)
}
func (m *CGCMsgMemCachedSet) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgMemCachedSet.Merge(m, src)
}
func (m *CGCMsgMemCachedSet) XXX_Size() int {
return xxx_messageInfo_CGCMsgMemCachedSet.Size(m)
}
func (m *CGCMsgMemCachedSet) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgMemCachedSet.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgMemCachedSet proto.InternalMessageInfo
func (m *CGCMsgMemCachedSet) GetKeys() []*CGCMsgMemCachedSet_KeyPair {
if m != nil {
return m.Keys
}
return nil
}
type CGCMsgMemCachedSet_KeyPair struct {
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Value []byte `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgMemCachedSet_KeyPair) Reset() { *m = CGCMsgMemCachedSet_KeyPair{} }
func (m *CGCMsgMemCachedSet_KeyPair) String() string { return proto.CompactTextString(m) }
func (*CGCMsgMemCachedSet_KeyPair) ProtoMessage() {}
func (*CGCMsgMemCachedSet_KeyPair) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{17, 0}
}
func (m *CGCMsgMemCachedSet_KeyPair) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgMemCachedSet_KeyPair.Unmarshal(m, b)
}
func (m *CGCMsgMemCachedSet_KeyPair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgMemCachedSet_KeyPair.Marshal(b, m, deterministic)
}
func (m *CGCMsgMemCachedSet_KeyPair) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgMemCachedSet_KeyPair.Merge(m, src)
}
func (m *CGCMsgMemCachedSet_KeyPair) XXX_Size() int {
return xxx_messageInfo_CGCMsgMemCachedSet_KeyPair.Size(m)
}
func (m *CGCMsgMemCachedSet_KeyPair) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgMemCachedSet_KeyPair.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgMemCachedSet_KeyPair proto.InternalMessageInfo
func (m *CGCMsgMemCachedSet_KeyPair) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *CGCMsgMemCachedSet_KeyPair) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type CGCMsgMemCachedDelete struct {
Keys []string `protobuf:"bytes,1,rep,name=keys" json:"keys,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgMemCachedDelete) Reset() { *m = CGCMsgMemCachedDelete{} }
func (m *CGCMsgMemCachedDelete) String() string { return proto.CompactTextString(m) }
func (*CGCMsgMemCachedDelete) ProtoMessage() {}
func (*CGCMsgMemCachedDelete) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{18}
}
func (m *CGCMsgMemCachedDelete) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgMemCachedDelete.Unmarshal(m, b)
}
func (m *CGCMsgMemCachedDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgMemCachedDelete.Marshal(b, m, deterministic)
}
func (m *CGCMsgMemCachedDelete) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgMemCachedDelete.Merge(m, src)
}
func (m *CGCMsgMemCachedDelete) XXX_Size() int {
return xxx_messageInfo_CGCMsgMemCachedDelete.Size(m)
}
func (m *CGCMsgMemCachedDelete) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgMemCachedDelete.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgMemCachedDelete proto.InternalMessageInfo
func (m *CGCMsgMemCachedDelete) GetKeys() []string {
if m != nil {
return m.Keys
}
return nil
}
type CGCMsgMemCachedStats struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgMemCachedStats) Reset() { *m = CGCMsgMemCachedStats{} }
func (m *CGCMsgMemCachedStats) String() string { return proto.CompactTextString(m) }
func (*CGCMsgMemCachedStats) ProtoMessage() {}
func (*CGCMsgMemCachedStats) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{19}
}
func (m *CGCMsgMemCachedStats) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgMemCachedStats.Unmarshal(m, b)
}
func (m *CGCMsgMemCachedStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgMemCachedStats.Marshal(b, m, deterministic)
}
func (m *CGCMsgMemCachedStats) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgMemCachedStats.Merge(m, src)
}
func (m *CGCMsgMemCachedStats) XXX_Size() int {
return xxx_messageInfo_CGCMsgMemCachedStats.Size(m)
}
func (m *CGCMsgMemCachedStats) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgMemCachedStats.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgMemCachedStats proto.InternalMessageInfo
type CGCMsgMemCachedStatsResponse struct {
CurrConnections *uint64 `protobuf:"varint,1,opt,name=curr_connections,json=currConnections" json:"curr_connections,omitempty"`
CmdGet *uint64 `protobuf:"varint,2,opt,name=cmd_get,json=cmdGet" json:"cmd_get,omitempty"`
CmdSet *uint64 `protobuf:"varint,3,opt,name=cmd_set,json=cmdSet" json:"cmd_set,omitempty"`
CmdFlush *uint64 `protobuf:"varint,4,opt,name=cmd_flush,json=cmdFlush" json:"cmd_flush,omitempty"`
GetHits *uint64 `protobuf:"varint,5,opt,name=get_hits,json=getHits" json:"get_hits,omitempty"`
GetMisses *uint64 `protobuf:"varint,6,opt,name=get_misses,json=getMisses" json:"get_misses,omitempty"`
DeleteHits *uint64 `protobuf:"varint,7,opt,name=delete_hits,json=deleteHits" json:"delete_hits,omitempty"`
DeleteMisses *uint64 `protobuf:"varint,8,opt,name=delete_misses,json=deleteMisses" json:"delete_misses,omitempty"`
BytesRead *uint64 `protobuf:"varint,9,opt,name=bytes_read,json=bytesRead" json:"bytes_read,omitempty"`
BytesWritten *uint64 `protobuf:"varint,10,opt,name=bytes_written,json=bytesWritten" json:"bytes_written,omitempty"`
LimitMaxbytes *uint64 `protobuf:"varint,11,opt,name=limit_maxbytes,json=limitMaxbytes" json:"limit_maxbytes,omitempty"`
CurrItems *uint64 `protobuf:"varint,12,opt,name=curr_items,json=currItems" json:"curr_items,omitempty"`
Evictions *uint64 `protobuf:"varint,13,opt,name=evictions" json:"evictions,omitempty"`
Bytes *uint64 `protobuf:"varint,14,opt,name=bytes" json:"bytes,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgMemCachedStatsResponse) Reset() { *m = CGCMsgMemCachedStatsResponse{} }
func (m *CGCMsgMemCachedStatsResponse) String() string { return proto.CompactTextString(m) }
func (*CGCMsgMemCachedStatsResponse) ProtoMessage() {}
func (*CGCMsgMemCachedStatsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{20}
}
func (m *CGCMsgMemCachedStatsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgMemCachedStatsResponse.Unmarshal(m, b)
}
func (m *CGCMsgMemCachedStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgMemCachedStatsResponse.Marshal(b, m, deterministic)
}
func (m *CGCMsgMemCachedStatsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgMemCachedStatsResponse.Merge(m, src)
}
func (m *CGCMsgMemCachedStatsResponse) XXX_Size() int {
return xxx_messageInfo_CGCMsgMemCachedStatsResponse.Size(m)
}
func (m *CGCMsgMemCachedStatsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgMemCachedStatsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgMemCachedStatsResponse proto.InternalMessageInfo
func (m *CGCMsgMemCachedStatsResponse) GetCurrConnections() uint64 {
if m != nil && m.CurrConnections != nil {
return *m.CurrConnections
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetCmdGet() uint64 {
if m != nil && m.CmdGet != nil {
return *m.CmdGet
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetCmdSet() uint64 {
if m != nil && m.CmdSet != nil {
return *m.CmdSet
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetCmdFlush() uint64 {
if m != nil && m.CmdFlush != nil {
return *m.CmdFlush
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetGetHits() uint64 {
if m != nil && m.GetHits != nil {
return *m.GetHits
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetGetMisses() uint64 {
if m != nil && m.GetMisses != nil {
return *m.GetMisses
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetDeleteHits() uint64 {
if m != nil && m.DeleteHits != nil {
return *m.DeleteHits
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetDeleteMisses() uint64 {
if m != nil && m.DeleteMisses != nil {
return *m.DeleteMisses
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetBytesRead() uint64 {
if m != nil && m.BytesRead != nil {
return *m.BytesRead
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetBytesWritten() uint64 {
if m != nil && m.BytesWritten != nil {
return *m.BytesWritten
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetLimitMaxbytes() uint64 {
if m != nil && m.LimitMaxbytes != nil {
return *m.LimitMaxbytes
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetCurrItems() uint64 {
if m != nil && m.CurrItems != nil {
return *m.CurrItems
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetEvictions() uint64 {
if m != nil && m.Evictions != nil {
return *m.Evictions
}
return 0
}
func (m *CGCMsgMemCachedStatsResponse) GetBytes() uint64 {
if m != nil && m.Bytes != nil {
return *m.Bytes
}
return 0
}
type CGCMsgSQLStats struct {
SchemaCatalog *uint32 `protobuf:"varint,1,opt,name=schema_catalog,json=schemaCatalog" json:"schema_catalog,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgSQLStats) Reset() { *m = CGCMsgSQLStats{} }
func (m *CGCMsgSQLStats) String() string { return proto.CompactTextString(m) }
func (*CGCMsgSQLStats) ProtoMessage() {}
func (*CGCMsgSQLStats) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{21}
}
func (m *CGCMsgSQLStats) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgSQLStats.Unmarshal(m, b)
}
func (m *CGCMsgSQLStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgSQLStats.Marshal(b, m, deterministic)
}
func (m *CGCMsgSQLStats) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgSQLStats.Merge(m, src)
}
func (m *CGCMsgSQLStats) XXX_Size() int {
return xxx_messageInfo_CGCMsgSQLStats.Size(m)
}
func (m *CGCMsgSQLStats) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgSQLStats.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgSQLStats proto.InternalMessageInfo
func (m *CGCMsgSQLStats) GetSchemaCatalog() uint32 {
if m != nil && m.SchemaCatalog != nil {
return *m.SchemaCatalog
}
return 0
}
type CGCMsgSQLStatsResponse struct {
Threads *uint32 `protobuf:"varint,1,opt,name=threads" json:"threads,omitempty"`
ThreadsConnected *uint32 `protobuf:"varint,2,opt,name=threads_connected,json=threadsConnected" json:"threads_connected,omitempty"`
ThreadsActive *uint32 `protobuf:"varint,3,opt,name=threads_active,json=threadsActive" json:"threads_active,omitempty"`
OperationsSubmitted *uint32 `protobuf:"varint,4,opt,name=operations_submitted,json=operationsSubmitted" json:"operations_submitted,omitempty"`
PreparedStatementsExecuted *uint32 `protobuf:"varint,5,opt,name=prepared_statements_executed,json=preparedStatementsExecuted" json:"prepared_statements_executed,omitempty"`
NonPreparedStatementsExecuted *uint32 `protobuf:"varint,6,opt,name=non_prepared_statements_executed,json=nonPreparedStatementsExecuted" json:"non_prepared_statements_executed,omitempty"`
DeadlockRetries *uint32 `protobuf:"varint,7,opt,name=deadlock_retries,json=deadlockRetries" json:"deadlock_retries,omitempty"`
OperationsTimedOutInQueue *uint32 `protobuf:"varint,8,opt,name=operations_timed_out_in_queue,json=operationsTimedOutInQueue" json:"operations_timed_out_in_queue,omitempty"`
Errors *uint32 `protobuf:"varint,9,opt,name=errors" json:"errors,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgSQLStatsResponse) Reset() { *m = CGCMsgSQLStatsResponse{} }
func (m *CGCMsgSQLStatsResponse) String() string { return proto.CompactTextString(m) }
func (*CGCMsgSQLStatsResponse) ProtoMessage() {}
func (*CGCMsgSQLStatsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{22}
}
func (m *CGCMsgSQLStatsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgSQLStatsResponse.Unmarshal(m, b)
}
func (m *CGCMsgSQLStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgSQLStatsResponse.Marshal(b, m, deterministic)
}
func (m *CGCMsgSQLStatsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgSQLStatsResponse.Merge(m, src)
}
func (m *CGCMsgSQLStatsResponse) XXX_Size() int {
return xxx_messageInfo_CGCMsgSQLStatsResponse.Size(m)
}
func (m *CGCMsgSQLStatsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgSQLStatsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgSQLStatsResponse proto.InternalMessageInfo
func (m *CGCMsgSQLStatsResponse) GetThreads() uint32 {
if m != nil && m.Threads != nil {
return *m.Threads
}
return 0
}
func (m *CGCMsgSQLStatsResponse) GetThreadsConnected() uint32 {
if m != nil && m.ThreadsConnected != nil {
return *m.ThreadsConnected
}
return 0
}
func (m *CGCMsgSQLStatsResponse) GetThreadsActive() uint32 {
if m != nil && m.ThreadsActive != nil {
return *m.ThreadsActive
}
return 0
}
func (m *CGCMsgSQLStatsResponse) GetOperationsSubmitted() uint32 {
if m != nil && m.OperationsSubmitted != nil {
return *m.OperationsSubmitted
}
return 0
}
func (m *CGCMsgSQLStatsResponse) GetPreparedStatementsExecuted() uint32 {
if m != nil && m.PreparedStatementsExecuted != nil {
return *m.PreparedStatementsExecuted
}
return 0
}
func (m *CGCMsgSQLStatsResponse) GetNonPreparedStatementsExecuted() uint32 {
if m != nil && m.NonPreparedStatementsExecuted != nil {
return *m.NonPreparedStatementsExecuted
}
return 0
}
func (m *CGCMsgSQLStatsResponse) GetDeadlockRetries() uint32 {
if m != nil && m.DeadlockRetries != nil {
return *m.DeadlockRetries
}
return 0
}
func (m *CGCMsgSQLStatsResponse) GetOperationsTimedOutInQueue() uint32 {
if m != nil && m.OperationsTimedOutInQueue != nil {
return *m.OperationsTimedOutInQueue
}
return 0
}
func (m *CGCMsgSQLStatsResponse) GetErrors() uint32 {
if m != nil && m.Errors != nil {
return *m.Errors
}
return 0
}
type CMsgAMAddFreeLicense struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
IpPublic *uint32 `protobuf:"varint,2,opt,name=ip_public,json=ipPublic" json:"ip_public,omitempty"`
Packageid *uint32 `protobuf:"varint,3,opt,name=packageid" json:"packageid,omitempty"`
StoreCountryCode *string `protobuf:"bytes,4,opt,name=store_country_code,json=storeCountryCode" json:"store_country_code,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMAddFreeLicense) Reset() { *m = CMsgAMAddFreeLicense{} }
func (m *CMsgAMAddFreeLicense) String() string { return proto.CompactTextString(m) }
func (*CMsgAMAddFreeLicense) ProtoMessage() {}
func (*CMsgAMAddFreeLicense) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{23}
}
func (m *CMsgAMAddFreeLicense) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMAddFreeLicense.Unmarshal(m, b)
}
func (m *CMsgAMAddFreeLicense) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMAddFreeLicense.Marshal(b, m, deterministic)
}
func (m *CMsgAMAddFreeLicense) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMAddFreeLicense.Merge(m, src)
}
func (m *CMsgAMAddFreeLicense) XXX_Size() int {
return xxx_messageInfo_CMsgAMAddFreeLicense.Size(m)
}
func (m *CMsgAMAddFreeLicense) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMAddFreeLicense.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMAddFreeLicense proto.InternalMessageInfo
func (m *CMsgAMAddFreeLicense) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CMsgAMAddFreeLicense) GetIpPublic() uint32 {
if m != nil && m.IpPublic != nil {
return *m.IpPublic
}
return 0
}
func (m *CMsgAMAddFreeLicense) GetPackageid() uint32 {
if m != nil && m.Packageid != nil {
return *m.Packageid
}
return 0
}
func (m *CMsgAMAddFreeLicense) GetStoreCountryCode() string {
if m != nil && m.StoreCountryCode != nil {
return *m.StoreCountryCode
}
return ""
}
type CMsgAMAddFreeLicenseResponse struct {
Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"`
PurchaseResultDetail *int32 `protobuf:"varint,2,opt,name=purchase_result_detail,json=purchaseResultDetail" json:"purchase_result_detail,omitempty"`
Transid *uint64 `protobuf:"fixed64,3,opt,name=transid" json:"transid,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMAddFreeLicenseResponse) Reset() { *m = CMsgAMAddFreeLicenseResponse{} }
func (m *CMsgAMAddFreeLicenseResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgAMAddFreeLicenseResponse) ProtoMessage() {}
func (*CMsgAMAddFreeLicenseResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{24}
}
func (m *CMsgAMAddFreeLicenseResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMAddFreeLicenseResponse.Unmarshal(m, b)
}
func (m *CMsgAMAddFreeLicenseResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMAddFreeLicenseResponse.Marshal(b, m, deterministic)
}
func (m *CMsgAMAddFreeLicenseResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMAddFreeLicenseResponse.Merge(m, src)
}
func (m *CMsgAMAddFreeLicenseResponse) XXX_Size() int {
return xxx_messageInfo_CMsgAMAddFreeLicenseResponse.Size(m)
}
func (m *CMsgAMAddFreeLicenseResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMAddFreeLicenseResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMAddFreeLicenseResponse proto.InternalMessageInfo
const Default_CMsgAMAddFreeLicenseResponse_Eresult int32 = 2
func (m *CMsgAMAddFreeLicenseResponse) GetEresult() int32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgAMAddFreeLicenseResponse_Eresult
}
func (m *CMsgAMAddFreeLicenseResponse) GetPurchaseResultDetail() int32 {
if m != nil && m.PurchaseResultDetail != nil {
return *m.PurchaseResultDetail
}
return 0
}
func (m *CMsgAMAddFreeLicenseResponse) GetTransid() uint64 {
if m != nil && m.Transid != nil {
return *m.Transid
}
return 0
}
type CGCMsgGetIPLocation struct {
Ips []uint32 `protobuf:"fixed32,1,rep,name=ips" json:"ips,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgGetIPLocation) Reset() { *m = CGCMsgGetIPLocation{} }
func (m *CGCMsgGetIPLocation) String() string { return proto.CompactTextString(m) }
func (*CGCMsgGetIPLocation) ProtoMessage() {}
func (*CGCMsgGetIPLocation) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{25}
}
func (m *CGCMsgGetIPLocation) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgGetIPLocation.Unmarshal(m, b)
}
func (m *CGCMsgGetIPLocation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgGetIPLocation.Marshal(b, m, deterministic)
}
func (m *CGCMsgGetIPLocation) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgGetIPLocation.Merge(m, src)
}
func (m *CGCMsgGetIPLocation) XXX_Size() int {
return xxx_messageInfo_CGCMsgGetIPLocation.Size(m)
}
func (m *CGCMsgGetIPLocation) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgGetIPLocation.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgGetIPLocation proto.InternalMessageInfo
func (m *CGCMsgGetIPLocation) GetIps() []uint32 {
if m != nil {
return m.Ips
}
return nil
}
type CIPLocationInfo struct {
Ip *uint32 `protobuf:"varint,1,opt,name=ip" json:"ip,omitempty"`
Latitude *float32 `protobuf:"fixed32,2,opt,name=latitude" json:"latitude,omitempty"`
Longitude *float32 `protobuf:"fixed32,3,opt,name=longitude" json:"longitude,omitempty"`
Country *string `protobuf:"bytes,4,opt,name=country" json:"country,omitempty"`
State *string `protobuf:"bytes,5,opt,name=state" json:"state,omitempty"`
City *string `protobuf:"bytes,6,opt,name=city" json:"city,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CIPLocationInfo) Reset() { *m = CIPLocationInfo{} }
func (m *CIPLocationInfo) String() string { return proto.CompactTextString(m) }
func (*CIPLocationInfo) ProtoMessage() {}
func (*CIPLocationInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{26}
}
func (m *CIPLocationInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CIPLocationInfo.Unmarshal(m, b)
}
func (m *CIPLocationInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CIPLocationInfo.Marshal(b, m, deterministic)
}
func (m *CIPLocationInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_CIPLocationInfo.Merge(m, src)
}
func (m *CIPLocationInfo) XXX_Size() int {
return xxx_messageInfo_CIPLocationInfo.Size(m)
}
func (m *CIPLocationInfo) XXX_DiscardUnknown() {
xxx_messageInfo_CIPLocationInfo.DiscardUnknown(m)
}
var xxx_messageInfo_CIPLocationInfo proto.InternalMessageInfo
func (m *CIPLocationInfo) GetIp() uint32 {
if m != nil && m.Ip != nil {
return *m.Ip
}
return 0
}
func (m *CIPLocationInfo) GetLatitude() float32 {
if m != nil && m.Latitude != nil {
return *m.Latitude
}
return 0
}
func (m *CIPLocationInfo) GetLongitude() float32 {
if m != nil && m.Longitude != nil {
return *m.Longitude
}
return 0
}
func (m *CIPLocationInfo) GetCountry() string {
if m != nil && m.Country != nil {
return *m.Country
}
return ""
}
func (m *CIPLocationInfo) GetState() string {
if m != nil && m.State != nil {
return *m.State
}
return ""
}
func (m *CIPLocationInfo) GetCity() string {
if m != nil && m.City != nil {
return *m.City
}
return ""
}
type CGCMsgGetIPLocationResponse struct {
Infos []*CIPLocationInfo `protobuf:"bytes,1,rep,name=infos" json:"infos,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgGetIPLocationResponse) Reset() { *m = CGCMsgGetIPLocationResponse{} }
func (m *CGCMsgGetIPLocationResponse) String() string { return proto.CompactTextString(m) }
func (*CGCMsgGetIPLocationResponse) ProtoMessage() {}
func (*CGCMsgGetIPLocationResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{27}
}
func (m *CGCMsgGetIPLocationResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgGetIPLocationResponse.Unmarshal(m, b)
}
func (m *CGCMsgGetIPLocationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgGetIPLocationResponse.Marshal(b, m, deterministic)
}
func (m *CGCMsgGetIPLocationResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgGetIPLocationResponse.Merge(m, src)
}
func (m *CGCMsgGetIPLocationResponse) XXX_Size() int {
return xxx_messageInfo_CGCMsgGetIPLocationResponse.Size(m)
}
func (m *CGCMsgGetIPLocationResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgGetIPLocationResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgGetIPLocationResponse proto.InternalMessageInfo
func (m *CGCMsgGetIPLocationResponse) GetInfos() []*CIPLocationInfo {
if m != nil {
return m.Infos
}
return nil
}
type CGCMsgSystemStatsSchema struct {
GcAppId *uint32 `protobuf:"varint,1,opt,name=gc_app_id,json=gcAppId" json:"gc_app_id,omitempty"`
SchemaKv []byte `protobuf:"bytes,2,opt,name=schema_kv,json=schemaKv" json:"schema_kv,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgSystemStatsSchema) Reset() { *m = CGCMsgSystemStatsSchema{} }
func (m *CGCMsgSystemStatsSchema) String() string { return proto.CompactTextString(m) }
func (*CGCMsgSystemStatsSchema) ProtoMessage() {}
func (*CGCMsgSystemStatsSchema) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{28}
}
func (m *CGCMsgSystemStatsSchema) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgSystemStatsSchema.Unmarshal(m, b)
}
func (m *CGCMsgSystemStatsSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgSystemStatsSchema.Marshal(b, m, deterministic)
}
func (m *CGCMsgSystemStatsSchema) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgSystemStatsSchema.Merge(m, src)
}
func (m *CGCMsgSystemStatsSchema) XXX_Size() int {
return xxx_messageInfo_CGCMsgSystemStatsSchema.Size(m)
}
func (m *CGCMsgSystemStatsSchema) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgSystemStatsSchema.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgSystemStatsSchema proto.InternalMessageInfo
func (m *CGCMsgSystemStatsSchema) GetGcAppId() uint32 {
if m != nil && m.GcAppId != nil {
return *m.GcAppId
}
return 0
}
func (m *CGCMsgSystemStatsSchema) GetSchemaKv() []byte {
if m != nil {
return m.SchemaKv
}
return nil
}
type CGCMsgGetSystemStats struct {
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgGetSystemStats) Reset() { *m = CGCMsgGetSystemStats{} }
func (m *CGCMsgGetSystemStats) String() string { return proto.CompactTextString(m) }
func (*CGCMsgGetSystemStats) ProtoMessage() {}
func (*CGCMsgGetSystemStats) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{29}
}
func (m *CGCMsgGetSystemStats) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgGetSystemStats.Unmarshal(m, b)
}
func (m *CGCMsgGetSystemStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgGetSystemStats.Marshal(b, m, deterministic)
}
func (m *CGCMsgGetSystemStats) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgGetSystemStats.Merge(m, src)
}
func (m *CGCMsgGetSystemStats) XXX_Size() int {
return xxx_messageInfo_CGCMsgGetSystemStats.Size(m)
}
func (m *CGCMsgGetSystemStats) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgGetSystemStats.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgGetSystemStats proto.InternalMessageInfo
type CGCMsgGetSystemStatsResponse struct {
GcAppId *uint32 `protobuf:"varint,1,opt,name=gc_app_id,json=gcAppId" json:"gc_app_id,omitempty"`
StatsKv []byte `protobuf:"bytes,2,opt,name=stats_kv,json=statsKv" json:"stats_kv,omitempty"`
ActiveJobs *uint32 `protobuf:"varint,3,opt,name=active_jobs,json=activeJobs" json:"active_jobs,omitempty"`
YieldingJobs *uint32 `protobuf:"varint,4,opt,name=yielding_jobs,json=yieldingJobs" json:"yielding_jobs,omitempty"`
UserSessions *uint32 `protobuf:"varint,5,opt,name=user_sessions,json=userSessions" json:"user_sessions,omitempty"`
GameServerSessions *uint32 `protobuf:"varint,6,opt,name=game_server_sessions,json=gameServerSessions" json:"game_server_sessions,omitempty"`
Socaches *uint32 `protobuf:"varint,7,opt,name=socaches" json:"socaches,omitempty"`
SocachesToUnload *uint32 `protobuf:"varint,8,opt,name=socaches_to_unload,json=socachesToUnload" json:"socaches_to_unload,omitempty"`
SocachesLoading *uint32 `protobuf:"varint,9,opt,name=socaches_loading,json=socachesLoading" json:"socaches_loading,omitempty"`
WritebackQueue *uint32 `protobuf:"varint,10,opt,name=writeback_queue,json=writebackQueue" json:"writeback_queue,omitempty"`
SteamidLocks *uint32 `protobuf:"varint,11,opt,name=steamid_locks,json=steamidLocks" json:"steamid_locks,omitempty"`
LogonQueue *uint32 `protobuf:"varint,12,opt,name=logon_queue,json=logonQueue" json:"logon_queue,omitempty"`
LogonJobs *uint32 `protobuf:"varint,13,opt,name=logon_jobs,json=logonJobs" json:"logon_jobs,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCMsgGetSystemStatsResponse) Reset() { *m = CGCMsgGetSystemStatsResponse{} }
func (m *CGCMsgGetSystemStatsResponse) String() string { return proto.CompactTextString(m) }
func (*CGCMsgGetSystemStatsResponse) ProtoMessage() {}
func (*CGCMsgGetSystemStatsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{30}
}
func (m *CGCMsgGetSystemStatsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCMsgGetSystemStatsResponse.Unmarshal(m, b)
}
func (m *CGCMsgGetSystemStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCMsgGetSystemStatsResponse.Marshal(b, m, deterministic)
}
func (m *CGCMsgGetSystemStatsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCMsgGetSystemStatsResponse.Merge(m, src)
}
func (m *CGCMsgGetSystemStatsResponse) XXX_Size() int {
return xxx_messageInfo_CGCMsgGetSystemStatsResponse.Size(m)
}
func (m *CGCMsgGetSystemStatsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CGCMsgGetSystemStatsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CGCMsgGetSystemStatsResponse proto.InternalMessageInfo
func (m *CGCMsgGetSystemStatsResponse) GetGcAppId() uint32 {
if m != nil && m.GcAppId != nil {
return *m.GcAppId
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetStatsKv() []byte {
if m != nil {
return m.StatsKv
}
return nil
}
func (m *CGCMsgGetSystemStatsResponse) GetActiveJobs() uint32 {
if m != nil && m.ActiveJobs != nil {
return *m.ActiveJobs
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetYieldingJobs() uint32 {
if m != nil && m.YieldingJobs != nil {
return *m.YieldingJobs
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetUserSessions() uint32 {
if m != nil && m.UserSessions != nil {
return *m.UserSessions
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetGameServerSessions() uint32 {
if m != nil && m.GameServerSessions != nil {
return *m.GameServerSessions
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetSocaches() uint32 {
if m != nil && m.Socaches != nil {
return *m.Socaches
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetSocachesToUnload() uint32 {
if m != nil && m.SocachesToUnload != nil {
return *m.SocachesToUnload
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetSocachesLoading() uint32 {
if m != nil && m.SocachesLoading != nil {
return *m.SocachesLoading
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetWritebackQueue() uint32 {
if m != nil && m.WritebackQueue != nil {
return *m.WritebackQueue
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetSteamidLocks() uint32 {
if m != nil && m.SteamidLocks != nil {
return *m.SteamidLocks
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetLogonQueue() uint32 {
if m != nil && m.LogonQueue != nil {
return *m.LogonQueue
}
return 0
}
func (m *CGCMsgGetSystemStatsResponse) GetLogonJobs() uint32 {
if m != nil && m.LogonJobs != nil {
return *m.LogonJobs
}
return 0
}
type CMsgAMSendEmail struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
EmailMsgType *uint32 `protobuf:"varint,2,opt,name=email_msg_type,json=emailMsgType" json:"email_msg_type,omitempty"`
EmailFormat *uint32 `protobuf:"varint,3,opt,name=email_format,json=emailFormat" json:"email_format,omitempty"`
PersonaNameTokens []*CMsgAMSendEmail_PersonaNameReplacementToken `protobuf:"bytes,5,rep,name=persona_name_tokens,json=personaNameTokens" json:"persona_name_tokens,omitempty"`
SourceGc *uint32 `protobuf:"varint,6,opt,name=source_gc,json=sourceGc" json:"source_gc,omitempty"`
Tokens []*CMsgAMSendEmail_ReplacementToken `protobuf:"bytes,7,rep,name=tokens" json:"tokens,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMSendEmail) Reset() { *m = CMsgAMSendEmail{} }
func (m *CMsgAMSendEmail) String() string { return proto.CompactTextString(m) }
func (*CMsgAMSendEmail) ProtoMessage() {}
func (*CMsgAMSendEmail) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{31}
}
func (m *CMsgAMSendEmail) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMSendEmail.Unmarshal(m, b)
}
func (m *CMsgAMSendEmail) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMSendEmail.Marshal(b, m, deterministic)
}
func (m *CMsgAMSendEmail) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMSendEmail.Merge(m, src)
}
func (m *CMsgAMSendEmail) XXX_Size() int {
return xxx_messageInfo_CMsgAMSendEmail.Size(m)
}
func (m *CMsgAMSendEmail) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMSendEmail.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMSendEmail proto.InternalMessageInfo
func (m *CMsgAMSendEmail) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CMsgAMSendEmail) GetEmailMsgType() uint32 {
if m != nil && m.EmailMsgType != nil {
return *m.EmailMsgType
}
return 0
}
func (m *CMsgAMSendEmail) GetEmailFormat() uint32 {
if m != nil && m.EmailFormat != nil {
return *m.EmailFormat
}
return 0
}
func (m *CMsgAMSendEmail) GetPersonaNameTokens() []*CMsgAMSendEmail_PersonaNameReplacementToken {
if m != nil {
return m.PersonaNameTokens
}
return nil
}
func (m *CMsgAMSendEmail) GetSourceGc() uint32 {
if m != nil && m.SourceGc != nil {
return *m.SourceGc
}
return 0
}
func (m *CMsgAMSendEmail) GetTokens() []*CMsgAMSendEmail_ReplacementToken {
if m != nil {
return m.Tokens
}
return nil
}
type CMsgAMSendEmail_ReplacementToken struct {
TokenName *string `protobuf:"bytes,1,opt,name=token_name,json=tokenName" json:"token_name,omitempty"`
TokenValue *string `protobuf:"bytes,2,opt,name=token_value,json=tokenValue" json:"token_value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMSendEmail_ReplacementToken) Reset() { *m = CMsgAMSendEmail_ReplacementToken{} }
func (m *CMsgAMSendEmail_ReplacementToken) String() string { return proto.CompactTextString(m) }
func (*CMsgAMSendEmail_ReplacementToken) ProtoMessage() {}
func (*CMsgAMSendEmail_ReplacementToken) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{31, 0}
}
func (m *CMsgAMSendEmail_ReplacementToken) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMSendEmail_ReplacementToken.Unmarshal(m, b)
}
func (m *CMsgAMSendEmail_ReplacementToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMSendEmail_ReplacementToken.Marshal(b, m, deterministic)
}
func (m *CMsgAMSendEmail_ReplacementToken) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMSendEmail_ReplacementToken.Merge(m, src)
}
func (m *CMsgAMSendEmail_ReplacementToken) XXX_Size() int {
return xxx_messageInfo_CMsgAMSendEmail_ReplacementToken.Size(m)
}
func (m *CMsgAMSendEmail_ReplacementToken) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMSendEmail_ReplacementToken.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMSendEmail_ReplacementToken proto.InternalMessageInfo
func (m *CMsgAMSendEmail_ReplacementToken) GetTokenName() string {
if m != nil && m.TokenName != nil {
return *m.TokenName
}
return ""
}
func (m *CMsgAMSendEmail_ReplacementToken) GetTokenValue() string {
if m != nil && m.TokenValue != nil {
return *m.TokenValue
}
return ""
}
type CMsgAMSendEmail_PersonaNameReplacementToken struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
TokenName *string `protobuf:"bytes,2,opt,name=token_name,json=tokenName" json:"token_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMSendEmail_PersonaNameReplacementToken) Reset() {
*m = CMsgAMSendEmail_PersonaNameReplacementToken{}
}
func (m *CMsgAMSendEmail_PersonaNameReplacementToken) String() string {
return proto.CompactTextString(m)
}
func (*CMsgAMSendEmail_PersonaNameReplacementToken) ProtoMessage() {}
func (*CMsgAMSendEmail_PersonaNameReplacementToken) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{31, 1}
}
func (m *CMsgAMSendEmail_PersonaNameReplacementToken) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMSendEmail_PersonaNameReplacementToken.Unmarshal(m, b)
}
func (m *CMsgAMSendEmail_PersonaNameReplacementToken) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMSendEmail_PersonaNameReplacementToken.Marshal(b, m, deterministic)
}
func (m *CMsgAMSendEmail_PersonaNameReplacementToken) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMSendEmail_PersonaNameReplacementToken.Merge(m, src)
}
func (m *CMsgAMSendEmail_PersonaNameReplacementToken) XXX_Size() int {
return xxx_messageInfo_CMsgAMSendEmail_PersonaNameReplacementToken.Size(m)
}
func (m *CMsgAMSendEmail_PersonaNameReplacementToken) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMSendEmail_PersonaNameReplacementToken.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMSendEmail_PersonaNameReplacementToken proto.InternalMessageInfo
func (m *CMsgAMSendEmail_PersonaNameReplacementToken) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CMsgAMSendEmail_PersonaNameReplacementToken) GetTokenName() string {
if m != nil && m.TokenName != nil {
return *m.TokenName
}
return ""
}
type CMsgAMSendEmailResponse struct {
Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMSendEmailResponse) Reset() { *m = CMsgAMSendEmailResponse{} }
func (m *CMsgAMSendEmailResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgAMSendEmailResponse) ProtoMessage() {}
func (*CMsgAMSendEmailResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{32}
}
func (m *CMsgAMSendEmailResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMSendEmailResponse.Unmarshal(m, b)
}
func (m *CMsgAMSendEmailResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMSendEmailResponse.Marshal(b, m, deterministic)
}
func (m *CMsgAMSendEmailResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMSendEmailResponse.Merge(m, src)
}
func (m *CMsgAMSendEmailResponse) XXX_Size() int {
return xxx_messageInfo_CMsgAMSendEmailResponse.Size(m)
}
func (m *CMsgAMSendEmailResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMSendEmailResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMSendEmailResponse proto.InternalMessageInfo
const Default_CMsgAMSendEmailResponse_Eresult uint32 = 2
func (m *CMsgAMSendEmailResponse) GetEresult() uint32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgAMSendEmailResponse_Eresult
}
type CMsgGCGetEmailTemplate struct {
AppId *uint32 `protobuf:"varint,1,opt,name=app_id,json=appId" json:"app_id,omitempty"`
EmailMsgType *uint32 `protobuf:"varint,2,opt,name=email_msg_type,json=emailMsgType" json:"email_msg_type,omitempty"`
EmailLang *int32 `protobuf:"varint,3,opt,name=email_lang,json=emailLang" json:"email_lang,omitempty"`
EmailFormat *int32 `protobuf:"varint,4,opt,name=email_format,json=emailFormat" json:"email_format,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCGetEmailTemplate) Reset() { *m = CMsgGCGetEmailTemplate{} }
func (m *CMsgGCGetEmailTemplate) String() string { return proto.CompactTextString(m) }
func (*CMsgGCGetEmailTemplate) ProtoMessage() {}
func (*CMsgGCGetEmailTemplate) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{33}
}
func (m *CMsgGCGetEmailTemplate) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCGetEmailTemplate.Unmarshal(m, b)
}
func (m *CMsgGCGetEmailTemplate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCGetEmailTemplate.Marshal(b, m, deterministic)
}
func (m *CMsgGCGetEmailTemplate) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCGetEmailTemplate.Merge(m, src)
}
func (m *CMsgGCGetEmailTemplate) XXX_Size() int {
return xxx_messageInfo_CMsgGCGetEmailTemplate.Size(m)
}
func (m *CMsgGCGetEmailTemplate) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCGetEmailTemplate.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCGetEmailTemplate proto.InternalMessageInfo
func (m *CMsgGCGetEmailTemplate) GetAppId() uint32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
func (m *CMsgGCGetEmailTemplate) GetEmailMsgType() uint32 {
if m != nil && m.EmailMsgType != nil {
return *m.EmailMsgType
}
return 0
}
func (m *CMsgGCGetEmailTemplate) GetEmailLang() int32 {
if m != nil && m.EmailLang != nil {
return *m.EmailLang
}
return 0
}
func (m *CMsgGCGetEmailTemplate) GetEmailFormat() int32 {
if m != nil && m.EmailFormat != nil {
return *m.EmailFormat
}
return 0
}
type CMsgGCGetEmailTemplateResponse struct {
Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"`
TemplateExists *bool `protobuf:"varint,2,opt,name=template_exists,json=templateExists" json:"template_exists,omitempty"`
Template *string `protobuf:"bytes,3,opt,name=template" json:"template,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCGetEmailTemplateResponse) Reset() { *m = CMsgGCGetEmailTemplateResponse{} }
func (m *CMsgGCGetEmailTemplateResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgGCGetEmailTemplateResponse) ProtoMessage() {}
func (*CMsgGCGetEmailTemplateResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{34}
}
func (m *CMsgGCGetEmailTemplateResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCGetEmailTemplateResponse.Unmarshal(m, b)
}
func (m *CMsgGCGetEmailTemplateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCGetEmailTemplateResponse.Marshal(b, m, deterministic)
}
func (m *CMsgGCGetEmailTemplateResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCGetEmailTemplateResponse.Merge(m, src)
}
func (m *CMsgGCGetEmailTemplateResponse) XXX_Size() int {
return xxx_messageInfo_CMsgGCGetEmailTemplateResponse.Size(m)
}
func (m *CMsgGCGetEmailTemplateResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCGetEmailTemplateResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCGetEmailTemplateResponse proto.InternalMessageInfo
const Default_CMsgGCGetEmailTemplateResponse_Eresult uint32 = 2
func (m *CMsgGCGetEmailTemplateResponse) GetEresult() uint32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgGCGetEmailTemplateResponse_Eresult
}
func (m *CMsgGCGetEmailTemplateResponse) GetTemplateExists() bool {
if m != nil && m.TemplateExists != nil {
return *m.TemplateExists
}
return false
}
func (m *CMsgGCGetEmailTemplateResponse) GetTemplate() string {
if m != nil && m.Template != nil {
return *m.Template
}
return ""
}
type CMsgAMGrantGuestPasses2 struct {
SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id,json=steamId" json:"steam_id,omitempty"`
PackageId *uint32 `protobuf:"varint,2,opt,name=package_id,json=packageId" json:"package_id,omitempty"`
PassesToGrant *int32 `protobuf:"varint,3,opt,name=passes_to_grant,json=passesToGrant" json:"passes_to_grant,omitempty"`
DaysToExpiration *int32 `protobuf:"varint,4,opt,name=days_to_expiration,json=daysToExpiration" json:"days_to_expiration,omitempty"`
Action *int32 `protobuf:"varint,5,opt,name=action" json:"action,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMGrantGuestPasses2) Reset() { *m = CMsgAMGrantGuestPasses2{} }
func (m *CMsgAMGrantGuestPasses2) String() string { return proto.CompactTextString(m) }
func (*CMsgAMGrantGuestPasses2) ProtoMessage() {}
func (*CMsgAMGrantGuestPasses2) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{35}
}
func (m *CMsgAMGrantGuestPasses2) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMGrantGuestPasses2.Unmarshal(m, b)
}
func (m *CMsgAMGrantGuestPasses2) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMGrantGuestPasses2.Marshal(b, m, deterministic)
}
func (m *CMsgAMGrantGuestPasses2) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMGrantGuestPasses2.Merge(m, src)
}
func (m *CMsgAMGrantGuestPasses2) XXX_Size() int {
return xxx_messageInfo_CMsgAMGrantGuestPasses2.Size(m)
}
func (m *CMsgAMGrantGuestPasses2) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMGrantGuestPasses2.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMGrantGuestPasses2 proto.InternalMessageInfo
func (m *CMsgAMGrantGuestPasses2) GetSteamId() uint64 {
if m != nil && m.SteamId != nil {
return *m.SteamId
}
return 0
}
func (m *CMsgAMGrantGuestPasses2) GetPackageId() uint32 {
if m != nil && m.PackageId != nil {
return *m.PackageId
}
return 0
}
func (m *CMsgAMGrantGuestPasses2) GetPassesToGrant() int32 {
if m != nil && m.PassesToGrant != nil {
return *m.PassesToGrant
}
return 0
}
func (m *CMsgAMGrantGuestPasses2) GetDaysToExpiration() int32 {
if m != nil && m.DaysToExpiration != nil {
return *m.DaysToExpiration
}
return 0
}
func (m *CMsgAMGrantGuestPasses2) GetAction() int32 {
if m != nil && m.Action != nil {
return *m.Action
}
return 0
}
type CMsgAMGrantGuestPasses2Response struct {
Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"`
PassesGranted *int32 `protobuf:"varint,2,opt,name=passes_granted,json=passesGranted,def=0" json:"passes_granted,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgAMGrantGuestPasses2Response) Reset() { *m = CMsgAMGrantGuestPasses2Response{} }
func (m *CMsgAMGrantGuestPasses2Response) String() string { return proto.CompactTextString(m) }
func (*CMsgAMGrantGuestPasses2Response) ProtoMessage() {}
func (*CMsgAMGrantGuestPasses2Response) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{36}
}
func (m *CMsgAMGrantGuestPasses2Response) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgAMGrantGuestPasses2Response.Unmarshal(m, b)
}
func (m *CMsgAMGrantGuestPasses2Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgAMGrantGuestPasses2Response.Marshal(b, m, deterministic)
}
func (m *CMsgAMGrantGuestPasses2Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgAMGrantGuestPasses2Response.Merge(m, src)
}
func (m *CMsgAMGrantGuestPasses2Response) XXX_Size() int {
return xxx_messageInfo_CMsgAMGrantGuestPasses2Response.Size(m)
}
func (m *CMsgAMGrantGuestPasses2Response) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgAMGrantGuestPasses2Response.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgAMGrantGuestPasses2Response proto.InternalMessageInfo
const Default_CMsgAMGrantGuestPasses2Response_Eresult int32 = 2
const Default_CMsgAMGrantGuestPasses2Response_PassesGranted int32 = 0
func (m *CMsgAMGrantGuestPasses2Response) GetEresult() int32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgAMGrantGuestPasses2Response_Eresult
}
func (m *CMsgAMGrantGuestPasses2Response) GetPassesGranted() int32 {
if m != nil && m.PassesGranted != nil {
return *m.PassesGranted
}
return Default_CMsgAMGrantGuestPasses2Response_PassesGranted
}
type CGCSystemMsg_GetAccountDetails struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCSystemMsg_GetAccountDetails) Reset() { *m = CGCSystemMsg_GetAccountDetails{} }
func (m *CGCSystemMsg_GetAccountDetails) String() string { return proto.CompactTextString(m) }
func (*CGCSystemMsg_GetAccountDetails) ProtoMessage() {}
func (*CGCSystemMsg_GetAccountDetails) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{37}
}
func (m *CGCSystemMsg_GetAccountDetails) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCSystemMsg_GetAccountDetails.Unmarshal(m, b)
}
func (m *CGCSystemMsg_GetAccountDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCSystemMsg_GetAccountDetails.Marshal(b, m, deterministic)
}
func (m *CGCSystemMsg_GetAccountDetails) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCSystemMsg_GetAccountDetails.Merge(m, src)
}
func (m *CGCSystemMsg_GetAccountDetails) XXX_Size() int {
return xxx_messageInfo_CGCSystemMsg_GetAccountDetails.Size(m)
}
func (m *CGCSystemMsg_GetAccountDetails) XXX_DiscardUnknown() {
xxx_messageInfo_CGCSystemMsg_GetAccountDetails.DiscardUnknown(m)
}
var xxx_messageInfo_CGCSystemMsg_GetAccountDetails proto.InternalMessageInfo
func (m *CGCSystemMsg_GetAccountDetails) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
type CGCSystemMsg_GetAccountDetails_Response struct {
EresultDeprecated *uint32 `protobuf:"varint,1,opt,name=eresult_deprecated,json=eresultDeprecated,def=2" json:"eresult_deprecated,omitempty"`
AccountName *string `protobuf:"bytes,2,opt,name=account_name,json=accountName" json:"account_name,omitempty"`
PersonaName *string `protobuf:"bytes,3,opt,name=persona_name,json=personaName" json:"persona_name,omitempty"`
IsProfilePublic *bool `protobuf:"varint,4,opt,name=is_profile_public,json=isProfilePublic" json:"is_profile_public,omitempty"`
IsInventoryPublic *bool `protobuf:"varint,5,opt,name=is_inventory_public,json=isInventoryPublic" json:"is_inventory_public,omitempty"`
IsVacBanned *bool `protobuf:"varint,7,opt,name=is_vac_banned,json=isVacBanned" json:"is_vac_banned,omitempty"`
IsCyberCafe *bool `protobuf:"varint,8,opt,name=is_cyber_cafe,json=isCyberCafe" json:"is_cyber_cafe,omitempty"`
IsSchoolAccount *bool `protobuf:"varint,9,opt,name=is_school_account,json=isSchoolAccount" json:"is_school_account,omitempty"`
IsLimited *bool `protobuf:"varint,10,opt,name=is_limited,json=isLimited" json:"is_limited,omitempty"`
IsSubscribed *bool `protobuf:"varint,11,opt,name=is_subscribed,json=isSubscribed" json:"is_subscribed,omitempty"`
Package *uint32 `protobuf:"varint,12,opt,name=package" json:"package,omitempty"`
IsFreeTrialAccount *bool `protobuf:"varint,13,opt,name=is_free_trial_account,json=isFreeTrialAccount" json:"is_free_trial_account,omitempty"`
FreeTrialExpiration *uint32 `protobuf:"varint,14,opt,name=free_trial_expiration,json=freeTrialExpiration" json:"free_trial_expiration,omitempty"`
IsLowViolence *bool `protobuf:"varint,15,opt,name=is_low_violence,json=isLowViolence" json:"is_low_violence,omitempty"`
IsAccountLockedDown *bool `protobuf:"varint,16,opt,name=is_account_locked_down,json=isAccountLockedDown" json:"is_account_locked_down,omitempty"`
IsCommunityBanned *bool `protobuf:"varint,17,opt,name=is_community_banned,json=isCommunityBanned" json:"is_community_banned,omitempty"`
IsTradeBanned *bool `protobuf:"varint,18,opt,name=is_trade_banned,json=isTradeBanned" json:"is_trade_banned,omitempty"`
TradeBanExpiration *uint32 `protobuf:"varint,19,opt,name=trade_ban_expiration,json=tradeBanExpiration" json:"trade_ban_expiration,omitempty"`
Accountid *uint32 `protobuf:"varint,20,opt,name=accountid" json:"accountid,omitempty"`
SuspensionEndTime *uint32 `protobuf:"varint,21,opt,name=suspension_end_time,json=suspensionEndTime" json:"suspension_end_time,omitempty"`
Currency *string `protobuf:"bytes,22,opt,name=currency" json:"currency,omitempty"`
SteamLevel *uint32 `protobuf:"varint,23,opt,name=steam_level,json=steamLevel" json:"steam_level,omitempty"`
FriendCount *uint32 `protobuf:"varint,24,opt,name=friend_count,json=friendCount" json:"friend_count,omitempty"`
AccountCreationTime *uint32 `protobuf:"varint,25,opt,name=account_creation_time,json=accountCreationTime" json:"account_creation_time,omitempty"`
IsSteamguardEnabled *bool `protobuf:"varint,27,opt,name=is_steamguard_enabled,json=isSteamguardEnabled" json:"is_steamguard_enabled,omitempty"`
IsPhoneVerified *bool `protobuf:"varint,28,opt,name=is_phone_verified,json=isPhoneVerified" json:"is_phone_verified,omitempty"`
IsTwoFactorAuthEnabled *bool `protobuf:"varint,29,opt,name=is_two_factor_auth_enabled,json=isTwoFactorAuthEnabled" json:"is_two_factor_auth_enabled,omitempty"`
TwoFactorEnabledTime *uint32 `protobuf:"varint,30,opt,name=two_factor_enabled_time,json=twoFactorEnabledTime" json:"two_factor_enabled_time,omitempty"`
PhoneVerificationTime *uint32 `protobuf:"varint,31,opt,name=phone_verification_time,json=phoneVerificationTime" json:"phone_verification_time,omitempty"`
PhoneId *uint64 `protobuf:"varint,33,opt,name=phone_id,json=phoneId" json:"phone_id,omitempty"`
IsPhoneIdentifying *bool `protobuf:"varint,34,opt,name=is_phone_identifying,json=isPhoneIdentifying" json:"is_phone_identifying,omitempty"`
RtIdentityLinked *uint32 `protobuf:"varint,35,opt,name=rt_identity_linked,json=rtIdentityLinked" json:"rt_identity_linked,omitempty"`
RtBirthDate *uint32 `protobuf:"varint,36,opt,name=rt_birth_date,json=rtBirthDate" json:"rt_birth_date,omitempty"`
TxnCountryCode *string `protobuf:"bytes,37,opt,name=txn_country_code,json=txnCountryCode" json:"txn_country_code,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCSystemMsg_GetAccountDetails_Response) Reset() {
*m = CGCSystemMsg_GetAccountDetails_Response{}
}
func (m *CGCSystemMsg_GetAccountDetails_Response) String() string { return proto.CompactTextString(m) }
func (*CGCSystemMsg_GetAccountDetails_Response) ProtoMessage() {}
func (*CGCSystemMsg_GetAccountDetails_Response) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{38}
}
func (m *CGCSystemMsg_GetAccountDetails_Response) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCSystemMsg_GetAccountDetails_Response.Unmarshal(m, b)
}
func (m *CGCSystemMsg_GetAccountDetails_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCSystemMsg_GetAccountDetails_Response.Marshal(b, m, deterministic)
}
func (m *CGCSystemMsg_GetAccountDetails_Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCSystemMsg_GetAccountDetails_Response.Merge(m, src)
}
func (m *CGCSystemMsg_GetAccountDetails_Response) XXX_Size() int {
return xxx_messageInfo_CGCSystemMsg_GetAccountDetails_Response.Size(m)
}
func (m *CGCSystemMsg_GetAccountDetails_Response) XXX_DiscardUnknown() {
xxx_messageInfo_CGCSystemMsg_GetAccountDetails_Response.DiscardUnknown(m)
}
var xxx_messageInfo_CGCSystemMsg_GetAccountDetails_Response proto.InternalMessageInfo
const Default_CGCSystemMsg_GetAccountDetails_Response_EresultDeprecated uint32 = 2
func (m *CGCSystemMsg_GetAccountDetails_Response) GetEresultDeprecated() uint32 {
if m != nil && m.EresultDeprecated != nil {
return *m.EresultDeprecated
}
return Default_CGCSystemMsg_GetAccountDetails_Response_EresultDeprecated
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetAccountName() string {
if m != nil && m.AccountName != nil {
return *m.AccountName
}
return ""
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetPersonaName() string {
if m != nil && m.PersonaName != nil {
return *m.PersonaName
}
return ""
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsProfilePublic() bool {
if m != nil && m.IsProfilePublic != nil {
return *m.IsProfilePublic
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsInventoryPublic() bool {
if m != nil && m.IsInventoryPublic != nil {
return *m.IsInventoryPublic
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsVacBanned() bool {
if m != nil && m.IsVacBanned != nil {
return *m.IsVacBanned
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsCyberCafe() bool {
if m != nil && m.IsCyberCafe != nil {
return *m.IsCyberCafe
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsSchoolAccount() bool {
if m != nil && m.IsSchoolAccount != nil {
return *m.IsSchoolAccount
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsLimited() bool {
if m != nil && m.IsLimited != nil {
return *m.IsLimited
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsSubscribed() bool {
if m != nil && m.IsSubscribed != nil {
return *m.IsSubscribed
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetPackage() uint32 {
if m != nil && m.Package != nil {
return *m.Package
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsFreeTrialAccount() bool {
if m != nil && m.IsFreeTrialAccount != nil {
return *m.IsFreeTrialAccount
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetFreeTrialExpiration() uint32 {
if m != nil && m.FreeTrialExpiration != nil {
return *m.FreeTrialExpiration
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsLowViolence() bool {
if m != nil && m.IsLowViolence != nil {
return *m.IsLowViolence
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsAccountLockedDown() bool {
if m != nil && m.IsAccountLockedDown != nil {
return *m.IsAccountLockedDown
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsCommunityBanned() bool {
if m != nil && m.IsCommunityBanned != nil {
return *m.IsCommunityBanned
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsTradeBanned() bool {
if m != nil && m.IsTradeBanned != nil {
return *m.IsTradeBanned
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetTradeBanExpiration() uint32 {
if m != nil && m.TradeBanExpiration != nil {
return *m.TradeBanExpiration
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetAccountid() uint32 {
if m != nil && m.Accountid != nil {
return *m.Accountid
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetSuspensionEndTime() uint32 {
if m != nil && m.SuspensionEndTime != nil {
return *m.SuspensionEndTime
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetCurrency() string {
if m != nil && m.Currency != nil {
return *m.Currency
}
return ""
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetSteamLevel() uint32 {
if m != nil && m.SteamLevel != nil {
return *m.SteamLevel
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetFriendCount() uint32 {
if m != nil && m.FriendCount != nil {
return *m.FriendCount
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetAccountCreationTime() uint32 {
if m != nil && m.AccountCreationTime != nil {
return *m.AccountCreationTime
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsSteamguardEnabled() bool {
if m != nil && m.IsSteamguardEnabled != nil {
return *m.IsSteamguardEnabled
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsPhoneVerified() bool {
if m != nil && m.IsPhoneVerified != nil {
return *m.IsPhoneVerified
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsTwoFactorAuthEnabled() bool {
if m != nil && m.IsTwoFactorAuthEnabled != nil {
return *m.IsTwoFactorAuthEnabled
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetTwoFactorEnabledTime() uint32 {
if m != nil && m.TwoFactorEnabledTime != nil {
return *m.TwoFactorEnabledTime
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetPhoneVerificationTime() uint32 {
if m != nil && m.PhoneVerificationTime != nil {
return *m.PhoneVerificationTime
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetPhoneId() uint64 {
if m != nil && m.PhoneId != nil {
return *m.PhoneId
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetIsPhoneIdentifying() bool {
if m != nil && m.IsPhoneIdentifying != nil {
return *m.IsPhoneIdentifying
}
return false
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetRtIdentityLinked() uint32 {
if m != nil && m.RtIdentityLinked != nil {
return *m.RtIdentityLinked
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetRtBirthDate() uint32 {
if m != nil && m.RtBirthDate != nil {
return *m.RtBirthDate
}
return 0
}
func (m *CGCSystemMsg_GetAccountDetails_Response) GetTxnCountryCode() string {
if m != nil && m.TxnCountryCode != nil {
return *m.TxnCountryCode
}
return ""
}
type CMsgGCGetPersonaNames struct {
Steamids []uint64 `protobuf:"fixed64,1,rep,name=steamids" json:"steamids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCGetPersonaNames) Reset() { *m = CMsgGCGetPersonaNames{} }
func (m *CMsgGCGetPersonaNames) String() string { return proto.CompactTextString(m) }
func (*CMsgGCGetPersonaNames) ProtoMessage() {}
func (*CMsgGCGetPersonaNames) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{39}
}
func (m *CMsgGCGetPersonaNames) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCGetPersonaNames.Unmarshal(m, b)
}
func (m *CMsgGCGetPersonaNames) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCGetPersonaNames.Marshal(b, m, deterministic)
}
func (m *CMsgGCGetPersonaNames) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCGetPersonaNames.Merge(m, src)
}
func (m *CMsgGCGetPersonaNames) XXX_Size() int {
return xxx_messageInfo_CMsgGCGetPersonaNames.Size(m)
}
func (m *CMsgGCGetPersonaNames) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCGetPersonaNames.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCGetPersonaNames proto.InternalMessageInfo
func (m *CMsgGCGetPersonaNames) GetSteamids() []uint64 {
if m != nil {
return m.Steamids
}
return nil
}
type CMsgGCGetPersonaNames_Response struct {
SucceededLookups []*CMsgGCGetPersonaNames_Response_PersonaName `protobuf:"bytes,1,rep,name=succeeded_lookups,json=succeededLookups" json:"succeeded_lookups,omitempty"`
FailedLookupSteamids []uint64 `protobuf:"fixed64,2,rep,name=failed_lookup_steamids,json=failedLookupSteamids" json:"failed_lookup_steamids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCGetPersonaNames_Response) Reset() { *m = CMsgGCGetPersonaNames_Response{} }
func (m *CMsgGCGetPersonaNames_Response) String() string { return proto.CompactTextString(m) }
func (*CMsgGCGetPersonaNames_Response) ProtoMessage() {}
func (*CMsgGCGetPersonaNames_Response) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{40}
}
func (m *CMsgGCGetPersonaNames_Response) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCGetPersonaNames_Response.Unmarshal(m, b)
}
func (m *CMsgGCGetPersonaNames_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCGetPersonaNames_Response.Marshal(b, m, deterministic)
}
func (m *CMsgGCGetPersonaNames_Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCGetPersonaNames_Response.Merge(m, src)
}
func (m *CMsgGCGetPersonaNames_Response) XXX_Size() int {
return xxx_messageInfo_CMsgGCGetPersonaNames_Response.Size(m)
}
func (m *CMsgGCGetPersonaNames_Response) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCGetPersonaNames_Response.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCGetPersonaNames_Response proto.InternalMessageInfo
func (m *CMsgGCGetPersonaNames_Response) GetSucceededLookups() []*CMsgGCGetPersonaNames_Response_PersonaName {
if m != nil {
return m.SucceededLookups
}
return nil
}
func (m *CMsgGCGetPersonaNames_Response) GetFailedLookupSteamids() []uint64 {
if m != nil {
return m.FailedLookupSteamids
}
return nil
}
type CMsgGCGetPersonaNames_Response_PersonaName struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
PersonaName *string `protobuf:"bytes,2,opt,name=persona_name,json=personaName" json:"persona_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCGetPersonaNames_Response_PersonaName) Reset() {
*m = CMsgGCGetPersonaNames_Response_PersonaName{}
}
func (m *CMsgGCGetPersonaNames_Response_PersonaName) String() string {
return proto.CompactTextString(m)
}
func (*CMsgGCGetPersonaNames_Response_PersonaName) ProtoMessage() {}
func (*CMsgGCGetPersonaNames_Response_PersonaName) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{40, 0}
}
func (m *CMsgGCGetPersonaNames_Response_PersonaName) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCGetPersonaNames_Response_PersonaName.Unmarshal(m, b)
}
func (m *CMsgGCGetPersonaNames_Response_PersonaName) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCGetPersonaNames_Response_PersonaName.Marshal(b, m, deterministic)
}
func (m *CMsgGCGetPersonaNames_Response_PersonaName) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCGetPersonaNames_Response_PersonaName.Merge(m, src)
}
func (m *CMsgGCGetPersonaNames_Response_PersonaName) XXX_Size() int {
return xxx_messageInfo_CMsgGCGetPersonaNames_Response_PersonaName.Size(m)
}
func (m *CMsgGCGetPersonaNames_Response_PersonaName) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCGetPersonaNames_Response_PersonaName.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCGetPersonaNames_Response_PersonaName proto.InternalMessageInfo
func (m *CMsgGCGetPersonaNames_Response_PersonaName) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CMsgGCGetPersonaNames_Response_PersonaName) GetPersonaName() string {
if m != nil && m.PersonaName != nil {
return *m.PersonaName
}
return ""
}
type CMsgGCCheckFriendship struct {
SteamidLeft *uint64 `protobuf:"fixed64,1,opt,name=steamid_left,json=steamidLeft" json:"steamid_left,omitempty"`
SteamidRight *uint64 `protobuf:"fixed64,2,opt,name=steamid_right,json=steamidRight" json:"steamid_right,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCCheckFriendship) Reset() { *m = CMsgGCCheckFriendship{} }
func (m *CMsgGCCheckFriendship) String() string { return proto.CompactTextString(m) }
func (*CMsgGCCheckFriendship) ProtoMessage() {}
func (*CMsgGCCheckFriendship) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{41}
}
func (m *CMsgGCCheckFriendship) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCCheckFriendship.Unmarshal(m, b)
}
func (m *CMsgGCCheckFriendship) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCCheckFriendship.Marshal(b, m, deterministic)
}
func (m *CMsgGCCheckFriendship) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCCheckFriendship.Merge(m, src)
}
func (m *CMsgGCCheckFriendship) XXX_Size() int {
return xxx_messageInfo_CMsgGCCheckFriendship.Size(m)
}
func (m *CMsgGCCheckFriendship) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCCheckFriendship.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCCheckFriendship proto.InternalMessageInfo
func (m *CMsgGCCheckFriendship) GetSteamidLeft() uint64 {
if m != nil && m.SteamidLeft != nil {
return *m.SteamidLeft
}
return 0
}
func (m *CMsgGCCheckFriendship) GetSteamidRight() uint64 {
if m != nil && m.SteamidRight != nil {
return *m.SteamidRight
}
return 0
}
type CMsgGCCheckFriendship_Response struct {
Success *bool `protobuf:"varint,1,opt,name=success" json:"success,omitempty"`
FoundFriendship *bool `protobuf:"varint,2,opt,name=found_friendship,json=foundFriendship" json:"found_friendship,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCCheckFriendship_Response) Reset() { *m = CMsgGCCheckFriendship_Response{} }
func (m *CMsgGCCheckFriendship_Response) String() string { return proto.CompactTextString(m) }
func (*CMsgGCCheckFriendship_Response) ProtoMessage() {}
func (*CMsgGCCheckFriendship_Response) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{42}
}
func (m *CMsgGCCheckFriendship_Response) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCCheckFriendship_Response.Unmarshal(m, b)
}
func (m *CMsgGCCheckFriendship_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCCheckFriendship_Response.Marshal(b, m, deterministic)
}
func (m *CMsgGCCheckFriendship_Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCCheckFriendship_Response.Merge(m, src)
}
func (m *CMsgGCCheckFriendship_Response) XXX_Size() int {
return xxx_messageInfo_CMsgGCCheckFriendship_Response.Size(m)
}
func (m *CMsgGCCheckFriendship_Response) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCCheckFriendship_Response.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCCheckFriendship_Response proto.InternalMessageInfo
func (m *CMsgGCCheckFriendship_Response) GetSuccess() bool {
if m != nil && m.Success != nil {
return *m.Success
}
return false
}
func (m *CMsgGCCheckFriendship_Response) GetFoundFriendship() bool {
if m != nil && m.FoundFriendship != nil {
return *m.FoundFriendship
}
return false
}
type CMsgGCMsgMasterSetDirectory struct {
MasterDirIndex *uint32 `protobuf:"varint,1,opt,name=master_dir_index,json=masterDirIndex" json:"master_dir_index,omitempty"`
Dir []*CMsgGCMsgMasterSetDirectory_SubGC `protobuf:"bytes,2,rep,name=dir" json:"dir,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgMasterSetDirectory) Reset() { *m = CMsgGCMsgMasterSetDirectory{} }
func (m *CMsgGCMsgMasterSetDirectory) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgMasterSetDirectory) ProtoMessage() {}
func (*CMsgGCMsgMasterSetDirectory) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{43}
}
func (m *CMsgGCMsgMasterSetDirectory) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgMasterSetDirectory.Unmarshal(m, b)
}
func (m *CMsgGCMsgMasterSetDirectory) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgMasterSetDirectory.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgMasterSetDirectory) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgMasterSetDirectory.Merge(m, src)
}
func (m *CMsgGCMsgMasterSetDirectory) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgMasterSetDirectory.Size(m)
}
func (m *CMsgGCMsgMasterSetDirectory) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgMasterSetDirectory.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgMasterSetDirectory proto.InternalMessageInfo
func (m *CMsgGCMsgMasterSetDirectory) GetMasterDirIndex() uint32 {
if m != nil && m.MasterDirIndex != nil {
return *m.MasterDirIndex
}
return 0
}
func (m *CMsgGCMsgMasterSetDirectory) GetDir() []*CMsgGCMsgMasterSetDirectory_SubGC {
if m != nil {
return m.Dir
}
return nil
}
type CMsgGCMsgMasterSetDirectory_SubGC struct {
DirIndex *uint32 `protobuf:"varint,1,opt,name=dir_index,json=dirIndex" json:"dir_index,omitempty"`
Name *string `protobuf:"bytes,2,opt,name=name" json:"name,omitempty"`
Box *string `protobuf:"bytes,3,opt,name=box" json:"box,omitempty"`
CommandLine *string `protobuf:"bytes,4,opt,name=command_line,json=commandLine" json:"command_line,omitempty"`
GcBinary *string `protobuf:"bytes,5,opt,name=gc_binary,json=gcBinary" json:"gc_binary,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) Reset() { *m = CMsgGCMsgMasterSetDirectory_SubGC{} }
func (m *CMsgGCMsgMasterSetDirectory_SubGC) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgMasterSetDirectory_SubGC) ProtoMessage() {}
func (*CMsgGCMsgMasterSetDirectory_SubGC) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{43, 0}
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgMasterSetDirectory_SubGC.Unmarshal(m, b)
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgMasterSetDirectory_SubGC.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgMasterSetDirectory_SubGC.Merge(m, src)
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgMasterSetDirectory_SubGC.Size(m)
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgMasterSetDirectory_SubGC.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgMasterSetDirectory_SubGC proto.InternalMessageInfo
func (m *CMsgGCMsgMasterSetDirectory_SubGC) GetDirIndex() uint32 {
if m != nil && m.DirIndex != nil {
return *m.DirIndex
}
return 0
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) GetBox() string {
if m != nil && m.Box != nil {
return *m.Box
}
return ""
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) GetCommandLine() string {
if m != nil && m.CommandLine != nil {
return *m.CommandLine
}
return ""
}
func (m *CMsgGCMsgMasterSetDirectory_SubGC) GetGcBinary() string {
if m != nil && m.GcBinary != nil {
return *m.GcBinary
}
return ""
}
type CMsgGCMsgMasterSetDirectory_Response struct {
Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgMasterSetDirectory_Response) Reset() { *m = CMsgGCMsgMasterSetDirectory_Response{} }
func (m *CMsgGCMsgMasterSetDirectory_Response) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgMasterSetDirectory_Response) ProtoMessage() {}
func (*CMsgGCMsgMasterSetDirectory_Response) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{44}
}
func (m *CMsgGCMsgMasterSetDirectory_Response) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgMasterSetDirectory_Response.Unmarshal(m, b)
}
func (m *CMsgGCMsgMasterSetDirectory_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgMasterSetDirectory_Response.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgMasterSetDirectory_Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgMasterSetDirectory_Response.Merge(m, src)
}
func (m *CMsgGCMsgMasterSetDirectory_Response) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgMasterSetDirectory_Response.Size(m)
}
func (m *CMsgGCMsgMasterSetDirectory_Response) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgMasterSetDirectory_Response.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgMasterSetDirectory_Response proto.InternalMessageInfo
const Default_CMsgGCMsgMasterSetDirectory_Response_Eresult int32 = 2
func (m *CMsgGCMsgMasterSetDirectory_Response) GetEresult() int32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgGCMsgMasterSetDirectory_Response_Eresult
}
type CMsgGCMsgWebAPIJobRequestForwardResponse struct {
DirIndex *uint32 `protobuf:"varint,1,opt,name=dir_index,json=dirIndex" json:"dir_index,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgWebAPIJobRequestForwardResponse) Reset() {
*m = CMsgGCMsgWebAPIJobRequestForwardResponse{}
}
func (m *CMsgGCMsgWebAPIJobRequestForwardResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgWebAPIJobRequestForwardResponse) ProtoMessage() {}
func (*CMsgGCMsgWebAPIJobRequestForwardResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{45}
}
func (m *CMsgGCMsgWebAPIJobRequestForwardResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgWebAPIJobRequestForwardResponse.Unmarshal(m, b)
}
func (m *CMsgGCMsgWebAPIJobRequestForwardResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgWebAPIJobRequestForwardResponse.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgWebAPIJobRequestForwardResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgWebAPIJobRequestForwardResponse.Merge(m, src)
}
func (m *CMsgGCMsgWebAPIJobRequestForwardResponse) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgWebAPIJobRequestForwardResponse.Size(m)
}
func (m *CMsgGCMsgWebAPIJobRequestForwardResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgWebAPIJobRequestForwardResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgWebAPIJobRequestForwardResponse proto.InternalMessageInfo
func (m *CMsgGCMsgWebAPIJobRequestForwardResponse) GetDirIndex() uint32 {
if m != nil && m.DirIndex != nil {
return *m.DirIndex
}
return 0
}
type CGCSystemMsg_GetPurchaseTrust_Request struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCSystemMsg_GetPurchaseTrust_Request) Reset() { *m = CGCSystemMsg_GetPurchaseTrust_Request{} }
func (m *CGCSystemMsg_GetPurchaseTrust_Request) String() string { return proto.CompactTextString(m) }
func (*CGCSystemMsg_GetPurchaseTrust_Request) ProtoMessage() {}
func (*CGCSystemMsg_GetPurchaseTrust_Request) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{46}
}
func (m *CGCSystemMsg_GetPurchaseTrust_Request) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Request.Unmarshal(m, b)
}
func (m *CGCSystemMsg_GetPurchaseTrust_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Request.Marshal(b, m, deterministic)
}
func (m *CGCSystemMsg_GetPurchaseTrust_Request) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Request.Merge(m, src)
}
func (m *CGCSystemMsg_GetPurchaseTrust_Request) XXX_Size() int {
return xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Request.Size(m)
}
func (m *CGCSystemMsg_GetPurchaseTrust_Request) XXX_DiscardUnknown() {
xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Request.DiscardUnknown(m)
}
var xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Request proto.InternalMessageInfo
func (m *CGCSystemMsg_GetPurchaseTrust_Request) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CGCSystemMsg_GetPurchaseTrust_Response struct {
HasPriorPurchaseHistory *bool `protobuf:"varint,1,opt,name=has_prior_purchase_history,json=hasPriorPurchaseHistory" json:"has_prior_purchase_history,omitempty"`
HasNoRecentPasswordResets *bool `protobuf:"varint,2,opt,name=has_no_recent_password_resets,json=hasNoRecentPasswordResets" json:"has_no_recent_password_resets,omitempty"`
IsWalletCashTrusted *bool `protobuf:"varint,3,opt,name=is_wallet_cash_trusted,json=isWalletCashTrusted" json:"is_wallet_cash_trusted,omitempty"`
TimeAllTrusted *uint32 `protobuf:"varint,4,opt,name=time_all_trusted,json=timeAllTrusted" json:"time_all_trusted,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) Reset() {
*m = CGCSystemMsg_GetPurchaseTrust_Response{}
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) String() string { return proto.CompactTextString(m) }
func (*CGCSystemMsg_GetPurchaseTrust_Response) ProtoMessage() {}
func (*CGCSystemMsg_GetPurchaseTrust_Response) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{47}
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Response.Unmarshal(m, b)
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Response.Marshal(b, m, deterministic)
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Response.Merge(m, src)
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) XXX_Size() int {
return xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Response.Size(m)
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) XXX_DiscardUnknown() {
xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Response.DiscardUnknown(m)
}
var xxx_messageInfo_CGCSystemMsg_GetPurchaseTrust_Response proto.InternalMessageInfo
func (m *CGCSystemMsg_GetPurchaseTrust_Response) GetHasPriorPurchaseHistory() bool {
if m != nil && m.HasPriorPurchaseHistory != nil {
return *m.HasPriorPurchaseHistory
}
return false
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) GetHasNoRecentPasswordResets() bool {
if m != nil && m.HasNoRecentPasswordResets != nil {
return *m.HasNoRecentPasswordResets
}
return false
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) GetIsWalletCashTrusted() bool {
if m != nil && m.IsWalletCashTrusted != nil {
return *m.IsWalletCashTrusted
}
return false
}
func (m *CGCSystemMsg_GetPurchaseTrust_Response) GetTimeAllTrusted() uint32 {
if m != nil && m.TimeAllTrusted != nil {
return *m.TimeAllTrusted
}
return 0
}
type CMsgGCHAccountVacStatusChange struct {
SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id,json=steamId" json:"steam_id,omitempty"`
AppId *uint32 `protobuf:"varint,2,opt,name=app_id,json=appId" json:"app_id,omitempty"`
RtimeVacbanStarts *uint32 `protobuf:"varint,3,opt,name=rtime_vacban_starts,json=rtimeVacbanStarts" json:"rtime_vacban_starts,omitempty"`
IsBannedNow *bool `protobuf:"varint,4,opt,name=is_banned_now,json=isBannedNow" json:"is_banned_now,omitempty"`
IsBannedFuture *bool `protobuf:"varint,5,opt,name=is_banned_future,json=isBannedFuture" json:"is_banned_future,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCHAccountVacStatusChange) Reset() { *m = CMsgGCHAccountVacStatusChange{} }
func (m *CMsgGCHAccountVacStatusChange) String() string { return proto.CompactTextString(m) }
func (*CMsgGCHAccountVacStatusChange) ProtoMessage() {}
func (*CMsgGCHAccountVacStatusChange) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{48}
}
func (m *CMsgGCHAccountVacStatusChange) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCHAccountVacStatusChange.Unmarshal(m, b)
}
func (m *CMsgGCHAccountVacStatusChange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCHAccountVacStatusChange.Marshal(b, m, deterministic)
}
func (m *CMsgGCHAccountVacStatusChange) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCHAccountVacStatusChange.Merge(m, src)
}
func (m *CMsgGCHAccountVacStatusChange) XXX_Size() int {
return xxx_messageInfo_CMsgGCHAccountVacStatusChange.Size(m)
}
func (m *CMsgGCHAccountVacStatusChange) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCHAccountVacStatusChange.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCHAccountVacStatusChange proto.InternalMessageInfo
func (m *CMsgGCHAccountVacStatusChange) GetSteamId() uint64 {
if m != nil && m.SteamId != nil {
return *m.SteamId
}
return 0
}
func (m *CMsgGCHAccountVacStatusChange) GetAppId() uint32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
func (m *CMsgGCHAccountVacStatusChange) GetRtimeVacbanStarts() uint32 {
if m != nil && m.RtimeVacbanStarts != nil {
return *m.RtimeVacbanStarts
}
return 0
}
func (m *CMsgGCHAccountVacStatusChange) GetIsBannedNow() bool {
if m != nil && m.IsBannedNow != nil {
return *m.IsBannedNow
}
return false
}
func (m *CMsgGCHAccountVacStatusChange) GetIsBannedFuture() bool {
if m != nil && m.IsBannedFuture != nil {
return *m.IsBannedFuture
}
return false
}
type CMsgGCGetPartnerAccountLink struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCGetPartnerAccountLink) Reset() { *m = CMsgGCGetPartnerAccountLink{} }
func (m *CMsgGCGetPartnerAccountLink) String() string { return proto.CompactTextString(m) }
func (*CMsgGCGetPartnerAccountLink) ProtoMessage() {}
func (*CMsgGCGetPartnerAccountLink) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{49}
}
func (m *CMsgGCGetPartnerAccountLink) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCGetPartnerAccountLink.Unmarshal(m, b)
}
func (m *CMsgGCGetPartnerAccountLink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCGetPartnerAccountLink.Marshal(b, m, deterministic)
}
func (m *CMsgGCGetPartnerAccountLink) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCGetPartnerAccountLink.Merge(m, src)
}
func (m *CMsgGCGetPartnerAccountLink) XXX_Size() int {
return xxx_messageInfo_CMsgGCGetPartnerAccountLink.Size(m)
}
func (m *CMsgGCGetPartnerAccountLink) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCGetPartnerAccountLink.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCGetPartnerAccountLink proto.InternalMessageInfo
func (m *CMsgGCGetPartnerAccountLink) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
type CMsgGCGetPartnerAccountLink_Response struct {
Pwid *uint32 `protobuf:"varint,1,opt,name=pwid" json:"pwid,omitempty"`
Nexonid *uint32 `protobuf:"varint,2,opt,name=nexonid" json:"nexonid,omitempty"`
Ageclass *int32 `protobuf:"varint,3,opt,name=ageclass" json:"ageclass,omitempty"`
IdVerified *bool `protobuf:"varint,4,opt,name=id_verified,json=idVerified,def=1" json:"id_verified,omitempty"`
IsAdult *bool `protobuf:"varint,5,opt,name=is_adult,json=isAdult" json:"is_adult,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCGetPartnerAccountLink_Response) Reset() { *m = CMsgGCGetPartnerAccountLink_Response{} }
func (m *CMsgGCGetPartnerAccountLink_Response) String() string { return proto.CompactTextString(m) }
func (*CMsgGCGetPartnerAccountLink_Response) ProtoMessage() {}
func (*CMsgGCGetPartnerAccountLink_Response) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{50}
}
func (m *CMsgGCGetPartnerAccountLink_Response) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCGetPartnerAccountLink_Response.Unmarshal(m, b)
}
func (m *CMsgGCGetPartnerAccountLink_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCGetPartnerAccountLink_Response.Marshal(b, m, deterministic)
}
func (m *CMsgGCGetPartnerAccountLink_Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCGetPartnerAccountLink_Response.Merge(m, src)
}
func (m *CMsgGCGetPartnerAccountLink_Response) XXX_Size() int {
return xxx_messageInfo_CMsgGCGetPartnerAccountLink_Response.Size(m)
}
func (m *CMsgGCGetPartnerAccountLink_Response) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCGetPartnerAccountLink_Response.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCGetPartnerAccountLink_Response proto.InternalMessageInfo
const Default_CMsgGCGetPartnerAccountLink_Response_IdVerified bool = true
func (m *CMsgGCGetPartnerAccountLink_Response) GetPwid() uint32 {
if m != nil && m.Pwid != nil {
return *m.Pwid
}
return 0
}
func (m *CMsgGCGetPartnerAccountLink_Response) GetNexonid() uint32 {
if m != nil && m.Nexonid != nil {
return *m.Nexonid
}
return 0
}
func (m *CMsgGCGetPartnerAccountLink_Response) GetAgeclass() int32 {
if m != nil && m.Ageclass != nil {
return *m.Ageclass
}
return 0
}
func (m *CMsgGCGetPartnerAccountLink_Response) GetIdVerified() bool {
if m != nil && m.IdVerified != nil {
return *m.IdVerified
}
return Default_CMsgGCGetPartnerAccountLink_Response_IdVerified
}
func (m *CMsgGCGetPartnerAccountLink_Response) GetIsAdult() bool {
if m != nil && m.IsAdult != nil {
return *m.IsAdult
}
return false
}
type CMsgGCRoutingInfo struct {
DirIndex []uint32 `protobuf:"varint,1,rep,name=dir_index,json=dirIndex" json:"dir_index,omitempty"`
Method *CMsgGCRoutingInfo_RoutingMethod `protobuf:"varint,2,opt,name=method,enum=CMsgGCRoutingInfo_RoutingMethod,def=0" json:"method,omitempty"`
Fallback *CMsgGCRoutingInfo_RoutingMethod `protobuf:"varint,3,opt,name=fallback,enum=CMsgGCRoutingInfo_RoutingMethod,def=1" json:"fallback,omitempty"`
ProtobufField *uint32 `protobuf:"varint,4,opt,name=protobuf_field,json=protobufField" json:"protobuf_field,omitempty"`
WebapiParam *string `protobuf:"bytes,5,opt,name=webapi_param,json=webapiParam" json:"webapi_param,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCRoutingInfo) Reset() { *m = CMsgGCRoutingInfo{} }
func (m *CMsgGCRoutingInfo) String() string { return proto.CompactTextString(m) }
func (*CMsgGCRoutingInfo) ProtoMessage() {}
func (*CMsgGCRoutingInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{51}
}
func (m *CMsgGCRoutingInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCRoutingInfo.Unmarshal(m, b)
}
func (m *CMsgGCRoutingInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCRoutingInfo.Marshal(b, m, deterministic)
}
func (m *CMsgGCRoutingInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCRoutingInfo.Merge(m, src)
}
func (m *CMsgGCRoutingInfo) XXX_Size() int {
return xxx_messageInfo_CMsgGCRoutingInfo.Size(m)
}
func (m *CMsgGCRoutingInfo) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCRoutingInfo.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCRoutingInfo proto.InternalMessageInfo
const Default_CMsgGCRoutingInfo_Method CMsgGCRoutingInfo_RoutingMethod = CMsgGCRoutingInfo_RANDOM
const Default_CMsgGCRoutingInfo_Fallback CMsgGCRoutingInfo_RoutingMethod = CMsgGCRoutingInfo_DISCARD
func (m *CMsgGCRoutingInfo) GetDirIndex() []uint32 {
if m != nil {
return m.DirIndex
}
return nil
}
func (m *CMsgGCRoutingInfo) GetMethod() CMsgGCRoutingInfo_RoutingMethod {
if m != nil && m.Method != nil {
return *m.Method
}
return Default_CMsgGCRoutingInfo_Method
}
func (m *CMsgGCRoutingInfo) GetFallback() CMsgGCRoutingInfo_RoutingMethod {
if m != nil && m.Fallback != nil {
return *m.Fallback
}
return Default_CMsgGCRoutingInfo_Fallback
}
func (m *CMsgGCRoutingInfo) GetProtobufField() uint32 {
if m != nil && m.ProtobufField != nil {
return *m.ProtobufField
}
return 0
}
func (m *CMsgGCRoutingInfo) GetWebapiParam() string {
if m != nil && m.WebapiParam != nil {
return *m.WebapiParam
}
return ""
}
type CMsgGCMsgMasterSetWebAPIRouting struct {
Entries []*CMsgGCMsgMasterSetWebAPIRouting_Entry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgMasterSetWebAPIRouting) Reset() { *m = CMsgGCMsgMasterSetWebAPIRouting{} }
func (m *CMsgGCMsgMasterSetWebAPIRouting) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgMasterSetWebAPIRouting) ProtoMessage() {}
func (*CMsgGCMsgMasterSetWebAPIRouting) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{52}
}
func (m *CMsgGCMsgMasterSetWebAPIRouting) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting.Unmarshal(m, b)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting.Merge(m, src)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting.Size(m)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting proto.InternalMessageInfo
func (m *CMsgGCMsgMasterSetWebAPIRouting) GetEntries() []*CMsgGCMsgMasterSetWebAPIRouting_Entry {
if m != nil {
return m.Entries
}
return nil
}
type CMsgGCMsgMasterSetWebAPIRouting_Entry struct {
InterfaceName *string `protobuf:"bytes,1,opt,name=interface_name,json=interfaceName" json:"interface_name,omitempty"`
MethodName *string `protobuf:"bytes,2,opt,name=method_name,json=methodName" json:"method_name,omitempty"`
Routing *CMsgGCRoutingInfo `protobuf:"bytes,3,opt,name=routing" json:"routing,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) Reset() { *m = CMsgGCMsgMasterSetWebAPIRouting_Entry{} }
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgMasterSetWebAPIRouting_Entry) ProtoMessage() {}
func (*CMsgGCMsgMasterSetWebAPIRouting_Entry) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{52, 0}
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Entry.Unmarshal(m, b)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Entry.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Entry.Merge(m, src)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Entry.Size(m)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Entry.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Entry proto.InternalMessageInfo
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) GetInterfaceName() string {
if m != nil && m.InterfaceName != nil {
return *m.InterfaceName
}
return ""
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) GetMethodName() string {
if m != nil && m.MethodName != nil {
return *m.MethodName
}
return ""
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Entry) GetRouting() *CMsgGCRoutingInfo {
if m != nil {
return m.Routing
}
return nil
}
type CMsgGCMsgMasterSetClientMsgRouting struct {
Entries []*CMsgGCMsgMasterSetClientMsgRouting_Entry `protobuf:"bytes,1,rep,name=entries" json:"entries,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgMasterSetClientMsgRouting) Reset() { *m = CMsgGCMsgMasterSetClientMsgRouting{} }
func (m *CMsgGCMsgMasterSetClientMsgRouting) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgMasterSetClientMsgRouting) ProtoMessage() {}
func (*CMsgGCMsgMasterSetClientMsgRouting) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{53}
}
func (m *CMsgGCMsgMasterSetClientMsgRouting) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting.Unmarshal(m, b)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting.Merge(m, src)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting.Size(m)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting proto.InternalMessageInfo
func (m *CMsgGCMsgMasterSetClientMsgRouting) GetEntries() []*CMsgGCMsgMasterSetClientMsgRouting_Entry {
if m != nil {
return m.Entries
}
return nil
}
type CMsgGCMsgMasterSetClientMsgRouting_Entry struct {
MsgType *uint32 `protobuf:"varint,1,opt,name=msg_type,json=msgType" json:"msg_type,omitempty"`
Routing *CMsgGCRoutingInfo `protobuf:"bytes,2,opt,name=routing" json:"routing,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Entry) Reset() {
*m = CMsgGCMsgMasterSetClientMsgRouting_Entry{}
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Entry) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgMasterSetClientMsgRouting_Entry) ProtoMessage() {}
func (*CMsgGCMsgMasterSetClientMsgRouting_Entry) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{53, 0}
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Entry) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Entry.Unmarshal(m, b)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Entry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Entry.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Entry) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Entry.Merge(m, src)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Entry) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Entry.Size(m)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Entry) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Entry.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Entry proto.InternalMessageInfo
func (m *CMsgGCMsgMasterSetClientMsgRouting_Entry) GetMsgType() uint32 {
if m != nil && m.MsgType != nil {
return *m.MsgType
}
return 0
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Entry) GetRouting() *CMsgGCRoutingInfo {
if m != nil {
return m.Routing
}
return nil
}
type CMsgGCMsgMasterSetWebAPIRouting_Response struct {
Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Response) Reset() {
*m = CMsgGCMsgMasterSetWebAPIRouting_Response{}
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Response) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgMasterSetWebAPIRouting_Response) ProtoMessage() {}
func (*CMsgGCMsgMasterSetWebAPIRouting_Response) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{54}
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Response) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Response.Unmarshal(m, b)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Response.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Response.Merge(m, src)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Response) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Response.Size(m)
}
func (m *CMsgGCMsgMasterSetWebAPIRouting_Response) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Response.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgMasterSetWebAPIRouting_Response proto.InternalMessageInfo
const Default_CMsgGCMsgMasterSetWebAPIRouting_Response_Eresult int32 = 2
func (m *CMsgGCMsgMasterSetWebAPIRouting_Response) GetEresult() int32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgGCMsgMasterSetWebAPIRouting_Response_Eresult
}
type CMsgGCMsgMasterSetClientMsgRouting_Response struct {
Eresult *int32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Response) Reset() {
*m = CMsgGCMsgMasterSetClientMsgRouting_Response{}
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Response) String() string {
return proto.CompactTextString(m)
}
func (*CMsgGCMsgMasterSetClientMsgRouting_Response) ProtoMessage() {}
func (*CMsgGCMsgMasterSetClientMsgRouting_Response) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{55}
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Response) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Response.Unmarshal(m, b)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Response.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Response) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Response.Merge(m, src)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Response) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Response.Size(m)
}
func (m *CMsgGCMsgMasterSetClientMsgRouting_Response) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Response.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgMasterSetClientMsgRouting_Response proto.InternalMessageInfo
const Default_CMsgGCMsgMasterSetClientMsgRouting_Response_Eresult int32 = 2
func (m *CMsgGCMsgMasterSetClientMsgRouting_Response) GetEresult() int32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgGCMsgMasterSetClientMsgRouting_Response_Eresult
}
type CMsgGCMsgSetOptions struct {
Options []CMsgGCMsgSetOptions_Option `protobuf:"varint,1,rep,name=options,enum=CMsgGCMsgSetOptions_Option" json:"options,omitempty"`
ClientMsgRanges []*CMsgGCMsgSetOptions_MessageRange `protobuf:"bytes,2,rep,name=client_msg_ranges,json=clientMsgRanges" json:"client_msg_ranges,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgSetOptions) Reset() { *m = CMsgGCMsgSetOptions{} }
func (m *CMsgGCMsgSetOptions) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgSetOptions) ProtoMessage() {}
func (*CMsgGCMsgSetOptions) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{56}
}
func (m *CMsgGCMsgSetOptions) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgSetOptions.Unmarshal(m, b)
}
func (m *CMsgGCMsgSetOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgSetOptions.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgSetOptions) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgSetOptions.Merge(m, src)
}
func (m *CMsgGCMsgSetOptions) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgSetOptions.Size(m)
}
func (m *CMsgGCMsgSetOptions) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgSetOptions.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgSetOptions proto.InternalMessageInfo
func (m *CMsgGCMsgSetOptions) GetOptions() []CMsgGCMsgSetOptions_Option {
if m != nil {
return m.Options
}
return nil
}
func (m *CMsgGCMsgSetOptions) GetClientMsgRanges() []*CMsgGCMsgSetOptions_MessageRange {
if m != nil {
return m.ClientMsgRanges
}
return nil
}
type CMsgGCMsgSetOptions_MessageRange struct {
Low *uint32 `protobuf:"varint,1,req,name=low" json:"low,omitempty"`
High *uint32 `protobuf:"varint,2,req,name=high" json:"high,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCMsgSetOptions_MessageRange) Reset() { *m = CMsgGCMsgSetOptions_MessageRange{} }
func (m *CMsgGCMsgSetOptions_MessageRange) String() string { return proto.CompactTextString(m) }
func (*CMsgGCMsgSetOptions_MessageRange) ProtoMessage() {}
func (*CMsgGCMsgSetOptions_MessageRange) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{56, 0}
}
func (m *CMsgGCMsgSetOptions_MessageRange) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCMsgSetOptions_MessageRange.Unmarshal(m, b)
}
func (m *CMsgGCMsgSetOptions_MessageRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCMsgSetOptions_MessageRange.Marshal(b, m, deterministic)
}
func (m *CMsgGCMsgSetOptions_MessageRange) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCMsgSetOptions_MessageRange.Merge(m, src)
}
func (m *CMsgGCMsgSetOptions_MessageRange) XXX_Size() int {
return xxx_messageInfo_CMsgGCMsgSetOptions_MessageRange.Size(m)
}
func (m *CMsgGCMsgSetOptions_MessageRange) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCMsgSetOptions_MessageRange.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCMsgSetOptions_MessageRange proto.InternalMessageInfo
func (m *CMsgGCMsgSetOptions_MessageRange) GetLow() uint32 {
if m != nil && m.Low != nil {
return *m.Low
}
return 0
}
func (m *CMsgGCMsgSetOptions_MessageRange) GetHigh() uint32 {
if m != nil && m.High != nil {
return *m.High
}
return 0
}
type CMsgGCHUpdateSession struct {
SteamId *uint64 `protobuf:"fixed64,1,opt,name=steam_id,json=steamId" json:"steam_id,omitempty"`
AppId *uint32 `protobuf:"varint,2,opt,name=app_id,json=appId" json:"app_id,omitempty"`
Online *bool `protobuf:"varint,3,opt,name=online" json:"online,omitempty"`
ServerSteamId *uint64 `protobuf:"fixed64,4,opt,name=server_steam_id,json=serverSteamId" json:"server_steam_id,omitempty"`
ServerAddr *uint32 `protobuf:"varint,5,opt,name=server_addr,json=serverAddr" json:"server_addr,omitempty"`
ServerPort *uint32 `protobuf:"varint,6,opt,name=server_port,json=serverPort" json:"server_port,omitempty"`
OsType *uint32 `protobuf:"varint,7,opt,name=os_type,json=osType" json:"os_type,omitempty"`
ClientAddr *uint32 `protobuf:"varint,8,opt,name=client_addr,json=clientAddr" json:"client_addr,omitempty"`
ExtraFields []*CMsgGCHUpdateSession_ExtraField `protobuf:"bytes,9,rep,name=extra_fields,json=extraFields" json:"extra_fields,omitempty"`
OwnerId *uint64 `protobuf:"fixed64,10,opt,name=owner_id,json=ownerId" json:"owner_id,omitempty"`
CmSessionSysid *uint32 `protobuf:"varint,11,opt,name=cm_session_sysid,json=cmSessionSysid" json:"cm_session_sysid,omitempty"`
CmSessionIdentifier *uint32 `protobuf:"varint,12,opt,name=cm_session_identifier,json=cmSessionIdentifier" json:"cm_session_identifier,omitempty"`
DepotIds []uint32 `protobuf:"varint,13,rep,name=depot_ids,json=depotIds" json:"depot_ids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCHUpdateSession) Reset() { *m = CMsgGCHUpdateSession{} }
func (m *CMsgGCHUpdateSession) String() string { return proto.CompactTextString(m) }
func (*CMsgGCHUpdateSession) ProtoMessage() {}
func (*CMsgGCHUpdateSession) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{57}
}
func (m *CMsgGCHUpdateSession) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCHUpdateSession.Unmarshal(m, b)
}
func (m *CMsgGCHUpdateSession) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCHUpdateSession.Marshal(b, m, deterministic)
}
func (m *CMsgGCHUpdateSession) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCHUpdateSession.Merge(m, src)
}
func (m *CMsgGCHUpdateSession) XXX_Size() int {
return xxx_messageInfo_CMsgGCHUpdateSession.Size(m)
}
func (m *CMsgGCHUpdateSession) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCHUpdateSession.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCHUpdateSession proto.InternalMessageInfo
func (m *CMsgGCHUpdateSession) GetSteamId() uint64 {
if m != nil && m.SteamId != nil {
return *m.SteamId
}
return 0
}
func (m *CMsgGCHUpdateSession) GetAppId() uint32 {
if m != nil && m.AppId != nil {
return *m.AppId
}
return 0
}
func (m *CMsgGCHUpdateSession) GetOnline() bool {
if m != nil && m.Online != nil {
return *m.Online
}
return false
}
func (m *CMsgGCHUpdateSession) GetServerSteamId() uint64 {
if m != nil && m.ServerSteamId != nil {
return *m.ServerSteamId
}
return 0
}
func (m *CMsgGCHUpdateSession) GetServerAddr() uint32 {
if m != nil && m.ServerAddr != nil {
return *m.ServerAddr
}
return 0
}
func (m *CMsgGCHUpdateSession) GetServerPort() uint32 {
if m != nil && m.ServerPort != nil {
return *m.ServerPort
}
return 0
}
func (m *CMsgGCHUpdateSession) GetOsType() uint32 {
if m != nil && m.OsType != nil {
return *m.OsType
}
return 0
}
func (m *CMsgGCHUpdateSession) GetClientAddr() uint32 {
if m != nil && m.ClientAddr != nil {
return *m.ClientAddr
}
return 0
}
func (m *CMsgGCHUpdateSession) GetExtraFields() []*CMsgGCHUpdateSession_ExtraField {
if m != nil {
return m.ExtraFields
}
return nil
}
func (m *CMsgGCHUpdateSession) GetOwnerId() uint64 {
if m != nil && m.OwnerId != nil {
return *m.OwnerId
}
return 0
}
func (m *CMsgGCHUpdateSession) GetCmSessionSysid() uint32 {
if m != nil && m.CmSessionSysid != nil {
return *m.CmSessionSysid
}
return 0
}
func (m *CMsgGCHUpdateSession) GetCmSessionIdentifier() uint32 {
if m != nil && m.CmSessionIdentifier != nil {
return *m.CmSessionIdentifier
}
return 0
}
func (m *CMsgGCHUpdateSession) GetDepotIds() []uint32 {
if m != nil {
return m.DepotIds
}
return nil
}
type CMsgGCHUpdateSession_ExtraField struct {
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgGCHUpdateSession_ExtraField) Reset() { *m = CMsgGCHUpdateSession_ExtraField{} }
func (m *CMsgGCHUpdateSession_ExtraField) String() string { return proto.CompactTextString(m) }
func (*CMsgGCHUpdateSession_ExtraField) ProtoMessage() {}
func (*CMsgGCHUpdateSession_ExtraField) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{57, 0}
}
func (m *CMsgGCHUpdateSession_ExtraField) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgGCHUpdateSession_ExtraField.Unmarshal(m, b)
}
func (m *CMsgGCHUpdateSession_ExtraField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgGCHUpdateSession_ExtraField.Marshal(b, m, deterministic)
}
func (m *CMsgGCHUpdateSession_ExtraField) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgGCHUpdateSession_ExtraField.Merge(m, src)
}
func (m *CMsgGCHUpdateSession_ExtraField) XXX_Size() int {
return xxx_messageInfo_CMsgGCHUpdateSession_ExtraField.Size(m)
}
func (m *CMsgGCHUpdateSession_ExtraField) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgGCHUpdateSession_ExtraField.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgGCHUpdateSession_ExtraField proto.InternalMessageInfo
func (m *CMsgGCHUpdateSession_ExtraField) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *CMsgGCHUpdateSession_ExtraField) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type CMsgNotificationOfSuspiciousActivity struct {
Steamid *uint64 `protobuf:"fixed64,1,opt,name=steamid" json:"steamid,omitempty"`
Appid *uint32 `protobuf:"varint,2,opt,name=appid" json:"appid,omitempty"`
MultipleInstances *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances `protobuf:"bytes,3,opt,name=multiple_instances,json=multipleInstances" json:"multiple_instances,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgNotificationOfSuspiciousActivity) Reset() { *m = CMsgNotificationOfSuspiciousActivity{} }
func (m *CMsgNotificationOfSuspiciousActivity) String() string { return proto.CompactTextString(m) }
func (*CMsgNotificationOfSuspiciousActivity) ProtoMessage() {}
func (*CMsgNotificationOfSuspiciousActivity) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{58}
}
func (m *CMsgNotificationOfSuspiciousActivity) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgNotificationOfSuspiciousActivity.Unmarshal(m, b)
}
func (m *CMsgNotificationOfSuspiciousActivity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgNotificationOfSuspiciousActivity.Marshal(b, m, deterministic)
}
func (m *CMsgNotificationOfSuspiciousActivity) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgNotificationOfSuspiciousActivity.Merge(m, src)
}
func (m *CMsgNotificationOfSuspiciousActivity) XXX_Size() int {
return xxx_messageInfo_CMsgNotificationOfSuspiciousActivity.Size(m)
}
func (m *CMsgNotificationOfSuspiciousActivity) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgNotificationOfSuspiciousActivity.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgNotificationOfSuspiciousActivity proto.InternalMessageInfo
func (m *CMsgNotificationOfSuspiciousActivity) GetSteamid() uint64 {
if m != nil && m.Steamid != nil {
return *m.Steamid
}
return 0
}
func (m *CMsgNotificationOfSuspiciousActivity) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CMsgNotificationOfSuspiciousActivity) GetMultipleInstances() *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances {
if m != nil {
return m.MultipleInstances
}
return nil
}
type CMsgNotificationOfSuspiciousActivity_MultipleGameInstances struct {
AppInstanceCount *uint32 `protobuf:"varint,1,opt,name=app_instance_count,json=appInstanceCount" json:"app_instance_count,omitempty"`
OtherSteamids []uint64 `protobuf:"fixed64,2,rep,name=other_steamids,json=otherSteamids" json:"other_steamids,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) Reset() {
*m = CMsgNotificationOfSuspiciousActivity_MultipleGameInstances{}
}
func (m *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) String() string {
return proto.CompactTextString(m)
}
func (*CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) ProtoMessage() {}
func (*CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{58, 0}
}
func (m *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgNotificationOfSuspiciousActivity_MultipleGameInstances.Unmarshal(m, b)
}
func (m *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgNotificationOfSuspiciousActivity_MultipleGameInstances.Marshal(b, m, deterministic)
}
func (m *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgNotificationOfSuspiciousActivity_MultipleGameInstances.Merge(m, src)
}
func (m *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) XXX_Size() int {
return xxx_messageInfo_CMsgNotificationOfSuspiciousActivity_MultipleGameInstances.Size(m)
}
func (m *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgNotificationOfSuspiciousActivity_MultipleGameInstances.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgNotificationOfSuspiciousActivity_MultipleGameInstances proto.InternalMessageInfo
func (m *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) GetAppInstanceCount() uint32 {
if m != nil && m.AppInstanceCount != nil {
return *m.AppInstanceCount
}
return 0
}
func (m *CMsgNotificationOfSuspiciousActivity_MultipleGameInstances) GetOtherSteamids() []uint64 {
if m != nil {
return m.OtherSteamids
}
return nil
}
type CMsgDPPartnerMicroTxns struct {
Appid *uint32 `protobuf:"varint,1,opt,name=appid" json:"appid,omitempty"`
GcName *string `protobuf:"bytes,2,opt,name=gc_name,json=gcName" json:"gc_name,omitempty"`
Partner *CMsgDPPartnerMicroTxns_PartnerInfo `protobuf:"bytes,3,opt,name=partner" json:"partner,omitempty"`
Transactions []*CMsgDPPartnerMicroTxns_PartnerMicroTxn `protobuf:"bytes,4,rep,name=transactions" json:"transactions,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgDPPartnerMicroTxns) Reset() { *m = CMsgDPPartnerMicroTxns{} }
func (m *CMsgDPPartnerMicroTxns) String() string { return proto.CompactTextString(m) }
func (*CMsgDPPartnerMicroTxns) ProtoMessage() {}
func (*CMsgDPPartnerMicroTxns) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{59}
}
func (m *CMsgDPPartnerMicroTxns) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgDPPartnerMicroTxns.Unmarshal(m, b)
}
func (m *CMsgDPPartnerMicroTxns) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgDPPartnerMicroTxns.Marshal(b, m, deterministic)
}
func (m *CMsgDPPartnerMicroTxns) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgDPPartnerMicroTxns.Merge(m, src)
}
func (m *CMsgDPPartnerMicroTxns) XXX_Size() int {
return xxx_messageInfo_CMsgDPPartnerMicroTxns.Size(m)
}
func (m *CMsgDPPartnerMicroTxns) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgDPPartnerMicroTxns.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgDPPartnerMicroTxns proto.InternalMessageInfo
func (m *CMsgDPPartnerMicroTxns) GetAppid() uint32 {
if m != nil && m.Appid != nil {
return *m.Appid
}
return 0
}
func (m *CMsgDPPartnerMicroTxns) GetGcName() string {
if m != nil && m.GcName != nil {
return *m.GcName
}
return ""
}
func (m *CMsgDPPartnerMicroTxns) GetPartner() *CMsgDPPartnerMicroTxns_PartnerInfo {
if m != nil {
return m.Partner
}
return nil
}
func (m *CMsgDPPartnerMicroTxns) GetTransactions() []*CMsgDPPartnerMicroTxns_PartnerMicroTxn {
if m != nil {
return m.Transactions
}
return nil
}
type CMsgDPPartnerMicroTxns_PartnerMicroTxn struct {
InitTime *uint32 `protobuf:"varint,1,opt,name=init_time,json=initTime" json:"init_time,omitempty"`
LastUpdateTime *uint32 `protobuf:"varint,2,opt,name=last_update_time,json=lastUpdateTime" json:"last_update_time,omitempty"`
TxnId *uint64 `protobuf:"varint,3,opt,name=txn_id,json=txnId" json:"txn_id,omitempty"`
AccountId *uint32 `protobuf:"varint,4,opt,name=account_id,json=accountId" json:"account_id,omitempty"`
LineItem *uint32 `protobuf:"varint,5,opt,name=line_item,json=lineItem" json:"line_item,omitempty"`
ItemId *uint64 `protobuf:"varint,6,opt,name=item_id,json=itemId" json:"item_id,omitempty"`
DefIndex *uint32 `protobuf:"varint,7,opt,name=def_index,json=defIndex" json:"def_index,omitempty"`
Price *uint64 `protobuf:"varint,8,opt,name=price" json:"price,omitempty"`
Tax *uint64 `protobuf:"varint,9,opt,name=tax" json:"tax,omitempty"`
PriceUsd *uint64 `protobuf:"varint,10,opt,name=price_usd,json=priceUsd" json:"price_usd,omitempty"`
TaxUsd *uint64 `protobuf:"varint,11,opt,name=tax_usd,json=taxUsd" json:"tax_usd,omitempty"`
PurchaseType *uint32 `protobuf:"varint,12,opt,name=purchase_type,json=purchaseType" json:"purchase_type,omitempty"`
SteamTxnType *uint32 `protobuf:"varint,13,opt,name=steam_txn_type,json=steamTxnType" json:"steam_txn_type,omitempty"`
CountryCode *string `protobuf:"bytes,14,opt,name=country_code,json=countryCode" json:"country_code,omitempty"`
RegionCode *string `protobuf:"bytes,15,opt,name=region_code,json=regionCode" json:"region_code,omitempty"`
Quantity *int32 `protobuf:"varint,16,opt,name=quantity" json:"quantity,omitempty"`
RefTransId *uint64 `protobuf:"varint,17,opt,name=ref_trans_id,json=refTransId" json:"ref_trans_id,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) Reset() {
*m = CMsgDPPartnerMicroTxns_PartnerMicroTxn{}
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) String() string { return proto.CompactTextString(m) }
func (*CMsgDPPartnerMicroTxns_PartnerMicroTxn) ProtoMessage() {}
func (*CMsgDPPartnerMicroTxns_PartnerMicroTxn) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{59, 0}
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerMicroTxn.Unmarshal(m, b)
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerMicroTxn.Marshal(b, m, deterministic)
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerMicroTxn.Merge(m, src)
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) XXX_Size() int {
return xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerMicroTxn.Size(m)
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerMicroTxn.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerMicroTxn proto.InternalMessageInfo
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetInitTime() uint32 {
if m != nil && m.InitTime != nil {
return *m.InitTime
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetLastUpdateTime() uint32 {
if m != nil && m.LastUpdateTime != nil {
return *m.LastUpdateTime
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetTxnId() uint64 {
if m != nil && m.TxnId != nil {
return *m.TxnId
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetAccountId() uint32 {
if m != nil && m.AccountId != nil {
return *m.AccountId
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetLineItem() uint32 {
if m != nil && m.LineItem != nil {
return *m.LineItem
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetItemId() uint64 {
if m != nil && m.ItemId != nil {
return *m.ItemId
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetDefIndex() uint32 {
if m != nil && m.DefIndex != nil {
return *m.DefIndex
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetPrice() uint64 {
if m != nil && m.Price != nil {
return *m.Price
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetTax() uint64 {
if m != nil && m.Tax != nil {
return *m.Tax
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetPriceUsd() uint64 {
if m != nil && m.PriceUsd != nil {
return *m.PriceUsd
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetTaxUsd() uint64 {
if m != nil && m.TaxUsd != nil {
return *m.TaxUsd
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetPurchaseType() uint32 {
if m != nil && m.PurchaseType != nil {
return *m.PurchaseType
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetSteamTxnType() uint32 {
if m != nil && m.SteamTxnType != nil {
return *m.SteamTxnType
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetCountryCode() string {
if m != nil && m.CountryCode != nil {
return *m.CountryCode
}
return ""
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetRegionCode() string {
if m != nil && m.RegionCode != nil {
return *m.RegionCode
}
return ""
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetQuantity() int32 {
if m != nil && m.Quantity != nil {
return *m.Quantity
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerMicroTxn) GetRefTransId() uint64 {
if m != nil && m.RefTransId != nil {
return *m.RefTransId
}
return 0
}
type CMsgDPPartnerMicroTxns_PartnerInfo struct {
PartnerId *uint32 `protobuf:"varint,1,opt,name=partner_id,json=partnerId" json:"partner_id,omitempty"`
PartnerName *string `protobuf:"bytes,2,opt,name=partner_name,json=partnerName" json:"partner_name,omitempty"`
CurrencyCode *string `protobuf:"bytes,3,opt,name=currency_code,json=currencyCode" json:"currency_code,omitempty"`
CurrencyName *string `protobuf:"bytes,4,opt,name=currency_name,json=currencyName" json:"currency_name,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) Reset() { *m = CMsgDPPartnerMicroTxns_PartnerInfo{} }
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) String() string { return proto.CompactTextString(m) }
func (*CMsgDPPartnerMicroTxns_PartnerInfo) ProtoMessage() {}
func (*CMsgDPPartnerMicroTxns_PartnerInfo) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{59, 1}
}
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerInfo.Unmarshal(m, b)
}
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerInfo.Marshal(b, m, deterministic)
}
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerInfo.Merge(m, src)
}
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) XXX_Size() int {
return xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerInfo.Size(m)
}
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerInfo.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgDPPartnerMicroTxns_PartnerInfo proto.InternalMessageInfo
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) GetPartnerId() uint32 {
if m != nil && m.PartnerId != nil {
return *m.PartnerId
}
return 0
}
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) GetPartnerName() string {
if m != nil && m.PartnerName != nil {
return *m.PartnerName
}
return ""
}
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) GetCurrencyCode() string {
if m != nil && m.CurrencyCode != nil {
return *m.CurrencyCode
}
return ""
}
func (m *CMsgDPPartnerMicroTxns_PartnerInfo) GetCurrencyName() string {
if m != nil && m.CurrencyName != nil {
return *m.CurrencyName
}
return ""
}
type CMsgDPPartnerMicroTxnsResponse struct {
Eresult *uint32 `protobuf:"varint,1,opt,name=eresult,def=2" json:"eresult,omitempty"`
Eerrorcode *CMsgDPPartnerMicroTxnsResponse_EErrorCode `protobuf:"varint,2,opt,name=eerrorcode,enum=CMsgDPPartnerMicroTxnsResponse_EErrorCode,def=0" json:"eerrorcode,omitempty"`
XXX_NoUnkeyedLiteral struct{} `json:"-"`
XXX_unrecognized []byte `json:"-"`
XXX_sizecache int32 `json:"-"`
}
func (m *CMsgDPPartnerMicroTxnsResponse) Reset() { *m = CMsgDPPartnerMicroTxnsResponse{} }
func (m *CMsgDPPartnerMicroTxnsResponse) String() string { return proto.CompactTextString(m) }
func (*CMsgDPPartnerMicroTxnsResponse) ProtoMessage() {}
func (*CMsgDPPartnerMicroTxnsResponse) Descriptor() ([]byte, []int) {
return fileDescriptor_662a1850681ae3f8, []int{60}
}
func (m *CMsgDPPartnerMicroTxnsResponse) XXX_Unmarshal(b []byte) error {
return xxx_messageInfo_CMsgDPPartnerMicroTxnsResponse.Unmarshal(m, b)
}
func (m *CMsgDPPartnerMicroTxnsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
return xxx_messageInfo_CMsgDPPartnerMicroTxnsResponse.Marshal(b, m, deterministic)
}
func (m *CMsgDPPartnerMicroTxnsResponse) XXX_Merge(src proto.Message) {
xxx_messageInfo_CMsgDPPartnerMicroTxnsResponse.Merge(m, src)
}
func (m *CMsgDPPartnerMicroTxnsResponse) XXX_Size() int {
return xxx_messageInfo_CMsgDPPartnerMicroTxnsResponse.Size(m)
}
func (m *CMsgDPPartnerMicroTxnsResponse) XXX_DiscardUnknown() {
xxx_messageInfo_CMsgDPPartnerMicroTxnsResponse.DiscardUnknown(m)
}
var xxx_messageInfo_CMsgDPPartnerMicroTxnsResponse proto.InternalMessageInfo
const Default_CMsgDPPartnerMicroTxnsResponse_Eresult uint32 = 2
const Default_CMsgDPPartnerMicroTxnsResponse_Eerrorcode CMsgDPPartnerMicroTxnsResponse_EErrorCode = CMsgDPPartnerMicroTxnsResponse_k_MsgValid
func (m *CMsgDPPartnerMicroTxnsResponse) GetEresult() uint32 {
if m != nil && m.Eresult != nil {
return *m.Eresult
}
return Default_CMsgDPPartnerMicroTxnsResponse_Eresult
}
func (m *CMsgDPPartnerMicroTxnsResponse) GetEerrorcode() CMsgDPPartnerMicroTxnsResponse_EErrorCode {
if m != nil && m.Eerrorcode != nil {
return *m.Eerrorcode
}
return Default_CMsgDPPartnerMicroTxnsResponse_Eerrorcode
}
var E_KeyField = &proto.ExtensionDesc{
ExtendedType: (*protobuf.FieldOptions)(nil),
ExtensionType: (*bool)(nil),
Field: 60000,
Name: "key_field",
Tag: "varint,60000,opt,name=key_field,def=0",
Filename: "steammessages.proto",
}
var E_MsgpoolSoftLimit = &proto.ExtensionDesc{
ExtendedType: (*protobuf.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 60000,
Name: "msgpool_soft_limit",
Tag: "varint,60000,opt,name=msgpool_soft_limit,def=32",
Filename: "steammessages.proto",
}
var E_MsgpoolHardLimit = &proto.ExtensionDesc{
ExtendedType: (*protobuf.MessageOptions)(nil),
ExtensionType: (*int32)(nil),
Field: 60001,
Name: "msgpool_hard_limit",
Tag: "varint,60001,opt,name=msgpool_hard_limit,def=384",
Filename: "steammessages.proto",
}
func init() {
proto.RegisterEnum("GCProtoBufMsgSrc", GCProtoBufMsgSrc_name, GCProtoBufMsgSrc_value)
proto.RegisterEnum("CMsgGCRoutingInfo_RoutingMethod", CMsgGCRoutingInfo_RoutingMethod_name, CMsgGCRoutingInfo_RoutingMethod_value)
proto.RegisterEnum("CMsgGCMsgSetOptions_Option", CMsgGCMsgSetOptions_Option_name, CMsgGCMsgSetOptions_Option_value)
proto.RegisterEnum("CMsgDPPartnerMicroTxnsResponse_EErrorCode", CMsgDPPartnerMicroTxnsResponse_EErrorCode_name, CMsgDPPartnerMicroTxnsResponse_EErrorCode_value)
proto.RegisterType((*CMsgProtoBufHeader)(nil), "CMsgProtoBufHeader")
proto.RegisterType((*CMsgWebAPIKey)(nil), "CMsgWebAPIKey")
proto.RegisterType((*CMsgHttpRequest)(nil), "CMsgHttpRequest")
proto.RegisterType((*CMsgHttpRequest_RequestHeader)(nil), "CMsgHttpRequest.RequestHeader")
proto.RegisterType((*CMsgHttpRequest_QueryParam)(nil), "CMsgHttpRequest.QueryParam")
proto.RegisterType((*CMsgWebAPIRequest)(nil), "CMsgWebAPIRequest")
proto.RegisterType((*CMsgHttpResponse)(nil), "CMsgHttpResponse")
proto.RegisterType((*CMsgHttpResponse_ResponseHeader)(nil), "CMsgHttpResponse.ResponseHeader")
proto.RegisterType((*CMsgAMFindAccounts)(nil), "CMsgAMFindAccounts")
proto.RegisterType((*CMsgAMFindAccountsResponse)(nil), "CMsgAMFindAccountsResponse")
proto.RegisterType((*CMsgNotifyWatchdog)(nil), "CMsgNotifyWatchdog")
proto.RegisterType((*CMsgAMGetLicenses)(nil), "CMsgAMGetLicenses")
proto.RegisterType((*CMsgPackageLicense)(nil), "CMsgPackageLicense")
proto.RegisterType((*CMsgAMGetLicensesResponse)(nil), "CMsgAMGetLicensesResponse")
proto.RegisterType((*CMsgAMGetUserGameStats)(nil), "CMsgAMGetUserGameStats")
proto.RegisterType((*CMsgAMGetUserGameStatsResponse)(nil), "CMsgAMGetUserGameStatsResponse")
proto.RegisterType((*CMsgAMGetUserGameStatsResponse_Stats)(nil), "CMsgAMGetUserGameStatsResponse.Stats")
proto.RegisterType((*CMsgAMGetUserGameStatsResponse_Achievement_Blocks)(nil), "CMsgAMGetUserGameStatsResponse.Achievement_Blocks")
proto.RegisterType((*CMsgGCGetCommandList)(nil), "CMsgGCGetCommandList")
proto.RegisterType((*CMsgGCGetCommandListResponse)(nil), "CMsgGCGetCommandListResponse")
proto.RegisterType((*CGCMsgMemCachedGet)(nil), "CGCMsgMemCachedGet")
proto.RegisterType((*CGCMsgMemCachedGetResponse)(nil), "CGCMsgMemCachedGetResponse")
proto.RegisterType((*CGCMsgMemCachedGetResponse_ValueTag)(nil), "CGCMsgMemCachedGetResponse.ValueTag")
proto.RegisterType((*CGCMsgMemCachedSet)(nil), "CGCMsgMemCachedSet")
proto.RegisterType((*CGCMsgMemCachedSet_KeyPair)(nil), "CGCMsgMemCachedSet.KeyPair")
proto.RegisterType((*CGCMsgMemCachedDelete)(nil), "CGCMsgMemCachedDelete")
proto.RegisterType((*CGCMsgMemCachedStats)(nil), "CGCMsgMemCachedStats")
proto.RegisterType((*CGCMsgMemCachedStatsResponse)(nil), "CGCMsgMemCachedStatsResponse")
proto.RegisterType((*CGCMsgSQLStats)(nil), "CGCMsgSQLStats")
proto.RegisterType((*CGCMsgSQLStatsResponse)(nil), "CGCMsgSQLStatsResponse")
proto.RegisterType((*CMsgAMAddFreeLicense)(nil), "CMsgAMAddFreeLicense")
proto.RegisterType((*CMsgAMAddFreeLicenseResponse)(nil), "CMsgAMAddFreeLicenseResponse")
proto.RegisterType((*CGCMsgGetIPLocation)(nil), "CGCMsgGetIPLocation")
proto.RegisterType((*CIPLocationInfo)(nil), "CIPLocationInfo")
proto.RegisterType((*CGCMsgGetIPLocationResponse)(nil), "CGCMsgGetIPLocationResponse")
proto.RegisterType((*CGCMsgSystemStatsSchema)(nil), "CGCMsgSystemStatsSchema")
proto.RegisterType((*CGCMsgGetSystemStats)(nil), "CGCMsgGetSystemStats")
proto.RegisterType((*CGCMsgGetSystemStatsResponse)(nil), "CGCMsgGetSystemStatsResponse")
proto.RegisterType((*CMsgAMSendEmail)(nil), "CMsgAMSendEmail")
proto.RegisterType((*CMsgAMSendEmail_ReplacementToken)(nil), "CMsgAMSendEmail.ReplacementToken")
proto.RegisterType((*CMsgAMSendEmail_PersonaNameReplacementToken)(nil), "CMsgAMSendEmail.PersonaNameReplacementToken")
proto.RegisterType((*CMsgAMSendEmailResponse)(nil), "CMsgAMSendEmailResponse")
proto.RegisterType((*CMsgGCGetEmailTemplate)(nil), "CMsgGCGetEmailTemplate")
proto.RegisterType((*CMsgGCGetEmailTemplateResponse)(nil), "CMsgGCGetEmailTemplateResponse")
proto.RegisterType((*CMsgAMGrantGuestPasses2)(nil), "CMsgAMGrantGuestPasses2")
proto.RegisterType((*CMsgAMGrantGuestPasses2Response)(nil), "CMsgAMGrantGuestPasses2Response")
proto.RegisterType((*CGCSystemMsg_GetAccountDetails)(nil), "CGCSystemMsg_GetAccountDetails")
proto.RegisterType((*CGCSystemMsg_GetAccountDetails_Response)(nil), "CGCSystemMsg_GetAccountDetails_Response")
proto.RegisterType((*CMsgGCGetPersonaNames)(nil), "CMsgGCGetPersonaNames")
proto.RegisterType((*CMsgGCGetPersonaNames_Response)(nil), "CMsgGCGetPersonaNames_Response")
proto.RegisterType((*CMsgGCGetPersonaNames_Response_PersonaName)(nil), "CMsgGCGetPersonaNames_Response.PersonaName")
proto.RegisterType((*CMsgGCCheckFriendship)(nil), "CMsgGCCheckFriendship")
proto.RegisterType((*CMsgGCCheckFriendship_Response)(nil), "CMsgGCCheckFriendship_Response")
proto.RegisterType((*CMsgGCMsgMasterSetDirectory)(nil), "CMsgGCMsgMasterSetDirectory")
proto.RegisterType((*CMsgGCMsgMasterSetDirectory_SubGC)(nil), "CMsgGCMsgMasterSetDirectory.SubGC")
proto.RegisterType((*CMsgGCMsgMasterSetDirectory_Response)(nil), "CMsgGCMsgMasterSetDirectory_Response")
proto.RegisterType((*CMsgGCMsgWebAPIJobRequestForwardResponse)(nil), "CMsgGCMsgWebAPIJobRequestForwardResponse")
proto.RegisterType((*CGCSystemMsg_GetPurchaseTrust_Request)(nil), "CGCSystemMsg_GetPurchaseTrust_Request")
proto.RegisterType((*CGCSystemMsg_GetPurchaseTrust_Response)(nil), "CGCSystemMsg_GetPurchaseTrust_Response")
proto.RegisterType((*CMsgGCHAccountVacStatusChange)(nil), "CMsgGCHAccountVacStatusChange")
proto.RegisterType((*CMsgGCGetPartnerAccountLink)(nil), "CMsgGCGetPartnerAccountLink")
proto.RegisterType((*CMsgGCGetPartnerAccountLink_Response)(nil), "CMsgGCGetPartnerAccountLink_Response")
proto.RegisterType((*CMsgGCRoutingInfo)(nil), "CMsgGCRoutingInfo")
proto.RegisterType((*CMsgGCMsgMasterSetWebAPIRouting)(nil), "CMsgGCMsgMasterSetWebAPIRouting")
proto.RegisterType((*CMsgGCMsgMasterSetWebAPIRouting_Entry)(nil), "CMsgGCMsgMasterSetWebAPIRouting.Entry")
proto.RegisterType((*CMsgGCMsgMasterSetClientMsgRouting)(nil), "CMsgGCMsgMasterSetClientMsgRouting")
proto.RegisterType((*CMsgGCMsgMasterSetClientMsgRouting_Entry)(nil), "CMsgGCMsgMasterSetClientMsgRouting.Entry")
proto.RegisterType((*CMsgGCMsgMasterSetWebAPIRouting_Response)(nil), "CMsgGCMsgMasterSetWebAPIRouting_Response")
proto.RegisterType((*CMsgGCMsgMasterSetClientMsgRouting_Response)(nil), "CMsgGCMsgMasterSetClientMsgRouting_Response")
proto.RegisterType((*CMsgGCMsgSetOptions)(nil), "CMsgGCMsgSetOptions")
proto.RegisterType((*CMsgGCMsgSetOptions_MessageRange)(nil), "CMsgGCMsgSetOptions.MessageRange")
proto.RegisterType((*CMsgGCHUpdateSession)(nil), "CMsgGCHUpdateSession")
proto.RegisterType((*CMsgGCHUpdateSession_ExtraField)(nil), "CMsgGCHUpdateSession.ExtraField")
proto.RegisterType((*CMsgNotificationOfSuspiciousActivity)(nil), "CMsgNotificationOfSuspiciousActivity")
proto.RegisterType((*CMsgNotificationOfSuspiciousActivity_MultipleGameInstances)(nil), "CMsgNotificationOfSuspiciousActivity.MultipleGameInstances")
proto.RegisterType((*CMsgDPPartnerMicroTxns)(nil), "CMsgDPPartnerMicroTxns")
proto.RegisterType((*CMsgDPPartnerMicroTxns_PartnerMicroTxn)(nil), "CMsgDPPartnerMicroTxns.PartnerMicroTxn")
proto.RegisterType((*CMsgDPPartnerMicroTxns_PartnerInfo)(nil), "CMsgDPPartnerMicroTxns.PartnerInfo")
proto.RegisterType((*CMsgDPPartnerMicroTxnsResponse)(nil), "CMsgDPPartnerMicroTxnsResponse")
proto.RegisterExtension(E_KeyField)
proto.RegisterExtension(E_MsgpoolSoftLimit)
proto.RegisterExtension(E_MsgpoolHardLimit)
}
func init() { proto.RegisterFile("steammessages.proto", fileDescriptor_662a1850681ae3f8) }
var fileDescriptor_662a1850681ae3f8 = []byte{
// 5599 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x5b, 0xcd, 0x6f, 0x1b, 0x49,
0x76, 0x1f, 0x52, 0x1f, 0xa4, 0x1e, 0x45, 0x8a, 0x6a, 0xf9, 0x83, 0xa6, 0xed, 0xb1, 0xdc, 0x33,
0xf6, 0x68, 0x66, 0x76, 0x39, 0x1e, 0x8f, 0xed, 0x99, 0xd5, 0x6e, 0x90, 0xa1, 0xa9, 0x0f, 0x73,
0x46, 0x92, 0x35, 0x4d, 0xda, 0x93, 0x04, 0x0b, 0x34, 0x8a, 0xdd, 0x45, 0xb2, 0x56, 0xcd, 0xee,
0x9e, 0xae, 0xa2, 0x24, 0x06, 0x08, 0x30, 0xc8, 0x61, 0xb1, 0xd8, 0xe4, 0x94, 0x1c, 0x36, 0x7b,
0xca, 0x6d, 0x8f, 0x41, 0x90, 0x43, 0x2e, 0x39, 0x04, 0x7b, 0xcb, 0x02, 0x01, 0x02, 0x04, 0x41,
0xae, 0x9b, 0xe4, 0x7f, 0xd8, 0x53, 0x82, 0x20, 0xa8, 0x57, 0x55, 0xcd, 0x16, 0x25, 0xcb, 0x9e,
0x9c, 0xc4, 0xfa, 0xbd, 0x57, 0xaf, 0x5f, 0x55, 0xbd, 0x7a, 0xef, 0xd5, 0xab, 0x12, 0xac, 0x71,
0x41, 0xc9, 0x68, 0x44, 0x39, 0x27, 0x03, 0xca, 0x1b, 0x71, 0x12, 0x89, 0xa8, 0xbe, 0x3e, 0x88,
0xa2, 0x41, 0x40, 0x3f, 0xc2, 0x56, 0x6f, 0xdc, 0xff, 0xc8, 0xa7, 0xdc, 0x4b, 0x58, 0x2c, 0xa2,
0x44, 0x71, 0xd8, 0x3f, 0x9d, 0x07, 0xab, 0xb5, 0xcf, 0x07, 0x87, 0xb2, 0xf5, 0x74, 0xdc, 0x7f,
0x46, 0x89, 0x4f, 0x13, 0xeb, 0x3e, 0xac, 0x78, 0x01, 0xa3, 0xa1, 0x70, 0x51, 0xac, 0xcb, 0xfc,
0x5a, 0x6e, 0x3d, 0xb7, 0xb1, 0xe8, 0x94, 0x15, 0xdc, 0x91, 0x68, 0xdb, 0xb7, 0x3e, 0x80, 0x55,
0xc3, 0x47, 0x39, 0x67, 0x51, 0x28, 0x39, 0xf3, 0xeb, 0xb9, 0x8d, 0x05, 0x47, 0x0b, 0xe8, 0x28,
0xbc, 0xed, 0x5b, 0x36, 0x94, 0x79, 0x34, 0x4e, 0x3c, 0xea, 0x92, 0x38, 0x96, 0x7c, 0x73, 0xeb,
0xb9, 0x8d, 0xb2, 0x53, 0x52, 0x60, 0x33, 0x8e, 0xdb, 0xbe, 0xf5, 0x19, 0x94, 0x7f, 0x12, 0xf5,
0x5c, 0xe6, 0xbb, 0x0a, 0xad, 0x81, 0xfc, 0xea, 0xe6, 0x95, 0x8f, 0x3f, 0x7b, 0xf4, 0xe8, 0xc9,
0xa7, 0x8f, 0x1e, 0x3d, 0xf8, 0xf4, 0x93, 0x4f, 0x1f, 0xfc, 0xe0, 0xf1, 0xe3, 0x8f, 0x9f, 0x7c,
0xfc, 0xd8, 0x29, 0xfd, 0x24, 0xea, 0xb5, 0xfd, 0x0e, 0x32, 0x66, 0x7a, 0x0a, 0x92, 0x0c, 0xa8,
0xa8, 0x95, 0x5e, 0xdb, 0xb3, 0x8b, 0x8c, 0x72, 0xac, 0xaa, 0x8b, 0x2b, 0x05, 0x84, 0x64, 0x44,
0x6b, 0xcb, 0xeb, 0xb9, 0x8d, 0x25, 0xa7, 0xac, 0xe0, 0x2f, 0xa2, 0xde, 0x01, 0x19, 0x51, 0xeb,
0x26, 0x14, 0x68, 0x42, 0xf9, 0x38, 0x10, 0xb5, 0xb2, 0x1c, 0xe1, 0x66, 0xee, 0xa1, 0x63, 0x10,
0xeb, 0x1d, 0x28, 0xd3, 0x24, 0x89, 0x12, 0x57, 0xaf, 0x40, 0xad, 0x82, 0x22, 0x96, 0x11, 0xdc,
0x57, 0x98, 0x55, 0x81, 0x3c, 0x8b, 0x6b, 0x2b, 0x38, 0xec, 0x3c, 0x8b, 0xad, 0x03, 0x80, 0x81,
0xe7, 0x8e, 0xf8, 0xc0, 0xe5, 0x89, 0x57, 0xfb, 0x27, 0x39, 0xc3, 0x95, 0x87, 0xab, 0x8d, 0xdd,
0x96, 0x59, 0x8d, 0x7d, 0x3e, 0xe8, 0x24, 0xde, 0xe6, 0xad, 0x59, 0xc4, 0x7d, 0x11, 0xf2, 0x98,
0x7a, 0xac, 0xcf, 0xa8, 0xef, 0x14, 0x07, 0x9e, 0x42, 0xad, 0x06, 0xac, 0x0d, 0x3c, 0xd7, 0x67,
0x89, 0xcb, 0x42, 0x9f, 0x9e, 0x9a, 0x39, 0xfc, 0x4d, 0x0e, 0xbf, 0x58, 0x1d, 0x78, 0x5b, 0x2c,
0x69, 0x4b, 0x8a, 0x9a, 0xb3, 0x4d, 0xf8, 0xf6, 0x57, 0xb7, 0xbf, 0xcd, 0xff, 0xec, 0x57, 0xb7,
0xbf, 0x2d, 0xda, 0x7f, 0x93, 0x83, 0xb2, 0x34, 0x84, 0xaf, 0x69, 0xaf, 0x79, 0xd8, 0xfe, 0x92,
0x4e, 0xac, 0x9b, 0xb0, 0xc8, 0x05, 0x11, 0x63, 0x8e, 0x4b, 0x5f, 0xde, 0x9c, 0x7b, 0xf8, 0xf8,
0xb1, 0xa3, 0x21, 0x6b, 0x1d, 0x80, 0x78, 0x5e, 0x34, 0x0e, 0x85, 0x59, 0xf1, 0xf2, 0x66, 0xee,
0x81, 0xb3, 0xa4, 0xc1, 0xb6, 0x6f, 0x7d, 0x04, 0x56, 0x3c, 0xee, 0x05, 0x8c, 0x0f, 0x69, 0xe2,
0x0e, 0x92, 0x68, 0x3c, 0x5d, 0x73, 0xc9, 0x59, 0x4d, 0x89, 0xbb, 0x92, 0xd6, 0xf6, 0xad, 0xab,
0xb0, 0x78, 0x44, 0x27, 0x92, 0x69, 0x1e, 0xf5, 0x5d, 0x38, 0xa2, 0x93, 0xb6, 0x6f, 0x5d, 0x83,
0x45, 0x3f, 0x1a, 0x11, 0x16, 0xd6, 0x16, 0x70, 0x4a, 0x75, 0xcb, 0xfe, 0xe7, 0x39, 0x58, 0x91,
0x0a, 0x3f, 0x13, 0x22, 0x76, 0xe8, 0x37, 0x63, 0xca, 0x85, 0x75, 0x0f, 0x2a, 0x89, 0xfa, 0xe9,
0x8e, 0xa8, 0x18, 0x46, 0xca, 0x6a, 0xcb, 0x4e, 0x59, 0xa3, 0xfb, 0x08, 0x5a, 0x75, 0x28, 0x0e,
0x23, 0x2e, 0x70, 0xa9, 0xf3, 0x28, 0x34, 0x6d, 0x5b, 0x55, 0x98, 0x1b, 0x27, 0x01, 0xea, 0xb9,
0xe4, 0xc8, 0x9f, 0xd6, 0x67, 0x50, 0x18, 0xe2, 0xae, 0xe0, 0xb5, 0xf9, 0xf5, 0xb9, 0x8d, 0xd2,
0xc3, 0xb7, 0x1b, 0x33, 0xdf, 0x6d, 0xe8, 0xbf, 0x6a, 0xf3, 0x38, 0x86, 0xdd, 0xda, 0x04, 0x90,
0x66, 0x15, 0x93, 0x84, 0x8c, 0x78, 0x6d, 0x01, 0x3b, 0xdf, 0x3c, 0xd7, 0xf9, 0xab, 0x31, 0x4d,
0x26, 0x87, 0x92, 0xc7, 0x59, 0x1a, 0x50, 0x81, 0xbf, 0xb8, 0xf5, 0x23, 0x28, 0xc5, 0x11, 0x4f,
0x3b, 0x2f, 0xbe, 0xbe, 0x33, 0x48, 0x7e, 0xdd, 0xdb, 0x82, 0xf9, 0x5e, 0xe4, 0x4f, 0x6a, 0x85,
0xf5, 0xdc, 0xc6, 0xb2, 0x83, 0xbf, 0xad, 0xf7, 0xa1, 0x4a, 0x7a, 0x3c, 0x0a, 0xc6, 0x82, 0xba,
0x82, 0x8d, 0x68, 0x34, 0x16, 0xb5, 0x22, 0x4e, 0xcf, 0x8a, 0xc1, 0xbb, 0x0a, 0xae, 0xff, 0x00,
0xca, 0x67, 0x86, 0x24, 0xe5, 0xe1, 0x6c, 0xe5, 0x70, 0x5a, 0xf0, 0xb7, 0x75, 0x05, 0x16, 0x8e,
0x49, 0x30, 0x36, 0x53, 0xa8, 0x1a, 0xf5, 0x27, 0x00, 0x53, 0x9d, 0x5e, 0xdf, 0x6f, 0x59, 0xf7,
0xb3, 0xff, 0x2a, 0x0f, 0xab, 0x53, 0xfb, 0x33, 0x0b, 0x7a, 0x1f, 0x56, 0x5e, 0x1c, 0xbc, 0xe8,
0x6c, 0x6f, 0x4d, 0xf7, 0xa6, 0x12, 0x55, 0x56, 0xb0, 0xd9, 0x9b, 0xf7, 0xa0, 0xc2, 0x42, 0x41,
0x93, 0x3e, 0xf1, 0xa8, 0x9b, 0x59, 0xd7, 0x72, 0x8a, 0x22, 0xdb, 0x1d, 0x28, 0x29, 0xbb, 0x50,
0x3c, 0x6a, 0x91, 0x41, 0x41, 0xc8, 0x50, 0x83, 0xc2, 0x31, 0x4d, 0xa4, 0xc3, 0xd2, 0x46, 0x68,
0x9a, 0xd6, 0x7b, 0x50, 0x20, 0x31, 0x73, 0x8f, 0xe8, 0x04, 0xed, 0xb0, 0xf4, 0xb0, 0xd2, 0x38,
0xb3, 0x5d, 0x9c, 0x45, 0x12, 0x33, 0xb9, 0x6d, 0x3e, 0x80, 0x82, 0xb6, 0xb6, 0xda, 0x22, 0x32,
0x56, 0x67, 0x17, 0xcd, 0x31, 0x0c, 0xd6, 0xbb, 0x50, 0x49, 0xa2, 0xb1, 0x60, 0xe1, 0xc0, 0xf8,
0xc4, 0x02, 0x7e, 0x75, 0x59, 0xa3, 0xe8, 0x14, 0xed, 0x7f, 0xcc, 0x41, 0x75, 0x2a, 0x82, 0xc7,
0x51, 0xc8, 0x71, 0x28, 0x6a, 0x2b, 0xba, 0x5e, 0xe4, 0x53, 0x6d, 0xe7, 0xa0, 0xa0, 0x56, 0xe4,
0x53, 0x6b, 0x73, 0x6a, 0xb6, 0x79, 0x34, 0x9e, 0xf5, 0xc6, 0xac, 0x90, 0x86, 0xf9, 0x31, 0x6b,
0xb8, 0xc6, 0x7c, 0xe6, 0xa6, 0xe6, 0x53, 0xdf, 0x84, 0xca, 0x59, 0xf6, 0x37, 0x37, 0x0a, 0xfb,
0x8f, 0x54, 0x90, 0x69, 0xee, 0xef, 0xb0, 0xd0, 0x6f, 0x2a, 0x17, 0xc1, 0x71, 0x08, 0x94, 0x24,
0xde, 0xd0, 0x15, 0x93, 0x78, 0x3a, 0x04, 0x84, 0xba, 0x93, 0x98, 0x4a, 0xa7, 0xaa, 0x19, 0xb8,
0x48, 0x58, 0x38, 0xd0, 0x42, 0x97, 0x15, 0xd8, 0x41, 0xcc, 0xfe, 0x14, 0xea, 0xe7, 0x65, 0xa7,
0xd3, 0x74, 0x03, 0x8a, 0x99, 0x08, 0x36, 0xb7, 0xb1, 0xe8, 0x14, 0xb8, 0x8a, 0x5d, 0xf6, 0xbf,
0xe6, 0x94, 0x56, 0x07, 0x91, 0x60, 0xfd, 0xc9, 0xd7, 0x44, 0x78, 0x43, 0x3f, 0x1a, 0x48, 0x7f,
0xa3, 0xfd, 0xa6, 0x52, 0x48, 0xb7, 0xac, 0xdb, 0x00, 0x24, 0xa0, 0x89, 0x50, 0xca, 0xa2, 0xc7,
0x73, 0x96, 0x10, 0x41, 0x5d, 0x3f, 0x84, 0x55, 0x45, 0xf6, 0x29, 0x17, 0x2c, 0x24, 0x42, 0xda,
0x90, 0x8a, 0x70, 0x55, 0x24, 0x6c, 0x4d, 0x71, 0xe9, 0x80, 0xbc, 0x84, 0x09, 0xe6, 0x91, 0x00,
0xed, 0xac, 0xe8, 0xa4, 0x6d, 0x39, 0xab, 0x72, 0x77, 0xa2, 0x95, 0x95, 0x1d, 0xfc, 0x2d, 0x67,
0x95, 0xc4, 0x31, 0xf3, 0xd1, 0xa2, 0xca, 0x8e, 0x6a, 0x20, 0x27, 0x3d, 0x15, 0x68, 0x33, 0x4b,
0x0e, 0xfe, 0xb6, 0xbf, 0xaf, 0x76, 0x51, 0x73, 0x7f, 0x97, 0x8a, 0x3d, 0xe6, 0xd1, 0x90, 0x53,
0x2e, 0xad, 0x1a, 0x07, 0x9d, 0x46, 0x71, 0xd3, 0xb4, 0xbf, 0xd1, 0xd1, 0x9f, 0x78, 0x47, 0x64,
0x40, 0x75, 0x07, 0x39, 0xd4, 0x58, 0x21, 0x26, 0xf0, 0x97, 0x9d, 0x25, 0x8d, 0xb4, 0x7d, 0xeb,
0x2e, 0x2c, 0x4b, 0xad, 0x5c, 0x2f, 0xa1, 0x44, 0x50, 0xed, 0xfd, 0x9d, 0x92, 0xc4, 0x5a, 0x0a,
0x92, 0xd3, 0x1e, 0x9d, 0x84, 0x34, 0x99, 0x86, 0xf9, 0x02, 0xb6, 0xdb, 0xbe, 0xdd, 0x83, 0x1b,
0xe7, 0x34, 0x4c, 0x97, 0xeb, 0xfb, 0x50, 0x08, 0x14, 0x86, 0xab, 0x55, 0x7a, 0xb8, 0xd6, 0x38,
0xaf, 0x9f, 0x63, 0x78, 0xe4, 0x5a, 0xe9, 0x88, 0xac, 0x74, 0xd0, 0x2d, 0xbb, 0x07, 0xd7, 0xd2,
0x6f, 0xbc, 0xe0, 0x34, 0xd9, 0x25, 0x23, 0xda, 0x11, 0x44, 0xf0, 0x19, 0x7b, 0xc8, 0x65, 0xec,
0xc1, 0xba, 0x0e, 0x85, 0x01, 0x19, 0x51, 0x13, 0xcf, 0x16, 0x9d, 0x45, 0xd9, 0x6c, 0xfb, 0x72,
0xf6, 0xe5, 0xbe, 0xe2, 0xb5, 0xb9, 0xf5, 0x39, 0x39, 0xfb, 0xd8, 0xb0, 0x7f, 0x3b, 0x07, 0x6f,
0x5f, 0xfc, 0x91, 0x57, 0x18, 0xdf, 0x9b, 0x7d, 0x2c, 0x93, 0x65, 0xcc, 0x9d, 0xcb, 0x32, 0x7e,
0x68, 0x34, 0x51, 0x81, 0xe8, 0x5e, 0xe3, 0x72, 0x05, 0x1a, 0xaa, 0xa5, 0xfa, 0x58, 0x04, 0x2c,
0xe2, 0x0d, 0x19, 0x3d, 0xa6, 0x23, 0x99, 0xb0, 0xf5, 0x82, 0xc8, 0x3b, 0x32, 0x51, 0xe9, 0xe1,
0xeb, 0x24, 0x35, 0x33, 0x3d, 0x9f, 0x62, 0x4f, 0x67, 0x35, 0x23, 0x4d, 0x41, 0xf5, 0xdf, 0x87,
0x05, 0x35, 0xcd, 0xd7, 0xa5, 0xc5, 0x11, 0x31, 0x35, 0x1f, 0xcc, 0x1b, 0xda, 0xbe, 0x34, 0x2d,
0x24, 0x4c, 0x9d, 0x44, 0xd9, 0x59, 0x92, 0xc8, 0x4b, 0x8c, 0x1e, 0x3f, 0xcf, 0x81, 0x75, 0xfe,
0x53, 0xd2, 0xbd, 0x67, 0x55, 0x4f, 0xa5, 0x96, 0x33, 0x68, 0xdb, 0xb7, 0xbe, 0x37, 0x33, 0x42,
0x36, 0x4d, 0x4e, 0x9c, 0x6a, 0x56, 0x5b, 0x26, 0xb9, 0xef, 0x40, 0x69, 0x1c, 0x4a, 0xf9, 0x18,
0x0d, 0x71, 0xb6, 0x0b, 0x0e, 0x28, 0x48, 0x06, 0x42, 0xbb, 0x0b, 0x57, 0xe4, 0xac, 0xec, 0xb6,
0x76, 0xa9, 0x68, 0x45, 0xa3, 0x11, 0x09, 0xfd, 0x3d, 0xc6, 0x85, 0x4c, 0x54, 0xb4, 0xb7, 0xce,
0xa5, 0xdb, 0xb1, 0xed, 0x4b, 0x25, 0x3d, 0xc5, 0xe5, 0xc6, 0x09, 0xed, 0xb3, 0x53, 0x13, 0x83,
0x34, 0x7a, 0x88, 0xa0, 0xdd, 0x84, 0x5b, 0x17, 0x49, 0x4d, 0x8d, 0xe6, 0x2e, 0x2c, 0x1b, 0x31,
0xda, 0xbb, 0xce, 0x6d, 0x2c, 0x39, 0x25, 0x8d, 0xc9, 0x28, 0x65, 0x6f, 0x80, 0xd5, 0xda, 0x95,
0x42, 0xf6, 0xe9, 0xa8, 0x45, 0xbc, 0x21, 0xf5, 0x77, 0xa9, 0x90, 0xee, 0xe0, 0x88, 0x4e, 0xb8,
0xee, 0x80, 0xbf, 0xed, 0xbf, 0xc8, 0x41, 0xfd, 0x3c, 0x6b, 0xfa, 0xad, 0x1f, 0xc1, 0x22, 0x2e,
0x04, 0xd7, 0xbb, 0xed, 0xdd, 0xc6, 0xab, 0x99, 0x1b, 0xb8, 0x42, 0x5d, 0x32, 0x70, 0x74, 0x9f,
0xfa, 0x13, 0x28, 0x1a, 0x4c, 0xee, 0x91, 0x7e, 0x34, 0x0e, 0xd5, 0x94, 0x14, 0x1d, 0xd5, 0x78,
0x45, 0xa8, 0xff, 0xe3, 0x73, 0xea, 0x77, 0xa8, 0xb0, 0x3e, 0xca, 0xa8, 0x8f, 0x99, 0xce, 0x39,
0x96, 0xc6, 0x97, 0x74, 0x72, 0x48, 0x58, 0xa2, 0xc6, 0x56, 0xff, 0x04, 0x0a, 0x1a, 0xf8, 0x0e,
0x69, 0xc6, 0x87, 0x70, 0x75, 0x46, 0xf0, 0x16, 0x0d, 0xa8, 0xa0, 0x17, 0xce, 0xde, 0x35, 0xb8,
0x32, 0xab, 0x05, 0x6e, 0xfd, 0x7f, 0x9f, 0x83, 0x5b, 0x17, 0x11, 0xd2, 0x79, 0x7d, 0x1f, 0xaa,
0xde, 0x38, 0x49, 0x5c, 0x2f, 0x0a, 0x43, 0xea, 0x49, 0x97, 0xaf, 0x92, 0xe8, 0x79, 0x67, 0x45,
0xe2, 0xad, 0x29, 0x2c, 0x77, 0x8a, 0x37, 0xf2, 0x5d, 0x79, 0x62, 0xc9, 0x23, 0xc7, 0xa2, 0x37,
0xc2, 0xe5, 0xd4, 0x04, 0x4e, 0x95, 0x23, 0x50, 0x04, 0x39, 0x51, 0x37, 0x61, 0x49, 0x12, 0xfa,
0xc1, 0x98, 0x0f, 0x31, 0x7a, 0xcc, 0x3b, 0x45, 0x6f, 0xe4, 0xef, 0xc8, 0xb6, 0x74, 0x39, 0x32,
0xe5, 0x1c, 0x32, 0xc1, 0x31, 0x82, 0xcc, 0x3b, 0x85, 0x01, 0x15, 0xcf, 0x98, 0xe0, 0x72, 0xeb,
0x49, 0xd2, 0x88, 0x71, 0x4e, 0x39, 0x46, 0x92, 0x79, 0x4c, 0x38, 0xf7, 0x11, 0x90, 0xdb, 0xc1,
0xc7, 0xa9, 0x50, 0x9d, 0x0b, 0x48, 0x07, 0x05, 0x61, 0xff, 0x77, 0xa0, 0xac, 0x19, 0xb4, 0x88,
0x22, 0xb2, 0x2c, 0x2b, 0x50, 0x4b, 0xb9, 0x0d, 0xd0, 0x9b, 0x08, 0xca, 0xdd, 0x84, 0x12, 0xbf,
0xb6, 0xa4, 0x3e, 0x82, 0x88, 0x43, 0x89, 0x2f, 0x65, 0x28, 0xf2, 0x49, 0xc2, 0x84, 0xa0, 0x21,
0x9e, 0xef, 0xe6, 0x9d, 0x65, 0x04, 0xbf, 0x56, 0x98, 0xdc, 0x48, 0x01, 0x1b, 0x31, 0xe1, 0x8e,
0xc8, 0x29, 0x12, 0xf0, 0x2c, 0x37, 0xef, 0x94, 0x11, 0xdd, 0xd7, 0xa0, 0xfc, 0x14, 0x4e, 0x32,
0x13, 0x74, 0xc4, 0xf1, 0xc8, 0x36, 0xef, 0x2c, 0x49, 0xa4, 0x2d, 0x01, 0xeb, 0x16, 0x2c, 0xd1,
0x63, 0xa6, 0x27, 0xbf, 0xac, 0xa8, 0x29, 0x20, 0xad, 0x43, 0x89, 0xae, 0x20, 0x45, 0x35, 0xec,
0x4f, 0xa1, 0xa2, 0xd6, 0xb5, 0xf3, 0xd5, 0x9e, 0x72, 0x64, 0xf7, 0xa0, 0xc2, 0xbd, 0x21, 0x1d,
0x11, 0xd7, 0x23, 0x82, 0x04, 0xd1, 0xc0, 0x78, 0x1e, 0x85, 0xb6, 0x14, 0x68, 0xff, 0x66, 0x0e,
0xae, 0x9d, 0xed, 0x99, 0xda, 0x42, 0x0d, 0x0a, 0x62, 0x28, 0x67, 0x43, 0x9f, 0xa3, 0x1c, 0xd3,
0x94, 0x29, 0x83, 0xfe, 0x69, 0x0c, 0x25, 0x0d, 0xa6, 0x55, 0x4d, 0x68, 0x19, 0x5c, 0x2a, 0x62,
0x98, 0x89, 0x27, 0xd8, 0x31, 0xd5, 0x71, 0xb5, 0xac, 0xd1, 0x26, 0x82, 0xd6, 0xc7, 0x70, 0x25,
0x8a, 0x69, 0x82, 0x69, 0x06, 0x77, 0xf9, 0xb8, 0x37, 0x92, 0x73, 0x6a, 0x8e, 0x54, 0x6b, 0x53,
0x5a, 0xc7, 0x90, 0xac, 0xcf, 0xe1, 0x56, 0x9c, 0xd0, 0x98, 0x24, 0xd4, 0x77, 0xa5, 0x27, 0x46,
0x17, 0xc9, 0x5d, 0x7a, 0x4a, 0xbd, 0xb1, 0xec, 0xaa, 0x12, 0x91, 0xba, 0xe1, 0xe9, 0xa4, 0x2c,
0xdb, 0x9a, 0xc3, 0xda, 0x85, 0xf5, 0x30, 0x0a, 0xdd, 0x4b, 0xa5, 0xa8, 0xcc, 0xe5, 0x76, 0x18,
0x85, 0x87, 0xaf, 0x16, 0xf4, 0x3e, 0x54, 0x7d, 0x4a, 0x7c, 0x74, 0xca, 0x09, 0x15, 0x09, 0xa3,
0x5c, 0x67, 0xc4, 0x2b, 0x06, 0x77, 0x14, 0x6c, 0x7d, 0x0e, 0xb7, 0x33, 0x03, 0x95, 0x1e, 0xdc,
0x77, 0xa3, 0xb1, 0x70, 0x59, 0xe8, 0x7e, 0x33, 0xa6, 0x63, 0xaa, 0x8f, 0x36, 0x37, 0xa6, 0x4c,
0xd2, 0xa7, 0xfb, 0xcf, 0xc7, 0xa2, 0x1d, 0x7e, 0x25, 0x19, 0x64, 0xf2, 0x80, 0xa7, 0x73, 0x8e,
0x66, 0x5a, 0x76, 0x74, 0xcb, 0xfe, 0x65, 0x4e, 0xf9, 0xfd, 0xe6, 0x7e, 0xd3, 0xf7, 0x77, 0x12,
0x9a, 0xa6, 0x45, 0xaf, 0x4c, 0xa3, 0xe4, 0x96, 0x64, 0xb1, 0x8b, 0x27, 0x5a, 0x4f, 0xaf, 0x60,
0x91, 0xc5, 0x87, 0xd8, 0x96, 0x86, 0xa8, 0x73, 0xa7, 0x34, 0x19, 0x9a, 0x02, 0x32, 0x66, 0x71,
0x11, 0x25, 0xd4, 0xc5, 0xc4, 0x35, 0x99, 0xa8, 0x74, 0x7e, 0x1e, 0x1d, 0x59, 0x15, 0x29, 0x2d,
0x45, 0x90, 0x49, 0xbd, 0xfd, 0x67, 0x39, 0x15, 0x3d, 0x66, 0x75, 0x4b, 0xad, 0x2d, 0x93, 0x3e,
0xe4, 0xce, 0xa5, 0x0f, 0x8f, 0xe0, 0x5a, 0x3c, 0x4e, 0xbc, 0x21, 0xe1, 0xd4, 0x55, 0x90, 0xeb,
0x53, 0x41, 0x58, 0xa0, 0x4b, 0x36, 0x57, 0x0c, 0xd5, 0x41, 0xe2, 0x16, 0xd2, 0xd0, 0x80, 0x13,
0x12, 0x72, 0xad, 0xfd, 0xa2, 0x63, 0x9a, 0xf6, 0x7b, 0xb0, 0xa6, 0x8c, 0x7e, 0x97, 0x8a, 0xf6,
0xe1, 0x5e, 0xe4, 0xa9, 0xec, 0xb6, 0x0a, 0x73, 0x2c, 0x56, 0x9e, 0xb4, 0xe0, 0xc8, 0x9f, 0xf6,
0x5f, 0xe7, 0x60, 0xa5, 0x35, 0xe5, 0x68, 0x87, 0xfd, 0x48, 0x17, 0x43, 0x72, 0x69, 0x31, 0xa4,
0x0e, 0xc5, 0x80, 0x08, 0x26, 0xc6, 0xbe, 0x72, 0xd9, 0x79, 0x27, 0x6d, 0xcb, 0x29, 0x0c, 0xa2,
0x70, 0xa0, 0x88, 0x73, 0x48, 0x9c, 0x02, 0x52, 0x41, 0x3d, 0x79, 0x7a, 0xde, 0x4c, 0xd3, 0x64,
0x6e, 0x54, 0x97, 0x0e, 0x54, 0x43, 0xba, 0x7a, 0x8f, 0x89, 0x09, 0x9a, 0xe4, 0x92, 0x83, 0xbf,
0xed, 0x6d, 0xb8, 0x79, 0xc1, 0x50, 0xd2, 0x69, 0xbd, 0x0f, 0x0b, 0x2c, 0xec, 0x47, 0x26, 0x3a,
0x55, 0x1b, 0x33, 0xa3, 0x71, 0x14, 0xd9, 0x76, 0xe0, 0xba, 0x76, 0x03, 0x13, 0x2e, 0xe8, 0x08,
0x3d, 0x41, 0x07, 0x3d, 0x85, 0x55, 0x87, 0xa5, 0x81, 0xe7, 0x9e, 0x49, 0x1c, 0x0a, 0x03, 0x4f,
0x95, 0xbd, 0x6e, 0xc2, 0x92, 0xf6, 0x32, 0x47, 0xc7, 0x3a, 0x5e, 0x15, 0x15, 0xf0, 0xe5, 0xf1,
0x34, 0x0a, 0xed, 0x52, 0x91, 0x11, 0x6b, 0xff, 0x2e, 0x8d, 0x42, 0x67, 0x09, 0xa9, 0xd2, 0x97,
0x7d, 0x11, 0x53, 0x53, 0x22, 0xf8, 0xf4, 0x83, 0x98, 0xb0, 0xf1, 0x2f, 0x8f, 0x65, 0x20, 0x50,
0x1e, 0x46, 0x9e, 0xb9, 0xb9, 0xb6, 0x58, 0x50, 0xd0, 0x17, 0x51, 0x0f, 0x03, 0xc1, 0x84, 0xd1,
0xc0, 0x97, 0xc7, 0x56, 0x64, 0x51, 0xce, 0x65, 0xd9, 0x80, 0x86, 0x69, 0xcc, 0x69, 0x62, 0xea,
0x82, 0x5c, 0xbb, 0x91, 0x65, 0x09, 0xea, 0x9a, 0x20, 0xb7, 0x1e, 0xc0, 0x15, 0xcc, 0x82, 0x39,
0x4d, 0x8e, 0xb3, 0xbc, 0xca, 0x59, 0x58, 0x92, 0xd6, 0x41, 0x52, 0xda, 0xa3, 0x0e, 0x45, 0x1e,
0x79, 0x32, 0xe4, 0x1a, 0xcf, 0x90, 0xb6, 0x71, 0x2b, 0xe9, 0xdf, 0xae, 0x88, 0x5c, 0x99, 0xc9,
0x11, 0x5f, 0xfb, 0x81, 0xaa, 0xa1, 0x74, 0xa3, 0x17, 0x88, 0x4b, 0x5f, 0x93, 0x72, 0x4b, 0x40,
0x9e, 0x2f, 0x95, 0x23, 0x58, 0x31, 0xf8, 0x9e, 0x82, 0xad, 0xf7, 0x60, 0x45, 0xc6, 0x2b, 0xda,
0x23, 0xde, 0x91, 0xf6, 0x2e, 0x80, 0x9c, 0x95, 0x14, 0x56, 0x2e, 0x45, 0x1e, 0x58, 0x95, 0x4b,
0x70, 0x55, 0x76, 0x5d, 0x52, 0x83, 0xd6, 0xe0, 0x1e, 0x26, 0xb3, 0x77, 0xa0, 0x14, 0x44, 0x83,
0xc8, 0xf8, 0xa9, 0x65, 0x35, 0xbf, 0x08, 0x29, 0x29, 0xb7, 0x41, 0xb5, 0xd4, 0xe4, 0x96, 0x95,
0xc7, 0x40, 0x44, 0xce, 0xac, 0xcc, 0x3e, 0x56, 0x94, 0x0f, 0xe8, 0xd0, 0xd0, 0xdf, 0x1e, 0xe9,
0x3d, 0xfa, 0x0a, 0xd7, 0xf4, 0x2e, 0x54, 0xa8, 0x64, 0xc1, 0x32, 0x63, 0xe6, 0xe8, 0xba, 0x8c,
0xe8, 0x3e, 0x1f, 0xe0, 0xe9, 0xf5, 0x2e, 0xa8, 0xb6, 0xdb, 0x8f, 0x92, 0x11, 0x11, 0xa6, 0x34,
0x8b, 0xd8, 0x0e, 0x42, 0xd6, 0x8f, 0x61, 0x2d, 0xa6, 0x09, 0x8f, 0x42, 0x82, 0x79, 0xa9, 0x2b,
0xa2, 0x23, 0x1a, 0x9a, 0xf3, 0xc3, 0xf7, 0x1a, 0x33, 0x1a, 0x35, 0x0e, 0x15, 0xaf, 0xcc, 0x57,
0x1d, 0x1a, 0x07, 0xc4, 0x43, 0x57, 0xdf, 0x95, 0x9d, 0x9c, 0xd5, 0x78, 0x4a, 0x44, 0x84, 0xe3,
0x0e, 0x50, 0xc5, 0xe1, 0x81, 0xa7, 0x97, 0xbf, 0xa8, 0x80, 0x5d, 0xcf, 0xfa, 0x01, 0x2c, 0xea,
0xaf, 0x15, 0xf0, 0x6b, 0x77, 0xcf, 0x7d, 0xed, 0xdc, 0x27, 0x74, 0x87, 0xba, 0x03, 0xd5, 0x59,
0x9a, 0x9c, 0x5f, 0xa4, 0x66, 0xeb, 0x49, 0x4b, 0x88, 0x98, 0x22, 0x91, 0x22, 0x67, 0x0b, 0x19,
0xaa, 0x87, 0x3a, 0xa4, 0xbc, 0x84, 0x9b, 0x97, 0x8c, 0xee, 0x92, 0xb5, 0x38, 0xfb, 0xe1, 0xfc,
0xcc, 0x87, 0xed, 0x27, 0x70, 0x7d, 0x66, 0x5c, 0xaf, 0x72, 0xeb, 0xe5, 0xac, 0x5b, 0xb7, 0x7f,
0x91, 0x53, 0xc7, 0x5d, 0x3c, 0x52, 0x60, 0xbf, 0x2e, 0x1d, 0xc5, 0x81, 0x74, 0x75, 0xaf, 0x38,
0xaa, 0xbc, 0x99, 0x51, 0xdc, 0x06, 0x50, 0x5c, 0x01, 0x09, 0x07, 0xea, 0x34, 0xea, 0x2c, 0x21,
0xb2, 0x47, 0xc2, 0xc1, 0x39, 0x9b, 0x99, 0x47, 0x86, 0xac, 0xcd, 0xd8, 0x7f, 0x9a, 0x53, 0x67,
0xe4, 0xf3, 0x9a, 0xbd, 0xd1, 0xc8, 0xe4, 0xc6, 0x13, 0xba, 0x83, 0x4b, 0x4f, 0x19, 0x17, 0x1c,
0x15, 0x2d, 0x3a, 0x15, 0x03, 0x6f, 0x23, 0x2a, 0xdd, 0x82, 0x41, 0x74, 0x55, 0x2f, 0x6d, 0xdb,
0xbf, 0xce, 0x99, 0x79, 0xdd, 0x4d, 0x48, 0x28, 0x76, 0xc7, 0x94, 0x8b, 0x43, 0x22, 0xb3, 0xd5,
0x87, 0x97, 0x9d, 0xd0, 0xcf, 0x16, 0x41, 0xf2, 0xb3, 0x45, 0x90, 0xfb, 0xb0, 0x12, 0xa3, 0x10,
0xe9, 0x6a, 0x06, 0x52, 0xb0, 0x9e, 0xa1, 0xb2, 0x82, 0xbb, 0x11, 0x7e, 0x4d, 0x3a, 0x25, 0x9f,
0x4c, 0x90, 0x8b, 0x9e, 0xc6, 0x4c, 0xe5, 0x22, 0x7a, 0xae, 0xaa, 0x92, 0xd2, 0x8d, 0xb6, 0x53,
0x5c, 0xe6, 0x24, 0x04, 0x33, 0x54, 0x74, 0x97, 0x0b, 0x8e, 0x6e, 0xd9, 0x43, 0xb8, 0xf3, 0x8a,
0x21, 0xbc, 0x59, 0xe4, 0xdf, 0x80, 0x8a, 0xd6, 0x16, 0x55, 0xd5, 0x79, 0xe6, 0xc2, 0x66, 0xee,
0x81, 0xd1, 0x77, 0x57, 0xe1, 0xf6, 0x8f, 0xe1, 0xed, 0xd6, 0x6e, 0x4b, 0x85, 0x93, 0x7d, 0x3e,
0x70, 0x77, 0xa9, 0xd0, 0x45, 0x35, 0x95, 0x0e, 0x5c, 0x52, 0x4d, 0x9a, 0x96, 0xa9, 0xf2, 0x99,
0x32, 0x95, 0xba, 0x65, 0xc8, 0xfd, 0xec, 0x57, 0xb7, 0xbf, 0x9d, 0xb7, 0x7f, 0x5b, 0x82, 0xf7,
0x2e, 0x17, 0xef, 0xa6, 0x03, 0x7a, 0x00, 0x16, 0x4d, 0xb3, 0x94, 0x38, 0xa1, 0x1e, 0x16, 0x9b,
0x52, 0x23, 0x59, 0xd5, 0xc4, 0xad, 0x94, 0x26, 0x2d, 0xd2, 0x5c, 0x4a, 0x64, 0x76, 0x58, 0x49,
0x63, 0xb8, 0xb9, 0xef, 0xc2, 0x72, 0xd6, 0x8b, 0x69, 0x63, 0x29, 0x65, 0x1c, 0x92, 0xf5, 0x01,
0xac, 0x32, 0xee, 0xc6, 0x49, 0xd4, 0x67, 0x01, 0x35, 0x49, 0x9d, 0xaa, 0xd2, 0xad, 0x30, 0x7e,
0xa8, 0x70, 0x9d, 0xdb, 0x35, 0x60, 0x8d, 0x71, 0x97, 0x85, 0xc7, 0x34, 0x14, 0x51, 0x32, 0x31,
0xdc, 0x0b, 0xc8, 0xbd, 0xca, 0x78, 0xdb, 0x50, 0x34, 0xbf, 0x0d, 0x65, 0xc6, 0xdd, 0x63, 0xe2,
0xb9, 0x3d, 0x12, 0x86, 0x54, 0xd5, 0x7b, 0x8b, 0x4e, 0x89, 0xf1, 0x97, 0xc4, 0x7b, 0x8a, 0x90,
0xe6, 0xf1, 0x26, 0x3d, 0x9a, 0xb8, 0x1e, 0xe9, 0xab, 0x4c, 0x16, 0x79, 0x5a, 0x12, 0x6b, 0x91,
0xbe, 0xd1, 0x91, 0x7b, 0xc3, 0x28, 0x0a, 0x5c, 0x3d, 0x3e, 0x8c, 0x5e, 0xa8, 0x63, 0x07, 0x71,
0x3d, 0xaf, 0xd2, 0x90, 0x19, 0x77, 0xf1, 0xec, 0x44, 0x7d, 0x0c, 0x5c, 0x45, 0x67, 0x89, 0xf1,
0x3d, 0x05, 0xc8, 0x98, 0xc5, 0xf0, 0xa4, 0xc0, 0xbd, 0x84, 0xf5, 0xa8, 0x8f, 0x31, 0xab, 0xe8,
0x2c, 0x33, 0x79, 0x44, 0xd0, 0x98, 0x5c, 0x73, 0x6d, 0xfa, 0x3a, 0x5e, 0x99, 0xa6, 0xf5, 0x31,
0x5c, 0x65, 0xdc, 0xed, 0x27, 0x94, 0xba, 0x22, 0x61, 0x64, 0xaa, 0x4d, 0x19, 0xc5, 0x58, 0x8c,
0xcb, 0x34, 0xb5, 0x2b, 0x49, 0x46, 0xa1, 0x87, 0x70, 0x35, 0xc3, 0x9f, 0xd9, 0x15, 0x15, 0x75,
0x48, 0xe9, 0x9b, 0x0e, 0x99, 0x8d, 0x71, 0x1f, 0x56, 0xe4, 0x20, 0xa2, 0x13, 0xf7, 0x98, 0x45,
0x01, 0x0d, 0x3d, 0x8a, 0xf7, 0x68, 0x45, 0xa7, 0xcc, 0xf8, 0x5e, 0x74, 0xf2, 0x52, 0x83, 0xd6,
0x27, 0x70, 0x8d, 0x71, 0xa3, 0x03, 0x06, 0x61, 0xea, 0xbb, 0x7e, 0x74, 0x12, 0xd6, 0xaa, 0xc8,
0xbe, 0xc6, 0xb8, 0x56, 0x63, 0x0f, 0x69, 0x5b, 0xd1, 0x49, 0xa8, 0x57, 0xd1, 0x8b, 0x46, 0xa3,
0x71, 0xc8, 0xc4, 0xc4, 0xac, 0xcd, 0xaa, 0x59, 0xc5, 0x96, 0xa1, 0xe8, 0x15, 0x52, 0xca, 0x88,
0x84, 0xf8, 0xd4, 0xf0, 0x5a, 0x46, 0x99, 0xae, 0x44, 0x35, 0xdf, 0x03, 0xb8, 0x92, 0x32, 0x65,
0xc7, 0xb9, 0xa6, 0xd2, 0x1b, 0xa1, 0x59, 0x33, 0xc3, 0xbc, 0x05, 0xe6, 0x06, 0x8d, 0xf9, 0xb5,
0x2b, 0xba, 0xc6, 0x6c, 0x00, 0xa9, 0x27, 0x1f, 0xf3, 0x98, 0x86, 0x78, 0xd3, 0x4a, 0x43, 0x5f,
0x55, 0xae, 0xae, 0x22, 0xdf, 0xea, 0x94, 0xb4, 0x1d, 0xfa, 0xf2, 0xb0, 0x83, 0x65, 0xe6, 0x71,
0x92, 0xd0, 0xd0, 0x9b, 0xd4, 0xae, 0x29, 0xaf, 0x68, 0xda, 0xea, 0xfe, 0x40, 0x7a, 0xbe, 0x80,
0x1e, 0xd3, 0xa0, 0x76, 0xdd, 0xdc, 0x1f, 0x50, 0x32, 0xda, 0x93, 0x88, 0xdc, 0x29, 0xfd, 0x84,
0xc9, 0x8f, 0xa8, 0xf5, 0xac, 0xa9, 0x94, 0x40, 0x61, 0x2d, 0xb3, 0x90, 0x66, 0xa6, 0xb1, 0x16,
0x2c, 0xb5, 0x42, 0x8d, 0x6e, 0xa8, 0x85, 0xd4, 0xc4, 0x96, 0xa6, 0xa1, 0x4e, 0x0f, 0xd1, 0x5e,
0xf0, 0x3b, 0x83, 0x31, 0x49, 0x7c, 0x97, 0x86, 0xa4, 0x17, 0x50, 0xbf, 0x76, 0xd3, 0xac, 0x4f,
0x27, 0xa5, 0x6d, 0x2b, 0x92, 0xd9, 0x91, 0xc3, 0x28, 0xa4, 0xee, 0x31, 0x4d, 0xf0, 0xda, 0xb3,
0x76, 0x2b, 0xdd, 0x91, 0x12, 0x7f, 0xa9, 0x61, 0x6b, 0x13, 0xea, 0x72, 0x6d, 0x4e, 0x22, 0xb7,
0x4f, 0x3c, 0x11, 0x25, 0x2e, 0x19, 0x8b, 0x61, 0xfa, 0x91, 0xdb, 0xd8, 0xe9, 0x1a, 0xe3, 0xdd,
0x93, 0x68, 0x07, 0xe9, 0xcd, 0xb1, 0x18, 0x9a, 0xef, 0x3c, 0x86, 0xeb, 0x99, 0x8e, 0xba, 0x8f,
0x1a, 0xd1, 0xdb, 0x38, 0xa2, 0x2b, 0xc2, 0x74, 0xd3, 0x5d, 0x70, 0x48, 0x4f, 0xe0, 0x7a, 0x56,
0x37, 0x2f, 0x33, 0x11, 0x77, 0xb0, 0xdb, 0xd5, 0x78, 0xaa, 0xa2, 0x37, 0x9d, 0x8a, 0x1b, 0x50,
0x54, 0xfd, 0x98, 0x5f, 0xbb, 0xab, 0x6a, 0x35, 0xd8, 0x6e, 0xa3, 0xe5, 0xa4, 0x23, 0x66, 0x3e,
0x0d, 0x05, 0xeb, 0x4f, 0x64, 0x82, 0x6a, 0x9b, 0x4d, 0x75, 0xa8, 0x18, 0x53, 0x8a, 0x8c, 0x33,
0x89, 0xd0, 0xbc, 0x62, 0xe2, 0x06, 0x2c, 0x3c, 0xa2, 0x7e, 0xed, 0x1d, 0x95, 0xfc, 0x26, 0xa2,
0xad, 0x09, 0x7b, 0x88, 0x4b, 0x1f, 0x93, 0x08, 0xb7, 0xc7, 0x12, 0x31, 0x74, 0x7d, 0x19, 0x34,
0xdf, 0x55, 0xab, 0x9b, 0x88, 0xa7, 0x12, 0xdb, 0x92, 0xb9, 0xc3, 0x06, 0x54, 0xc5, 0x69, 0x78,
0xf6, 0x5c, 0x7a, 0x0f, 0xad, 0xa8, 0x22, 0x4e, 0xc3, 0xcc, 0xa9, 0xf4, 0x8c, 0x87, 0xff, 0x04,
0xae, 0xa6, 0x11, 0x3f, 0x93, 0x25, 0xa9, 0xcc, 0x5d, 0xc5, 0x09, 0xae, 0x6f, 0x62, 0xd2, 0xb6,
0xfd, 0x3f, 0xd9, 0x3c, 0x21, 0xdb, 0x6b, 0x1a, 0x0d, 0xfe, 0x00, 0x56, 0xf9, 0xd8, 0xf3, 0x28,
0xf5, 0xa9, 0x4c, 0xae, 0xa3, 0xa3, 0x71, 0x6c, 0x4e, 0x63, 0x1f, 0x36, 0x2e, 0xef, 0x7b, 0x26,
0x17, 0xad, 0xa6, 0x52, 0xf6, 0x94, 0x10, 0x79, 0x2a, 0xee, 0x13, 0x16, 0xa4, 0x62, 0xdd, 0x54,
0xcd, 0x3c, 0xaa, 0x79, 0x45, 0x51, 0x15, 0x7b, 0x47, 0xd3, 0xea, 0x5f, 0x40, 0x29, 0x23, 0xf6,
0x92, 0xa0, 0x38, 0x1b, 0x71, 0xf2, 0xe7, 0x22, 0x8e, 0xed, 0x9a, 0x39, 0x6b, 0x0d, 0xa9, 0x77,
0xb4, 0x83, 0x3b, 0x8c, 0x0f, 0x59, 0x2c, 0xfb, 0xa6, 0xe7, 0x09, 0xda, 0x17, 0x5a, 0x74, 0xc9,
0x1c, 0x27, 0x68, 0x5f, 0x64, 0x8f, 0x1c, 0x09, 0x1b, 0x0c, 0x85, 0xbe, 0x4e, 0x30, 0xfd, 0x1c,
0x89, 0xd9, 0xd4, 0x4c, 0xef, 0xcc, 0x07, 0xdc, 0x6c, 0x95, 0x0a, 0x27, 0x86, 0x73, 0x5d, 0xc1,
0x35, 0x4d, 0x79, 0x4e, 0xc2, 0x62, 0xae, 0xdb, 0x4f, 0xbb, 0xe9, 0x24, 0x6c, 0x05, 0xf1, 0xa9,
0x34, 0xfb, 0xe7, 0x79, 0xb8, 0xa9, 0xbe, 0xb3, 0xcf, 0x07, 0xfb, 0x84, 0x0b, 0x79, 0x70, 0x13,
0x5b, 0x2c, 0xa1, 0x72, 0xcb, 0x4c, 0xa4, 0x45, 0x8d, 0x10, 0x9d, 0xbe, 0x51, 0xd0, 0x79, 0x69,
0x45, 0xe1, 0xe6, 0x7d, 0x82, 0xf5, 0x08, 0xe6, 0x7c, 0x96, 0xe8, 0x8b, 0x4b, 0xbb, 0x71, 0x89,
0xd0, 0x46, 0x67, 0xdc, 0xdb, 0x6d, 0x39, 0x92, 0xbd, 0xfe, 0xf3, 0x1c, 0x2c, 0x60, 0x53, 0x1e,
0x27, 0x66, 0x3f, 0x51, 0xf4, 0x8d, 0x70, 0x53, 0x2d, 0xce, 0x67, 0xaa, 0xc5, 0x55, 0x98, 0xeb,
0x45, 0xa7, 0xe6, 0xda, 0xbf, 0x17, 0x9d, 0x66, 0xeb, 0xf0, 0x01, 0x0b, 0x4d, 0x49, 0xc6, 0xd4,
0xe1, 0xf7, 0x58, 0x28, 0x53, 0x2e, 0x79, 0xc0, 0xee, 0xb1, 0x90, 0x24, 0x13, 0x5d, 0x62, 0x28,
0x0e, 0xbc, 0xa7, 0xd8, 0xb6, 0x5b, 0xf0, 0xee, 0x25, 0x6a, 0xbb, 0x6f, 0x94, 0xb7, 0xd9, 0xbb,
0xb0, 0x91, 0x0a, 0x51, 0x57, 0xcd, 0x5f, 0x44, 0x3d, 0x7d, 0x8d, 0xbc, 0x13, 0x25, 0x27, 0x24,
0xf1, 0x33, 0x82, 0x5e, 0x3d, 0x66, 0xbb, 0x09, 0xf7, 0x66, 0xf3, 0xae, 0x43, 0x5d, 0xec, 0xe9,
0x26, 0x63, 0x2e, 0x5c, 0x73, 0xe3, 0xfe, 0xea, 0xbb, 0xc2, 0x9f, 0xe6, 0xe1, 0xfe, 0xeb, 0x64,
0x68, 0x55, 0x7e, 0x08, 0xf5, 0x21, 0x91, 0x39, 0x14, 0x8b, 0x12, 0x37, 0x2d, 0x39, 0x0d, 0x19,
0x97, 0x43, 0xd7, 0x06, 0x76, 0x7d, 0x48, 0xf8, 0xa1, 0x64, 0x30, 0x32, 0x9e, 0x29, 0xb2, 0xf5,
0x39, 0xdc, 0x96, 0x9d, 0xc3, 0xc8, 0x4d, 0xa8, 0x47, 0x43, 0xe1, 0xca, 0x04, 0xf5, 0x24, 0x4a,
0x7c, 0x37, 0xa1, 0x9c, 0xa6, 0x47, 0x80, 0x1b, 0x43, 0xc2, 0x0f, 0x22, 0x07, 0x59, 0x0e, 0x35,
0x87, 0x83, 0x0c, 0x3a, 0x09, 0x38, 0x21, 0x41, 0x40, 0x85, 0xeb, 0x11, 0x3e, 0x74, 0x85, 0xd4,
0x8f, 0xaa, 0x02, 0x16, 0x06, 0x99, 0xaf, 0x91, 0xd8, 0x22, 0x7c, 0xd8, 0x55, 0x24, 0x74, 0x77,
0x6c, 0x44, 0x5d, 0x12, 0x04, 0x29, 0xbb, 0x2a, 0x6c, 0x54, 0x24, 0xde, 0x0c, 0x02, 0xcd, 0x69,
0xff, 0x4b, 0x0e, 0x6e, 0xab, 0x55, 0x79, 0xa6, 0x73, 0x89, 0x97, 0xc4, 0xeb, 0xa8, 0x9b, 0xf7,
0x21, 0x09, 0x07, 0x97, 0x5e, 0xfc, 0x4d, 0x4f, 0x64, 0xf9, 0xec, 0x89, 0xac, 0x01, 0x6b, 0x09,
0x7e, 0xfe, 0x98, 0x78, 0x32, 0x5b, 0xe0, 0x82, 0x24, 0xc2, 0x14, 0x5f, 0x56, 0x91, 0xf4, 0x12,
0x29, 0x1d, 0x24, 0xe8, 0x24, 0x51, 0x25, 0x1f, 0x6e, 0x18, 0x9d, 0xe8, 0x04, 0xb5, 0xc4, 0xb8,
0xca, 0x3d, 0x0e, 0xa2, 0x13, 0x39, 0xa2, 0x29, 0x4f, 0x7f, 0x2c, 0xc6, 0x09, 0xd5, 0x99, 0x69,
0xc5, 0xb0, 0xed, 0x20, 0x6a, 0x7f, 0x6a, 0xf6, 0xed, 0x2e, 0xbe, 0x3f, 0x11, 0x21, 0x4d, 0x4c,
0x96, 0xc4, 0xc2, 0xa3, 0x4b, 0x6c, 0xe2, 0xef, 0x72, 0xc6, 0xca, 0x2f, 0xec, 0x39, 0xb5, 0x08,
0x0b, 0xe6, 0xe3, 0x93, 0xf4, 0x18, 0x8a, 0xbf, 0xa5, 0xd8, 0x90, 0x9e, 0x46, 0x61, 0x3a, 0x17,
0xa6, 0x29, 0x63, 0x05, 0x19, 0x50, 0x2f, 0x20, 0x9c, 0xeb, 0x53, 0x55, 0xda, 0xb6, 0xee, 0x41,
0x89, 0xf9, 0xd3, 0x34, 0x00, 0xc7, 0xbd, 0x39, 0x2f, 0x92, 0x31, 0x75, 0x80, 0xf9, 0x69, 0x1e,
0x70, 0x03, 0x8a, 0x32, 0x11, 0xf4, 0xe5, 0xbe, 0x52, 0x83, 0x2e, 0x30, 0xde, 0x94, 0x4d, 0xfb,
0x77, 0xfa, 0xa9, 0xc9, 0x6e, 0xcb, 0x51, 0xcf, 0x2c, 0xb0, 0x1e, 0x39, 0xb3, 0x7d, 0xe6, 0xce,
0xb8, 0x8c, 0xcf, 0x61, 0x51, 0x3f, 0x28, 0xca, 0xe3, 0x23, 0xad, 0xf5, 0xc6, 0x39, 0x01, 0x0d,
0xfd, 0x5b, 0xbd, 0x31, 0xda, 0x5c, 0x74, 0x9a, 0x07, 0x5b, 0xcf, 0xf7, 0x1d, 0xdd, 0xcf, 0xda,
0x86, 0x62, 0x9f, 0x04, 0x41, 0x8f, 0x78, 0x47, 0x38, 0xa4, 0x37, 0x91, 0x51, 0xd8, 0x6a, 0x77,
0x5a, 0x4d, 0x67, 0xcb, 0x49, 0xbb, 0x5a, 0xf7, 0xa0, 0x62, 0x1e, 0xf3, 0xb9, 0x7d, 0x46, 0x03,
0x63, 0xa3, 0x65, 0x83, 0xee, 0x48, 0x50, 0x3a, 0xaf, 0x13, 0xda, 0x23, 0x31, 0x53, 0xef, 0x87,
0xb4, 0x73, 0x2a, 0x29, 0x0c, 0x9f, 0xe6, 0xd8, 0x31, 0x94, 0xcf, 0x7c, 0xcd, 0x02, 0xd0, 0x3a,
0x57, 0xdf, 0xb2, 0x4a, 0x60, 0xbe, 0x5d, 0xcd, 0x59, 0x16, 0x54, 0x5a, 0x7b, 0xed, 0xed, 0x83,
0xae, 0xdb, 0xe9, 0x6e, 0x37, 0xf7, 0xdb, 0x5b, 0xd5, 0xbc, 0x75, 0x03, 0xae, 0x1e, 0x3a, 0xcf,
0xbb, 0xcf, 0x9f, 0xbe, 0xd8, 0x71, 0x77, 0xda, 0xdb, 0x7b, 0x5b, 0xee, 0x8b, 0xf6, 0x41, 0xf7,
0xc9, 0xa3, 0xea, 0x9c, 0x75, 0x1d, 0xd6, 0xbe, 0xde, 0x7e, 0xda, 0x3c, 0x6c, 0xbb, 0x87, 0x4d,
0xa7, 0xb9, 0x6f, 0x08, 0xf3, 0xf6, 0x7f, 0xe5, 0xd4, 0x29, 0xf6, 0xac, 0x4b, 0xd4, 0x0f, 0x7e,
0x94, 0x2a, 0xd6, 0xe7, 0x50, 0xa0, 0xa1, 0x2a, 0xfc, 0xab, 0xe0, 0x7e, 0xbf, 0xf1, 0x9a, 0x2e,
0x8d, 0x6d, 0x99, 0x87, 0x38, 0xa6, 0x5b, 0xfd, 0x4f, 0x60, 0x01, 0x91, 0x0b, 0xde, 0x04, 0xe5,
0xde, 0xe0, 0x4d, 0x50, 0xfe, 0xdc, 0x9b, 0xa0, 0xef, 0x41, 0x41, 0x3f, 0xc7, 0xc1, 0x85, 0x2b,
0x3d, 0xb4, 0xce, 0x2f, 0x9c, 0x63, 0x58, 0xec, 0x7f, 0xc8, 0x81, 0x7d, 0x5e, 0xe3, 0x16, 0xbe,
0x85, 0xdc, 0xe7, 0x03, 0x33, 0xce, 0xd6, 0xec, 0x38, 0xdf, 0x6f, 0xbc, 0xbe, 0xd7, 0xec, 0x50,
0x0f, 0xcd, 0x50, 0x6f, 0x40, 0x31, 0xad, 0xe4, 0xe8, 0x42, 0xef, 0x48, 0x17, 0x71, 0x32, 0xda,
0xe7, 0x5f, 0xaf, 0x7d, 0x36, 0xde, 0x5c, 0x3c, 0xdd, 0x6f, 0x18, 0xb8, 0xbe, 0x80, 0x0f, 0x5f,
0x3f, 0x9e, 0x37, 0x94, 0xf5, 0xeb, 0x3c, 0xac, 0xa5, 0xc2, 0x3a, 0x54, 0x3c, 0x8f, 0xd5, 0x1d,
0xde, 0x63, 0x28, 0x44, 0xb1, 0xb9, 0x5c, 0x9d, 0xdb, 0xa8, 0xe8, 0xe7, 0x71, 0x33, 0x6c, 0x0d,
0xf5, 0xd7, 0x31, 0xbc, 0xd6, 0x7e, 0xfa, 0x66, 0x55, 0xce, 0x59, 0x22, 0x1d, 0xb6, 0x79, 0x22,
0x75, 0xf7, 0x42, 0x01, 0xfa, 0xf9, 0xa6, 0x23, 0x39, 0xcd, 0xb3, 0x56, 0x39, 0x08, 0xec, 0x59,
0x7f, 0x04, 0xcb, 0x59, 0x06, 0x99, 0x49, 0x04, 0xd1, 0x49, 0x2d, 0xb7, 0x9e, 0xdf, 0x28, 0x3b,
0xf2, 0xa7, 0xf4, 0x7d, 0x43, 0x36, 0x18, 0xd6, 0xf2, 0x08, 0xe1, 0x6f, 0x3b, 0x84, 0x45, 0x25,
0xde, 0xaa, 0xc1, 0x95, 0x83, 0xe7, 0xdd, 0xf6, 0xce, 0x1f, 0xba, 0x2f, 0x3a, 0xdb, 0x8e, 0xdb,
0xd9, 0xee, 0x74, 0xda, 0xcf, 0x0f, 0x3a, 0xd5, 0xb7, 0xac, 0x3a, 0x5c, 0xd3, 0x94, 0xce, 0xb6,
0xf3, 0x32, 0x4b, 0xcb, 0xc9, 0x4d, 0xa6, 0x69, 0xcd, 0xd6, 0xb3, 0xf6, 0xf6, 0xcb, 0xed, 0xfd,
0xed, 0x83, 0x6e, 0xa7, 0x9a, 0xb7, 0xae, 0xc2, 0xaa, 0x26, 0xbc, 0x6c, 0xb6, 0xdc, 0x66, 0xab,
0xdb, 0x7e, 0x7e, 0x50, 0x9d, 0xb3, 0x7f, 0x31, 0x6f, 0x1e, 0x33, 0x3c, 0x7b, 0x11, 0xcb, 0x8c,
0x5f, 0x57, 0xd4, 0xff, 0x1f, 0xa1, 0xea, 0x1a, 0x2c, 0x46, 0x21, 0xa6, 0x44, 0x2a, 0x9a, 0xea,
0x96, 0x3c, 0x15, 0x9b, 0x3a, 0xbe, 0x11, 0x38, 0xaf, 0xde, 0x0c, 0x2b, 0xd8, 0xbc, 0x19, 0xc6,
0x67, 0x5f, 0xc8, 0x47, 0x7c, 0x3f, 0xd1, 0xf7, 0x02, 0xa0, 0xa0, 0xa6, 0xef, 0x27, 0x19, 0x86,
0x38, 0x4a, 0x84, 0xae, 0x06, 0x6b, 0x86, 0xc3, 0x28, 0xc1, 0xab, 0xf1, 0x88, 0x2b, 0x6b, 0x57,
0x77, 0x00, 0x8b, 0x11, 0x47, 0x63, 0xbf, 0x03, 0x25, 0xbd, 0xb4, 0x28, 0x5a, 0x95, 0xfe, 0x41,
0x41, 0x28, 0xba, 0x05, 0xcb, 0xf4, 0x54, 0x24, 0x44, 0xf9, 0x4e, 0x5e, 0x5b, 0xca, 0xbc, 0x8c,
0x9b, 0x9d, 0x9a, 0xc6, 0xb6, 0xe4, 0x44, 0x7f, 0xea, 0x94, 0x68, 0xfa, 0x9b, 0x9f, 0x79, 0xdc,
0x04, 0x6a, 0xca, 0xf4, 0xe3, 0x26, 0x19, 0x72, 0xbd, 0x51, 0xfa, 0x16, 0x9a, 0x4f, 0x38, 0xf3,
0xf5, 0x1d, 0x40, 0xc5, 0x1b, 0x69, 0xb9, 0x1d, 0x89, 0xca, 0x73, 0x70, 0x86, 0x53, 0x9f, 0xf1,
0x18, 0x4d, 0x74, 0x7d, 0x65, 0x2d, 0x65, 0x6f, 0xa7, 0x24, 0x0c, 0x51, 0x34, 0x8e, 0xe4, 0x31,
0x8f, 0xd7, 0xca, 0x3a, 0x44, 0x49, 0xa0, 0xed, 0xf3, 0xfa, 0x13, 0x80, 0xa9, 0xc2, 0xdf, 0xe1,
0x6d, 0xde, 0xdf, 0xe6, 0x55, 0x08, 0xc7, 0x67, 0x70, 0xfa, 0x78, 0xfa, 0xbc, 0xdf, 0x19, 0xf3,
0x98, 0x79, 0x2c, 0x1a, 0xab, 0x8b, 0x65, 0x26, 0x26, 0xdf, 0xb5, 0xee, 0x67, 0xfd, 0x04, 0xac,
0xd1, 0x38, 0x10, 0x2c, 0x0e, 0xa8, 0xcb, 0x42, 0x2e, 0x48, 0xe8, 0x51, 0xae, 0x5d, 0xe8, 0x0f,
0x1b, 0x6f, 0xf2, 0xc9, 0xc6, 0xbe, 0xee, 0xbf, 0x4b, 0x46, 0xb4, 0x6d, 0x44, 0x38, 0xab, 0x46,
0x6c, 0x0a, 0xd5, 0x03, 0xb8, 0x7a, 0x21, 0x2f, 0x3e, 0x09, 0x92, 0x36, 0xac, 0x01, 0x5d, 0xcb,
0xd0, 0x0f, 0xa2, 0xa5, 0x3d, 0x6b, 0x82, 0x2a, 0x68, 0xdc, 0x83, 0x4a, 0x24, 0x86, 0xc6, 0x82,
0xa7, 0x47, 0xc0, 0x32, 0xa2, 0xe6, 0xec, 0x67, 0xff, 0xef, 0xa2, 0x2a, 0xb8, 0x6f, 0x1d, 0xea,
0x94, 0x67, 0x9f, 0x79, 0x49, 0xd4, 0x3d, 0x55, 0xef, 0x0a, 0xd4, 0x54, 0xe4, 0xb2, 0x53, 0x71,
0x1d, 0x0a, 0x03, 0x2f, 0x1b, 0x5f, 0x16, 0x07, 0x1e, 0xc6, 0x96, 0xdf, 0x83, 0x42, 0xac, 0x44,
0xe8, 0x89, 0x79, 0xa7, 0x71, 0xb1, 0xe0, 0x86, 0x06, 0x94, 0xbb, 0xd6, 0x7d, 0xac, 0x2f, 0x61,
0x19, 0xef, 0x62, 0x89, 0x7e, 0xe6, 0xa0, 0x9e, 0x85, 0xbd, 0xf7, 0x1a, 0x19, 0x06, 0x70, 0xce,
0x74, 0xae, 0xff, 0xf9, 0x3c, 0xac, 0xcc, 0x70, 0xe0, 0xc5, 0x76, 0xc8, 0x84, 0x2a, 0x66, 0xe8,
0x33, 0x85, 0x04, 0xb0, 0x7e, 0xb1, 0x01, 0xd5, 0x80, 0x70, 0xe1, 0x8e, 0x71, 0xd7, 0x28, 0x1e,
0x65, 0x01, 0x15, 0x89, 0xab, 0xcd, 0x84, 0x9c, 0x57, 0x61, 0x51, 0x9c, 0x86, 0xe6, 0x31, 0xe0,
0xbc, 0xb3, 0x20, 0x4e, 0x43, 0x55, 0x62, 0xcf, 0x3c, 0x22, 0x9f, 0x3f, 0x53, 0xee, 0x52, 0xb7,
0xa2, 0xd2, 0xb1, 0xe0, 0x03, 0x0f, 0xed, 0x26, 0x8a, 0x12, 0x68, 0x0b, 0x3a, 0x92, 0x53, 0x2a,
0x71, 0x57, 0x3f, 0x8a, 0x9c, 0x77, 0x16, 0x65, 0x53, 0xf5, 0xf2, 0x69, 0x5f, 0xe7, 0x71, 0xfa,
0x8a, 0xd0, 0xa7, 0x7d, 0x95, 0xc7, 0x5d, 0x81, 0x85, 0x38, 0x61, 0x1e, 0xd5, 0x6f, 0x57, 0x54,
0x43, 0xba, 0x6c, 0x41, 0x4e, 0xf5, 0x6b, 0x15, 0xf9, 0x53, 0x0a, 0x41, 0x92, 0x3b, 0xe6, 0xbe,
0x7e, 0xa3, 0x52, 0x44, 0xe0, 0x05, 0xc7, 0xd5, 0x14, 0xe4, 0x14, 0x49, 0xea, 0x61, 0xca, 0xa2,
0x20, 0xa7, 0x92, 0xf0, 0x0e, 0x94, 0xd3, 0xc3, 0x0e, 0x7a, 0x27, 0xb5, 0x97, 0x97, 0x0d, 0x88,
0x3e, 0xea, 0x5d, 0xa8, 0x28, 0xff, 0x28, 0x67, 0x04, 0xb9, 0xca, 0x99, 0x4b, 0xc2, 0xee, 0x69,
0x68, 0x2e, 0xe4, 0xce, 0x14, 0x5e, 0x2a, 0xe6, 0xf4, 0x99, 0x56, 0x5d, 0xa4, 0xb3, 0x4b, 0xe8,
0x40, 0x7a, 0x0f, 0xe4, 0x58, 0x51, 0x89, 0x8b, 0x82, 0x90, 0xa1, 0x0e, 0xc5, 0x6f, 0xc6, 0x04,
0xcb, 0x3e, 0x58, 0xfd, 0x5c, 0x70, 0xd2, 0xb6, 0xb5, 0x0e, 0xcb, 0x09, 0xed, 0xbb, 0x68, 0x00,
0x72, 0x0e, 0x57, 0xd5, 0x73, 0x9f, 0x84, 0xf6, 0xbb, 0x12, 0x6a, 0xfb, 0xf5, 0x5f, 0xe6, 0xa0,
0x94, 0x31, 0x3a, 0x75, 0x1f, 0x82, 0xcd, 0x33, 0x8f, 0x42, 0x15, 0x83, 0x2a, 0x73, 0x68, 0xf2,
0x99, 0x32, 0x87, 0xc2, 0xd0, 0xd8, 0xdf, 0x81, 0xb2, 0x29, 0x3f, 0x2a, 0x95, 0xd5, 0x69, 0x7b,
0xd9, 0x80, 0xa8, 0x74, 0x96, 0x09, 0x05, 0xcd, 0x9f, 0x65, 0xc2, 0x82, 0xc9, 0x5f, 0xea, 0xb7,
0x97, 0xe7, 0x6d, 0xfc, 0xcd, 0xee, 0x95, 0x5e, 0x02, 0x50, 0x7c, 0xed, 0x81, 0x6a, 0xa8, 0x94,
0xfe, 0x83, 0xc6, 0xe5, 0x12, 0x1b, 0xdb, 0xdb, 0xb2, 0x87, 0x2a, 0x78, 0x1d, 0xb9, 0xfb, 0x7c,
0xf0, 0x92, 0x04, 0xcc, 0x77, 0x32, 0x92, 0xec, 0xff, 0xce, 0x01, 0x4c, 0xd9, 0xac, 0x0a, 0x64,
0x18, 0xab, 0x6f, 0xc9, 0xd8, 0x8c, 0xed, 0x76, 0x78, 0x2c, 0x91, 0x66, 0x1c, 0xb7, 0x65, 0x7e,
0x7d, 0x13, 0xae, 0x67, 0xe1, 0xcc, 0xa4, 0x57, 0xf3, 0x32, 0xd0, 0x23, 0xf1, 0x20, 0xea, 0x66,
0x36, 0x6b, 0x75, 0xce, 0x5a, 0x83, 0x15, 0x24, 0x74, 0xbe, 0xda, 0xdb, 0x21, 0x2c, 0x18, 0x27,
0xb4, 0x3a, 0x6f, 0xdd, 0x81, 0x9b, 0x08, 0x66, 0x64, 0x6c, 0x31, 0xee, 0x25, 0x34, 0x26, 0xa1,
0x37, 0xa9, 0x2e, 0x58, 0xeb, 0x70, 0x0b, 0x19, 0x32, 0xc2, 0xda, 0x21, 0xa7, 0x89, 0xd8, 0xc1,
0x22, 0x57, 0xb5, 0x90, 0x7e, 0xb0, 0x19, 0x24, 0x94, 0xf8, 0x13, 0x67, 0x1c, 0x86, 0x2c, 0x1c,
0x54, 0x8b, 0xa9, 0x6c, 0xad, 0x66, 0x46, 0xc2, 0x16, 0x11, 0xa4, 0xba, 0xf4, 0xc1, 0xdf, 0xe7,
0xa0, 0x3a, 0xfb, 0x9f, 0x2a, 0xf2, 0x83, 0x97, 0xfd, 0xf7, 0x4a, 0xf5, 0x2d, 0x29, 0xf7, 0x1c,
0xc7, 0x4e, 0x12, 0x8d, 0x54, 0xa1, 0xa1, 0x9a, 0xbb, 0x50, 0x04, 0x32, 0x60, 0x42, 0x21, 0x4f,
0x23, 0x37, 0xe1, 0xfa, 0x85, 0x1c, 0xbb, 0xad, 0xea, 0xdc, 0x85, 0xdd, 0x1d, 0x1a, 0x07, 0x13,
0xfd, 0x81, 0xf9, 0xcd, 0x16, 0x2c, 0x1d, 0xd1, 0x89, 0xca, 0x09, 0xac, 0xdb, 0x0d, 0xf5, 0x4f,
0x53, 0x0d, 0x73, 0xa2, 0x6a, 0x60, 0x44, 0xd5, 0xc9, 0x60, 0xed, 0x3f, 0xfe, 0x0d, 0xb3, 0x9e,
0xcd, 0x85, 0x3e, 0x09, 0x38, 0x75, 0x8a, 0x47, 0x74, 0x82, 0xf4, 0xcd, 0x0e, 0x58, 0x23, 0x3e,
0x88, 0xa3, 0x28, 0x70, 0x79, 0xd4, 0x17, 0xea, 0xc2, 0xc5, 0xba, 0x73, 0x4e, 0x9a, 0x4e, 0x16,
0xcf, 0xca, 0x5b, 0xd8, 0xcc, 0x7f, 0xf2, 0xd0, 0xa9, 0x6a, 0x01, 0x9d, 0xa8, 0x2f, 0xf0, 0x7a,
0x66, 0xb3, 0x3b, 0x15, 0x3a, 0x24, 0x89, 0xff, 0xa6, 0x42, 0xff, 0x53, 0x0b, 0x9d, 0xfb, 0xe4,
0xb3, 0x47, 0xa9, 0xd4, 0x67, 0x24, 0xf1, 0x51, 0xea, 0xd3, 0x85, 0x67, 0xb9, 0x6f, 0x73, 0x6f,
0xfd, 0x5f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xad, 0xd1, 0xc2, 0x67, 0x33, 0x36, 0x00, 0x00,
}
|
<gh_stars>0
import { Fragment } from "react";
import { APYUpdater } from "state/apy/updater";
import { BankUpdater } from "state/banks/updater";
import { MulticallUpdater } from "state/multicall/updater";
import { PriceUpdater } from "state/prices/updater";
import { SupplyUpdater } from "state/supply/updater";
import { TransactionUpdater } from "state/transactions/updater";
import { TVLUpdater } from "state/tvl/updater";
export const Updaters = () => {
return (
<Fragment>
<APYUpdater />
<BankUpdater />
<MulticallUpdater />
<PriceUpdater />
<SupplyUpdater />
<TransactionUpdater />
<TVLUpdater />
</Fragment>
);
};
|
/*
* Copyright (c) 2008-2019, Hazelcast, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.hazelcast.internal.diagnostics;
import com.hazelcast.logging.ILogger;
import com.hazelcast.spi.impl.NodeEngineImpl;
import com.hazelcast.spi.properties.HazelcastProperties;
import com.hazelcast.spi.properties.HazelcastProperty;
import com.hazelcast.util.ConcurrentReferenceHashMap;
import com.hazelcast.util.ConcurrentReferenceHashMap.ReferenceType;
import com.hazelcast.util.ConstructorFunction;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.atomic.AtomicLongArray;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
import static com.hazelcast.internal.diagnostics.Diagnostics.PREFIX;
import static com.hazelcast.util.ConcurrencyUtil.getOrPutIfAbsent;
import static java.lang.Math.max;
import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
import static java.util.concurrent.atomic.AtomicLongFieldUpdater.newUpdater;
/**
* A {@link DiagnosticsPlugin} that helps to detect if there are any performance issues with Stores/Loaders like e.g.
* {@link com.hazelcast.core.MapStore}.
* <p>
* This is done by instrumenting these Stores/Loaders with latency tracking probes, so that per Store/Loader all kinds
* of statistics like count, avg, mag, latency distribution etc is available.
* <p>
* One of the main purposes of this plugin is to make sure that e.g. a Database is the cause of slow performance. This
* plugin is useful to be combined with {@link SlowOperationPlugin} to get idea about where the threads are spending
* their time.
* <p>
* If this plugin is not enabled, there is no performance hit since the Stores/Loaders don't get decorated.
*/
public class StoreLatencyPlugin extends DiagnosticsPlugin {
/**
* The period in seconds this plugin runs.
* <p>
* If set to 0, the plugin is disabled.
*/
public static final HazelcastProperty PERIOD_SECONDS
= new HazelcastProperty(PREFIX + ".storeLatency.period.seconds", 0, SECONDS);
/**
* The period in second the statistics should be reset. Normally the statistics are not reset and if the system
* is running for an extended time, it isn't possible to see that happened in e.g. the last hour.
* <p>
* Currently there is no sliding window functionality to deal with this correctly. But for the time being this
* setting will periodically reset the statistics.
*/
public static final HazelcastProperty RESET_PERIOD_SECONDS
= new HazelcastProperty(PREFIX + ".storeLatency.reset.period.seconds", 0, SECONDS);
private static final int LOW_WATERMARK_MICROS = 100;
private static final int LATENCY_BUCKET_COUNT = 32;
private static final String[] LATENCY_KEYS;
static {
LATENCY_KEYS = new String[LATENCY_BUCKET_COUNT];
long maxDurationForBucket = LOW_WATERMARK_MICROS;
long p = 0;
for (int k = 0; k < LATENCY_KEYS.length; k++) {
LATENCY_KEYS[k] = p + ".." + (maxDurationForBucket - 1) + "us";
p = maxDurationForBucket;
maxDurationForBucket *= 2;
}
}
private final ConcurrentMap<String, ServiceProbes> metricsPerServiceMap
= new ConcurrentHashMap<String, ServiceProbes>();
private final ConstructorFunction<String, ServiceProbes> metricsPerServiceConstructorFunction
= new ConstructorFunction<String, ServiceProbes>() {
@Override
public ServiceProbes createNew(String serviceName) {
return new ServiceProbes(serviceName);
}
};
private final ConstructorFunction<String, InstanceProbes> instanceProbesConstructorFunction
= new ConstructorFunction<String, InstanceProbes>() {
@Override
public InstanceProbes createNew(String dataStructureName) {
return new InstanceProbes(dataStructureName);
}
};
private final long periodMillis;
private final long resetPeriodMillis;
private final long resetFrequency;
private long iteration;
public StoreLatencyPlugin(NodeEngineImpl nodeEngine) {
this(nodeEngine.getLogger(StoreLatencyPlugin.class), nodeEngine.getProperties());
}
public StoreLatencyPlugin(ILogger logger, HazelcastProperties properties) {
super(logger);
this.periodMillis = properties.getMillis(PERIOD_SECONDS);
this.resetPeriodMillis = properties.getMillis(RESET_PERIOD_SECONDS);
if (periodMillis == 0 || resetPeriodMillis == 0) {
this.resetFrequency = 0;
} else {
this.resetFrequency = max(1, resetPeriodMillis / periodMillis);
}
}
@Override
public long getPeriodMillis() {
return periodMillis;
}
@Override
public void onStart() {
logger.info("Plugin:active: period-millis:" + periodMillis + " resetPeriod-millis:" + resetPeriodMillis);
}
@Override
public void run(DiagnosticsLogWriter writer) {
iteration++;
render(writer);
resetStatisticsIfNeeded();
}
private void render(DiagnosticsLogWriter writer) {
for (ServiceProbes serviceProbes : metricsPerServiceMap.values()) {
serviceProbes.render(writer);
}
}
private void resetStatisticsIfNeeded() {
if (resetFrequency > 0 && iteration % resetFrequency == 0) {
for (ServiceProbes serviceProbes : metricsPerServiceMap.values()) {
serviceProbes.resetStatistics();
}
}
}
// just for testing
public long count(String serviceName, String dataStructureName, String methodName) {
return ((LatencyProbeImpl) newProbe(serviceName, dataStructureName, methodName)).stats.count;
}
public LatencyProbe newProbe(String serviceName, String dataStructureName, String methodName) {
ServiceProbes serviceProbes = getOrPutIfAbsent(
metricsPerServiceMap, serviceName, metricsPerServiceConstructorFunction);
return serviceProbes.newProbe(dataStructureName, methodName);
}
private final class ServiceProbes {
private final String serviceName;
// the InstanceProbes are stored in a weak reference, so that if the store/loader is gc'ed, the probes are gc'ed
// and therefor there is no strong reference to the InstanceProbes and they get gc'ed
private final ConcurrentReferenceHashMap<String, InstanceProbes> instanceProbesMap
= new ConcurrentReferenceHashMap<String, InstanceProbes>(ReferenceType.STRONG, ReferenceType.WEAK);
private ServiceProbes(String serviceName) {
this.serviceName = serviceName;
}
private LatencyProbe newProbe(String dataStructureName, String methodName) {
InstanceProbes instanceProbes = getOrPutIfAbsent(
instanceProbesMap, dataStructureName, instanceProbesConstructorFunction);
return instanceProbes.newProbe(methodName);
}
private void render(DiagnosticsLogWriter writer) {
writer.startSection(serviceName);
for (InstanceProbes instanceProbes : instanceProbesMap.values()) {
instanceProbes.render(writer);
}
writer.endSection();
}
private void resetStatistics() {
for (InstanceProbes instanceProbes : instanceProbesMap.values()) {
instanceProbes.resetStatistics();
}
}
}
/**
* Contains all probes for a given instance, e.g. for an {@link com.hazelcast.core.IMap} instance {@code employees}.
*/
private static final class InstanceProbes {
// key is the name of the probe, e.g. load
private final ConcurrentMap<String, LatencyProbeImpl> probes = new ConcurrentHashMap<String, LatencyProbeImpl>();
private final String dataStructureName;
InstanceProbes(String dataStructureName) {
this.dataStructureName = dataStructureName;
}
LatencyProbe newProbe(String methodName) {
LatencyProbeImpl probe = probes.get(methodName);
if (probe == null) {
LatencyProbeImpl newProbe = new LatencyProbeImpl(methodName, this);
LatencyProbeImpl found = probes.putIfAbsent(methodName, newProbe);
probe = found == null ? newProbe : found;
}
return probe;
}
private void render(DiagnosticsLogWriter writer) {
writer.startSection(dataStructureName);
for (LatencyProbeImpl probe : probes.values()) {
probe.render(writer);
}
writer.endSection();
}
private void resetStatistics() {
for (LatencyProbeImpl probe : probes.values()) {
probe.resetStatistics();
}
}
}
// package private for testing
static final class LatencyProbeImpl implements LatencyProbe {
// instead of storing it in a final field, it is stored in a volatile field because stats can be reset
volatile Statistics stats = new Statistics();
// a strong reference to prevent garbage collection
@SuppressWarnings("unused")
private final InstanceProbes instanceProbes;
private final String methodName;
private LatencyProbeImpl(String methodName, InstanceProbes instanceProbes) {
this.methodName = methodName;
this.instanceProbes = instanceProbes;
}
@Override
public void recordValue(long durationNanos) {
stats.recordValue(durationNanos);
}
private void render(DiagnosticsLogWriter writer) {
Statistics stats = this.stats;
long invocations = stats.count;
long totalMicros = stats.totalMicros;
long avgMicros = invocations == 0 ? 0 : totalMicros / invocations;
long maxMicros = stats.maxMicros;
if (invocations == 0) {
return;
}
writer.startSection(methodName);
writer.writeKeyValueEntry("count", invocations);
writer.writeKeyValueEntry("totalTime(us)", totalMicros);
writer.writeKeyValueEntry("avg(us)", avgMicros);
writer.writeKeyValueEntry("max(us)", maxMicros);
writer.startSection("latency-distribution");
for (int k = 0; k < stats.latencyDistribution.length(); k++) {
long value = stats.latencyDistribution.get(k);
if (value > 0) {
writer.writeKeyValueEntry(LATENCY_KEYS[k], value);
}
}
writer.endSection();
writer.endSection();
}
private void resetStatistics() {
stats = new Statistics();
}
}
static final class Statistics {
private static final AtomicLongFieldUpdater<Statistics> COUNT
= newUpdater(Statistics.class, "count");
private static final AtomicLongFieldUpdater<Statistics> TOTAL_MICROS
= newUpdater(Statistics.class, "totalMicros");
private static final AtomicLongFieldUpdater<Statistics> MAX_MICROS
= newUpdater(Statistics.class, "maxMicros");
volatile long count;
volatile long maxMicros;
volatile long totalMicros;
private final AtomicLongArray latencyDistribution = new AtomicLongArray(LATENCY_BUCKET_COUNT);
private void recordValue(long durationNanos) {
long durationMicros = NANOSECONDS.toMicros(durationNanos);
COUNT.addAndGet(this, 1);
TOTAL_MICROS.addAndGet(this, durationMicros);
for (; ; ) {
long currentMax = maxMicros;
if (durationMicros <= currentMax) {
break;
}
if (MAX_MICROS.compareAndSet(this, currentMax, durationMicros)) {
break;
}
}
int bucketIndex = 0;
long maxDurationForBucket = LOW_WATERMARK_MICROS;
for (int k = 0; k < latencyDistribution.length() - 1; k++) {
if (durationMicros >= maxDurationForBucket) {
bucketIndex++;
maxDurationForBucket *= 2;
} else {
break;
}
}
latencyDistribution.incrementAndGet(bucketIndex);
}
}
public interface LatencyProbe {
void recordValue(long latencyNanos);
}
}
|
<reponame>Doogie13/postman<gh_stars>100-1000
package me.srgantmoomoo.postman.client.module.modules.pvp;
import org.lwjgl.input.Keyboard;
import me.srgantmoomoo.postman.client.module.Category;
import me.srgantmoomoo.postman.client.module.Module;
public class SmartHotbar extends Module {
public SmartHotbar() {
super ("smartHotbar", "a smart hotbar (wip).", Keyboard.KEY_NONE, Category.PVP);
}
}
|
<gh_stars>0
/**
* 导出声明
*/
const context = {};
module.exports = (obj) => {
Object.assign(context, obj);
return {
name: 'i18n_list',
method: 'GET',
path: '/i18n',
middleware: listRoute
};
};
/**
* 列表查询接口
* @param {object} ctx
*/
async function listRoute(ctx) {
// 当d不为空时返回所有信息，否则只返回必要信息
const list = context.app.getLocaleList();
let data = {};
if (ctx.query.d) {
data = list;
} else {
for (const key in list) {
data[key] = list[key].locale || key;
}
}
ctx.body = { data };
} |
package main
import "testing"
func TestNewUser(t *testing.T) {
user := NewUser("my_test_name")
if user.Name != "my_test_name" {
t.Fail()
}
if len(user.PubKeys) != 0 {
t.Fail()
}
}
func TestSetPubKeys(t *testing.T) {
user := NewUser("my_test_name")
beforeUpdate := user.UpdatedAt
user.SetPubKeys([]string{
"ssh-rsa dfskjwklejlwensdfslfjkwklefjskljdlskfjdsld user@host",
})
if len(user.PubKeys) != 1 {
t.Fail()
}
if beforeUpdate == user.UpdatedAt {
t.Fail()
}
}
|
import base64
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
def decrypt_data(algo, b64data, encryption_key, utf8):
if algo != 'AES':
raise ValueError('unsupported algorithm: %s' % algo)
encrypted = base64.b64decode(b64data)
decryptor = Cipher(algorithms.AES(encryption_key), modes.ECB(), default_backend()).decryptor()
decrypted_value = decryptor.update(encrypted) + decryptor.finalize()
decrypted_value = decrypted_value.rstrip(b'\x00')
if utf8:
decrypted_value = decrypted_value.decode('utf-8')
return decrypted_value |
<gh_stars>0
const Util = require('../../util/MitUtil.js');
module.exports = {
name: 'someone',
description: 'Elije un usuario aleatorio .w.',
aliases: ['something', 'randompick', 'person'],
usage: '',
cooldown: 2,
args: 0,
catergory: 'Utilidad',
async execute(client, message, args) {
try {
const member = message.guild.members.cache.random(1)[0];
return message.channel.send({
embed: {
title: "Aqui tienes al usuario elejido nwn",
color: "RANDOM",
fields: [{
name: '• Usuario',
value: member.user.username,
inline: false,
},
{
name: '• ID',
value: member.user.id,
inline: false,
}
],
thumbnail: {
url: member.user.displayAvatarURL(),
}
}
});
}
catch (err) {
console.log(err);
return message.reply(`Oh no, an error occurred. Try again later!`);
}
}
};
|
def binary_search(array, x):
# Initial values for start, middle and end
start = 0
end = len(array) - 1
while start <= end:
# Middle point calculation
mid = (start + end) // 2
# Check if x is present at mid
if array[mid] < x:
start = mid + 1
# If x is greater, ignore left half
elif array[mid] > x:
end = mid - 1
# If x is smaller, ignore right half
else:
return mid
# If we reach here, then the element was not present
return -1
# Added condition to avoid infinite while loop
if start == end:
return -1 |
#!/bin/bash
# Split lines in a text file
# Copyright 2017 Xiang Zhang
#
# Usage: bash split_lines.sh [lines] [input] [output_prefix]
#
# Note: .txt postfix will be automatically added.
set -x;
set -e;
split -d -a 1 --additional-suffix=.txt -l $1 $2 $3;
|
<filename>snippety/src/main/java/com/fueled/snippety/span/TextIndentSpan.java
package com.fueled.snippety.span;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Typeface;
import android.text.Layout;
import android.text.TextPaint;
import android.text.style.LeadingMarginSpan;
/**
* Indents the text with specified leadWidth and gapWidth.
*/
public class TextIndentSpan implements LeadingMarginSpan {
private final String data;
private final Options options;
public TextIndentSpan(Options options) {
this(options, "•");
}
public TextIndentSpan(Options options, int index) {
this(options, index + ".");
}
public TextIndentSpan(Options options, String data) {
this.options = options;
this.data = data;
}
@Override
public int getLeadingMargin(boolean first) {
return options.leadWidth + options.gapWidth;
}
public void drawLeadingMargin(Canvas c, Paint p, int x, int dir, int top, int baseline,
int bottom, CharSequence text, int start, int end, boolean first, Layout l) {
if (first) {
TextPaint paint = new TextPaint(p);
paint.setStyle(Paint.Style.FILL);
if (options.textSize != -1) {
paint.setTextSize(options.textSize);
}
if (options.textColor != -1) {
paint.setColor(options.textColor);
}
if (options.typeface != null) {
paint.setTypeface(options.typeface);
}
c.save();
c.drawText(data, x + options.leadWidth, baseline, paint);
c.restore();
}
}
public static class Options {
public int gapWidth;
public int leadWidth;
public int textSize = -1;
public int textColor = -1;
public Typeface typeface;
public Options(int leadWidth, int gapWidth) {
this.leadWidth = leadWidth;
this.gapWidth = gapWidth;
}
}
}
|
#!/usr/bin/env bash
set -eux
# Template custom configuration script -- add your own commands to customise
# the new box. Keep in mind that you can't use dnf and only selected file system
# locations are writable.
|
<gh_stars>1-10
package com.bustiblelemons.cthulhator.character.persistance;
import android.content.Context;
import android.os.Parcel;
import android.os.Parcelable;
import android.support.annotation.NonNull;
import android.support.v4.util.LruCache;
import com.bustiblelemons.cthulhator.character.characteristics.logic.CharacterPropertyComparators;
import com.bustiblelemons.cthulhator.character.characterslist.logic.SavedCharacterTransformer;
import com.bustiblelemons.cthulhator.character.description.model.CharacterDescription;
import com.bustiblelemons.cthulhator.character.history.model.BirthData;
import com.bustiblelemons.cthulhator.character.history.model.HistoryEvent;
import com.bustiblelemons.cthulhator.character.portrait.model.Portrait;
import com.bustiblelemons.cthulhator.character.possessions.model.Possesion;
import com.bustiblelemons.cthulhator.system.brp.skills.BRPSkillPointPools;
import com.bustiblelemons.cthulhator.system.brp.statistics.BRPStatistic;
import com.bustiblelemons.cthulhator.system.brp.statistics.HitPoints;
import com.bustiblelemons.cthulhator.system.brp.statistics.Sanity;
import com.bustiblelemons.cthulhator.system.damage.DamageBonusFactory;
import com.bustiblelemons.cthulhator.system.edition.GameEdition;
import com.bustiblelemons.cthulhator.system.properties.CharacterProperty;
import com.bustiblelemons.cthulhator.system.properties.PropertyType;
import com.bustiblelemons.cthulhator.system.properties.PropertyValueRetreiver;
import com.bustiblelemons.cthulhator.system.properties.Relation;
import com.bustiblelemons.cthulhator.system.time.YearsPeriodImpl;
import com.bustiblelemons.cthulhator.view.charactercard.CharacterInfo;
import com.bustiblelemons.cthulhator.view.charactercard.CharacterInfoProvider;
import com.bustiblelemons.randomuserdotme.model.Location;
import com.bustiblelemons.randomuserdotme.model.Name;
import com.fasterxml.jackson.annotation.JsonIgnore;
import org.joda.time.DateTime;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
/**
* Created by hiv on 07.01.15.
*/
public class CharacterWrapper extends SavedCharacter implements PropertyValueRetreiver,
CharacterInfoProvider,
TopSkillsRetriever {
static {
sShouldHaveAssignedAtLeast = BRPStatistic.values().length / 5;
}
public static final Parcelable.Creator<CharacterWrapper> CREATOR =
new Parcelable.Creator<CharacterWrapper>() {
public CharacterWrapper createFromParcel(Parcel source) {
return new CharacterWrapper(source);
}
public CharacterWrapper[] newArray(int size) {
return new CharacterWrapper[size];
}
};
private static LruCache<CharacterProperty, List<Possesion>> cachedAffectedPossessions =
new LruCache<CharacterProperty, List<Possesion>>(20);
private static YearsPeriodImpl sDefaultPeriod = YearsPeriodImpl.JAZZAGE;
private static int sShouldHaveAssignedAtLeast = 2;
@JsonIgnore
private long suggestedDate = Long.MIN_VALUE;
@JsonIgnore
private int skillPointsAvailable = -1;
@JsonIgnore
private int careerPoints = -1;
@JsonIgnore
private int hobbyPoints = -1;
@JsonIgnore
private Sanity sanity;
private CharacterInfo mCharacterInfo;
public CharacterWrapper(Parcel in) {
super(in);
this.suggestedDate = in.readLong();
this.skillPointsAvailable = in.readInt();
}
@JsonIgnore
@Override
public void writeToParcel(Parcel dest, int flags) {
super.writeToParcel(dest, flags);
dest.writeLong(this.suggestedDate);
dest.writeInt(this.skillPointsAvailable);
}
public CharacterWrapper(SavedCharacter character) {
super.setId(character.getId());
super.setProperties(character.getProperties());
super.setDescription(character.getDescription());
super.setPeriod(character.getPeriod());
super.setBirth(character.getBirth());
super.setAge(character.getAge());
super.setFullHistory(character.getFullHistory());
super.setPossesions(character.getPossesions());
super.setEdition(character.getEdition());
addDamageBonus();
addHitPoints();
updateSkillPointPools();
}
public CharacterWrapper(GameEdition edition) {
setEdition(edition);
}
@JsonIgnore
public int updatSecondaryStatistics() {
return updateRelatedProperties(getStatistics());
}
@JsonIgnore
private void setupAgeAndBirth() {
int edu = getStatisticValue(BRPStatistic.EDU.name());
int year = getPeriod().getDefaultYear();
int suggestedAge = edu + 6;
setAge(suggestedAge);
int estimateYear = year - getAge();
Random r = new Random();
int month = r.nextInt(11) + 1;
int day = r.nextInt(26) + 1;
int h = r.nextInt(23) + 1;
DateTime birthday = new DateTime(estimateYear, month, day, h, 0);
BirthData birth = new BirthData();
birth.setDate(birthday.getMillis());
setBirth(birth);
}
@JsonIgnore
public Collection<CharacterProperty> getTopCharacteristics(int max) {
List<CharacterProperty> r = new ArrayList<CharacterProperty>();
int i = 0;
for (CharacterProperty property : getTopStatistics()) {
r.add(property);
i++;
if (i == max) {
return r;
}
}
return r;
}
@JsonIgnore
public Collection<CharacterProperty> getTopStatistics() {
Set<CharacterProperty> r =
new TreeSet<CharacterProperty>(CharacterPropertyComparators.VALUE_DESC);
r.addAll(getStatistics());
return r;
}
@JsonIgnore
public List<CharacterProperty> getTopSkills(int max) {
List<CharacterProperty> r = new ArrayList<CharacterProperty>();
int i = 0;
for (CharacterProperty property : getTopSkills()) {
r.add(property);
i++;
if (i == max) {
return r;
}
}
return r;
}
@JsonIgnore
public List<CharacterProperty> getTopSkills() {
List<CharacterProperty> r = new ArrayList<CharacterProperty>();
r.addAll(getSkills());
Collections.sort(r, CharacterPropertyComparators.VALUE_DESC);
return r;
}
@JsonIgnore
private void updateSkillPointPools() {
if (getEdition() != null) {
fillSkillPointPools(getEdition());
}
}
@JsonIgnore
private void fillSkillPointPools(GameEdition edition) {
fillCareerPoints(edition);
fillHobbyPoints(edition);
}
private void fillHobbyPoints(GameEdition edition) {
CharacterProperty edu = getPropertyByName(BRPStatistic.EDU.name());
if (edu != null) {
CharacterProperty pointsProperty = BRPSkillPointPools.CAREER.asProperty();
int hobbyPointsValue = edu.getValue() * edition.getCareerSkillPointMultiplier();
pointsProperty.setValue(hobbyPointsValue);
addCharacterProperty(pointsProperty);
}
}
@JsonIgnore
private void fillCareerPoints(GameEdition edition) {
CharacterProperty __int = getPropertyByName(BRPStatistic.INT.name());
if (__int != null) {
CharacterProperty pointsProperty = BRPSkillPointPools.HOBBY.asProperty();
int hobbyPointsValue = __int.getValue() * edition.getCareerSkillPointMultiplier();
pointsProperty.setValue(hobbyPointsValue);
addCharacterProperty(pointsProperty);
}
}
@JsonIgnore
public Set<CharacterProperty> getCorelatives(CharacterProperty property) {
Set<CharacterProperty> r = Collections.emptySet();
if (property == null) {
return r;
}
r = new HashSet<CharacterProperty>();
Set<CharacterProperty> relatedProperties = getRelatedProperties(property);
for (CharacterProperty related : relatedProperties) {
if (related != null) {
Set<CharacterProperty> corelativesSet = getRelatedProperties(related);
r.addAll(corelativesSet);
}
}
return r;
}
@JsonIgnore
public Set<CharacterProperty> getRelatedProperties(@NonNull CharacterProperty toProperty) {
if (toProperty == null) {
throw new IllegalArgumentException("Passed param cannot be null");
}
Set<CharacterProperty> r = new HashSet<CharacterProperty>();
Collection<Relation> relations = toProperty.getRelations();
for (Relation relation : relations) {
if (relation != null) {
List<String> propNames = relation.getPropertyNames();
for (String propName : propNames) {
CharacterProperty relatedProperty = getPropertyByName(propName);
if (relatedProperty != null && relatedProperty.getRelations() != null) {
for (Relation relatedPropRelation : relatedProperty.getRelations()) {
int value = relatedPropRelation.getValueByRelation(this);
relatedProperty.setBaseValue(value);
relatedProperty.setMaxValue(value);
relatedProperty.setValue(value);
}
r.add(relatedProperty);
}
}
}
}
return r;
}
@JsonIgnore
private CharacterProperty getPropertyByName(String propertyName) {
for (CharacterProperty prop : properties) {
if (prop != null && prop.getName() != null) {
if (prop.getName().equalsIgnoreCase(propertyName)) {
return prop;
}
}
}
return null;
}
@JsonIgnore
public boolean addCharacterProperty(CharacterProperty property) {
if (properties != null && properties.contains(property)) {
properties.remove(property);
}
return properties != null && properties.add(property);
}
@JsonIgnore
public void fillSkillsList() {
addPropertiesList(getEdition().getSkills());
updateSkills();
}
@JsonIgnore
public void fillStatistics() {
if (properties == null || properties.isEmpty()) {
addPropertiesList(getEdition().getCharacteristics());
}
}
@JsonIgnore
public int updateSkills() {
return updateRelatedProperties(getSkills());
}
@JsonIgnore
public int updateRelatedProperties(Collection<CharacterProperty> ofProperties) {
int modified = 0;
for (CharacterProperty property : ofProperties) {
if (property != null) {
for (Relation relation : property.getRelations()) {
if (relation != null) {
int val = relation.getValueByRelation(this);
property.setValue(val);
property.setBaseValue(val);
modified++;
}
}
}
}
return modified;
}
public void setEdition(GameEdition edition) {
if (edition == null) {
return;
}
super.setEdition(edition);
fillStatistics();
addDamageBonus();
addHitPoints();
updatSecondaryStatistics();
fillSkillsList();
updateSkillPointPools();
setupAgeAndBirth();
}
private void addHitPoints() {
int con = getStatisticValue(BRPStatistic.CON.name());
int siz = getStatisticValue(BRPStatistic.SIZ.name());
CharacterProperty property = HitPoints.forProperties(getEdition(), con, siz)
.asCharacterProperty();
addCharacterProperty(property);
}
private void addDamageBonus() {
int con = getStatisticValue(BRPStatistic.CON.name());
int siz = getStatisticValue(BRPStatistic.SIZ.name());
CharacterProperty damageBonus = DamageBonusFactory.forEdition(getEdition(), con, siz)
.asCharacterProperty();
addCharacterProperty(damageBonus);
}
@JsonIgnore
public boolean hasAssignedStatistics() {
int count = 0;
for (CharacterProperty property : getStatistics()) {
if (property != null && property.getValue() > 0) {
count++;
}
}
return count >= sShouldHaveAssignedAtLeast;
}
@JsonIgnore
public long getSuggestedBirthDateEpoch() {
if (Long.MIN_VALUE == suggestedDate) {
DateTime now = new DateTime();
int year = getAge() + getPeriod().getDefaultYear();
int month = now.getMonthOfYear();
int dayOfMonth = now.getDayOfMonth();
int hour = now.getHourOfDay();
int minute = now.getMinuteOfHour();
DateTime time = new DateTime(year, month, dayOfMonth, hour, minute);
suggestedDate = time.getMillis();
}
return suggestedDate;
}
@JsonIgnore
public void setSuggestedDate(long suggestedDate) {
this.suggestedDate = suggestedDate;
}
@JsonIgnore
public Set<CharacterProperty> randomizeStatistics() {
careerPoints = -1;
skillPointsAvailable = -1;
hobbyPoints = -1;
for (CharacterProperty property : getStatistics()) {
if (property != null) {
int newRand = property.randomValue();
property.setValue(newRand);
}
}
updateSkills();
return getStatistics();
}
@JsonIgnore
public int getSkillValue(String name) {
CharacterProperty skill = getSkill(name);
return skill != null ? skill.getValue() : -1;
}
@JsonIgnore
public int getStatisticValue(String soughtStatistic) {
CharacterProperty stat = getStatistic(soughtStatistic);
return stat != null ? stat.getValue() : 1;
}
@JsonIgnore
protected boolean setPropertyValue(String name, int val) {
for (CharacterProperty prop : getProperties()) {
if (prop != null && prop.nameMatches(name)) {
prop.setValue(val);
return true;
}
}
return false;
}
@JsonIgnore
public int getCurrentSanity() {
return getSanity().getCurrent();
}
@JsonIgnore
public int getMaxSanity() {
return getSanity().getMax();
}
@JsonIgnore
public int setPropertyValues(Collection<CharacterProperty> propertyCollection) {
int r = 0;
if (propertyCollection == null) {
return r;
}
for (CharacterProperty s : propertyCollection) {
if (s != null) {
setPropertyValue(s.getName(), s.getValue());
r++;
}
}
updateSkills();
return r;
}
@JsonIgnore
public boolean setDexterity(int dex) {
return setPropertyValue(BRPStatistic.DEX.name(), dex);
}
@JsonIgnore
public boolean setEducation(int edu) {
return setPropertyValue(BRPStatistic.EDU.name(), edu);
}
@JsonIgnore
public boolean setIntelligence(int intellingence) {
return setPropertyValue(BRPStatistic.INT.name(), intellingence);
}
@JsonIgnore
public boolean setAppearance(int app) {
return setPropertyValue(BRPStatistic.APP.name(), app);
}
@JsonIgnore
public boolean setSize(int size) {
return setPropertyValue(BRPStatistic.SIZ.name(), size);
}
@JsonIgnore
public boolean setStrength(int str) {
return setPropertyValue(BRPStatistic.STR.name(), str);
}
@JsonIgnore
public boolean setPower(int pow) {
return setPropertyValue(BRPStatistic.POW.name(), pow);
}
@JsonIgnore
public boolean setSanity(int san) {
return setPropertyValue(BRPStatistic.SAN.name(), san);
}
@JsonIgnore
public void addPropertiesList(Set<CharacterProperty> characterProperties) {
if (properties == null) {
properties = new HashSet<CharacterProperty>();
}
properties.addAll(characterProperties);
updateSkills();
}
@JsonIgnore
public Set<CharacterProperty> getStatistics() {
return getPropertiesOfType(PropertyType.STATISTIC);
}
@JsonIgnore
public Set<CharacterProperty> getSkills() {
return getPropertiesOfType(PropertyType.SKILL);
}
@JsonIgnore
public Set<CharacterProperty> getPropertiesOfType(PropertyType type) {
Set<CharacterProperty> ret = new HashSet<CharacterProperty>();
for (CharacterProperty prop : properties) {
if (prop != null && type != null) {
if (type.equals(prop.getType())) {
ret.add(prop);
}
}
}
return ret;
}
@JsonIgnore
public List<Possesion> getPossesions(CharacterProperty affectedBy) {
List<Possesion> _prop = cachedAffectedPossessions.get(affectedBy);
if (_prop == null) {
_prop = extractPoseesions(affectedBy);
cachedAffectedPossessions.put(affectedBy, _prop);
}
return _prop;
}
@JsonIgnore
public List<Possesion> extractPoseesions(CharacterProperty characterProperty) {
List<Possesion> _prop = new ArrayList<Possesion>();
if (possesions != null) {
for (Possesion possesion : possesions) {
if (possesion != null) {
List<Relation> relations = possesion.getRelations();
for (Relation relation : relations) {
List<String> propertyNames = relation.getPropertyNames();
for (String propertyName : propertyNames) {
String soughtPropName = characterProperty.getName();
if (propertyName != null && propertyName.equals(soughtPropName)) {
_prop.add(possesion);
}
}
}
}
}
}
return _prop;
}
@JsonIgnore
public CharacterProperty getStatistic(String byName) {
for (CharacterProperty stat : getStatistics()) {
String statName = stat.getName();
if (statName.equalsIgnoreCase(byName)) {
return stat;
}
}
return null;
}
@JsonIgnore
public CharacterProperty getSkill(String byName) {
for (CharacterProperty skill : getSkills()) {
String skillName = skill.getName();
if (skillName.equalsIgnoreCase(byName)) {
return skill;
}
}
return null;
}
public int getSkillPointsAvailable() {
if (skillPointsAvailable < 0) {
skillPointsAvailable = getHobbyPoints() + getCareerPoints();
}
return skillPointsAvailable;
}
public void setSkillPointsAvailable(int skillPointsAvailable) {
this.skillPointsAvailable = skillPointsAvailable;
}
@JsonIgnore
public int getHobbyPoints() {
if (hobbyPoints < 0) {
CharacterProperty _int = getPropertyByName(BRPStatistic.INT.name());
if (_int != null) {
int intVal = _int.getValue();
hobbyPoints = getEdition().getHobbySkillPointMultiplier() * intVal;
}
}
return hobbyPoints;
}
@JsonIgnore
public int getCareerPoints() {
if (careerPoints < 0) {
CharacterProperty _int = getPropertyByName(BRPStatistic.EDU.name());
if (_int != null) {
int intVal = _int.getValue();
careerPoints = getEdition().getCareerSkillPointMultiplier() * intVal;
}
}
return careerPoints;
}
@Override
public int onRetreivePropertValue(String propertyName) {
for (CharacterProperty property : properties) {
if (property != null && property.nameMatches(propertyName)) {
return property.getValue();
}
}
return 0;
}
@JsonIgnore
public String getName() {
return getDescription() != null && getDescription().getName() != null ? getDescription().getName().getFullName() : null;
}
@JsonIgnore
public String getPhotoUrl() {
if (getDescription() != null
&& getDescription().getMainPortrait() != null) {
return getDescription().getMainPortrait().getUrl();
}
return null;
}
public List<Portrait> getPortraits() {
return getDescription() != null ? getDescription().getPortraitList() : new ArrayList<Portrait>();
}
public void setPortraits(List<Portrait> portraits) {
if (getDescription() == null) {
setDescription(new CharacterDescription());
}
getDescription().setPortraitList(portraits);
}
@JsonIgnore
public Portrait getMainPortrait() {
Portrait r = null;
if (getPortraits() != null) {
for (Portrait portrait : getPortraits()) {
if (r == null && portrait != null) {
r = portrait;
}
if (portrait != null && portrait.isMain()) {
return portrait;
}
}
}
return r;
}
@JsonIgnore
public List<HistoryEvent> getHistoryEvents(long tillDate) {
List<HistoryEvent> events = new ArrayList<HistoryEvent>();
if (fullHistory != null) {
for (HistoryEvent event : fullHistory) {
if (event != null && event.isBefore(tillDate)) {
events.add(event);
}
}
}
return events;
}
@Override
public YearsPeriodImpl getPeriod() {
YearsPeriodImpl period = super.getPeriod();
return period == null ? sDefaultPeriod : period;
}
public void setPeriod(YearsPeriodImpl period) {
super.setPeriod(period);
setupAgeAndBirth();
}
@JsonIgnore
public Name getNameObject() {
return getDescription() != null ? getDescription().getName() : null;
}
@JsonIgnore
public Sanity getSanity() {
return getSanity(false);
}
@JsonIgnore
public Sanity getSanity(boolean fresh) {
if (sanity == null || fresh) {
sanity = new Sanity();
int pow = getStatisticValue(BRPStatistic.POW.name());
int max = pow * 5;
sanity.setMax(max);
sanity.setCurrent(max);
}
return sanity;
}
@JsonIgnore
public List<HistoryEvent> getHistoryEvents(long tillDate, Location around) {
List<HistoryEvent> r = getHistoryEvents(tillDate);
//TODO Filter by location long/lat and distance toleration according to times
return r;
}
public boolean removeHistoryEvent(HistoryEvent event) {
if (event == null) {
return false;
}
if (fullHistory == null) {
fullHistory = new TreeSet<HistoryEvent>();
}
fullHistory.remove(event);
return true;
}
public boolean addHistoryEvent(HistoryEvent event) {
if (event == null) {
return false;
}
if (fullHistory == null) {
fullHistory = new TreeSet<HistoryEvent>();
}
fullHistory.add(event);
return true;
}
public static CharacterWrapper from(SavedCharacter character) {
return new CharacterWrapper(character);
}
//FIXME this class should not know of Context.class
@Override
public CharacterInfo onRetreiveCharacterInfo(Context arg) {
if (mCharacterInfo == null) {
mCharacterInfo = SavedCharacterTransformer.getInstance().withContext(arg)
.transform(this);
}
return mCharacterInfo;
}
}
|
package com.dev.base.mvp.model;
import com.dev.base.app.constant.UrlConstants;
import com.dev.base.mvp.model.http.DownloadApiService;
import com.dev.base.mvp.model.imodel.IDownloadModel;
import com.ljy.devring.DevRing;
import io.reactivex.Observable;
/**
* author: ljy
* date: 2018/3/23
* description: 下载文件的model层，进行相关的数据处理与提供
*/
public class DownloadModel implements IDownloadModel {
/**
* 下载文件
* @return 返回下载文件的请求
*/
@Override
public Observable downloadFile() {
return DevRing.httpManager().getService(DownloadApiService.class).downloadFile(UrlConstants.DOWNLOAD);
}
}
|
import { Document, Types } from 'mongoose';
import { UserDocument } from './user.interface';
export interface ITask {
user: Types.ObjectId | UserDocument,
body: string,
completed: boolean
}
export interface TaskDocument extends ITask, Document {}
|
/**
* Created by WareBare on 05/13/2019.
*/
module.exports = {
tplContent: {},
content_: function($contentType){
let url = `https://api.github.com/repos/WareBare/WanezGD_Tools/releases`;
// <span class=\"Link\" title=\"Opens link in Browser on click.\" onclick=\"require('electron').shell.openExternal(`https://discord.gg/ru6eU2p`)\">https://discord.gg/ru6eU2p</span>
fetchUrl(`${url}`, function(err, meta, InBody){
if(err){ console.error(err); return false; }
let releasesData = JSON.parse(InBody.toString())
, contentMD = ``;
for(let i = 0; i < releasesData.length; i++){
contentMD += `\r\n---\r\n# ${releasesData[i].name}\r\n${releasesData[i].body}\r\n`;
}
document.getElementById(`md_changelog`).innerHTML = marked(
`# Change Log\r\n` +
`---` +
`\r\n` +
`*Same as on the /releases/ page on GitHub*\r\n` +
`\r\n` +
`*You may use <kbd>Left-Click</kbd> on a link to open it in your default browser.*\r\n` +
`\r\n` +
`*You may use <kbd>Right-Click</kbd> on a link to copy its URL to Clipboard.*\r\n` +
`\r\n` +
`---` +
`\r\n` +
`# Table of Contents\r\n` +
`<details><summary>List</summary>` +
marked(markdown_toc(contentMD).content) +
`</details>`
);
document.getElementById(`md_changelog`).innerHTML += SanitizeLinks(marked(contentMD));
});
return `<div id="md_changelog" class="md">Loading...</div>`;
},
sidebarBtns_: function(){
return [];
},
sidebarList_: function(){
return {}
}
};
|
#! /bin/bash
set -e
echo "-----------------------------------------------"
echo "Current directory: $(pwd)"
echo "Python executable: ${PY_EXE}"
echo "-----------------------------------------------"
# {{{ clean up
rm -Rf .env
rm -Rf build
find . -name '*.pyc' -delete
# }}}
git submodule update --init --recursive
# {{{ virtualenv
VENV_VERSION="virtualenv-15.2.0"
rm -Rf "$VENV_VERSION"
curl -k https://files.pythonhosted.org/packages/b1/72/2d70c5a1de409ceb3a27ff2ec007ecdd5cc52239e7c74990e32af57affe9/$VENV_VERSION.tar.gz | tar xfz -
VIRTUALENV="${PY_EXE} -m venv"
${VIRTUALENV} -h > /dev/null || VIRTUALENV="$VENV_VERSION/virtualenv.py --no-setuptools -p ${PY_EXE}"
if [ -d ".env" ]; then
echo "**> virtualenv exists"
else
echo "**> creating virtualenv"
${VIRTUALENV} .env
fi
. .env/bin/activate
# }}}
# {{{ setuptools
#curl -k https://bitbucket.org/pypa/setuptools/raw/bootstrap-py24/ez_setup.py | python -
#curl -k https://ssl.tiker.net/software/ez_setup.py | python -
curl -k https://bootstrap.pypa.io/ez_setup.py | python -
# }}}
curl -k https://bootstrap.pypa.io/get-pip.py | python -
# Not sure why pip ends up there, but in Py3.3, it sometimes does.
export PATH=`pwd`/.env/local/bin:$PATH
PIP="${PY_EXE} $(which pip)"
$PIP install -r requirements.txt
cp local_settings_example.py local_settings.py
if [[ "$RL_CI_TEST" = "test_postgres" ]]; then
$PIP install psycopg2-binary
psql -c 'create database relate;' -U postgres
echo "import psycopg2.extensions" >> local_settings_example.py
echo "DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'USER': 'postgres',
'NAME': 'test_relate',
'OPTIONS': {
'isolation_level': psycopg2.extensions.ISOLATION_LEVEL_SERIALIZABLE,
},
},
}" >> local_settings_example.py
fi
# Make sure i18n literals marked correctly
${PY_EXE} manage.py makemessages --no-location --ignore=req.txt > output.txt
if [[ -n $(grep "msgid" output.txt) ]]; then
echo "Command 'python manage.py makemessages' failed with the following info:"
echo ""
grep --color -E '^|warning: ' output.txt
exit 1;
fi
${PY_EXE} manage.py compilemessages
$PIP install codecov factory_boy
if [[ "$RL_CI_TEST" = "test_expensive" ]]; then
coverage run manage.py test tests.test_tasks \
tests.test_admin \
tests.test_pages.test_code \
tests.test_pages.test_generic \
tests.test_pages.test_inline.InlineMultiPageUpdateTest \
tests.test_pages.test_upload.UploadQuestionNormalizeTest \
tests.test_grades.test_generic \
tests.test_grades.test_grades.GetGradeTableTest \
tests.test_grading.SingleCourseQuizPageGradeInterfaceTest \
tests.test_utils.LanguageOverrideTest \
tests.test_accounts.test_admin.AccountsAdminTest \
tests.test_flow.test_flow.AssemblePageGradesTest \
tests.test_flow.test_flow.FinishFlowSessionViewTest \
tests.test_content.SubDirRepoTest \
tests.test_auth.SignInByPasswordTest \
tests.test_analytics.FlowAnalyticsTest \
tests.test_analytics.PageAnalyticsTest \
tests.test_analytics.FlowListTest \
tests.test_analytics.IsFlowMultipleSubmitTest \
tests.test_analytics.IsPageMultipleSubmitTest \
tests.test_versioning.ParamikoSSHVendorTest \
tests.test_receivers.UpdateCouresOrUserSignalTest
elif [[ "$RL_CI_TEST" = "test_postgres" ]]; then
coverage run manage.py test tests.test_postgres
else
coverage run manage.py test tests
fi
coverage report -m
codecov
|
def classify_int(x):
if x < 0:
return 'negative'
elif x == 0:
return 'zero'
elif x > 0:
return 'positive' |
#include <stdio.h>
int main(void) {
int n = 10;
int sum = n * (n + 1) / 2;
printf("Sum of the first %d natural numbers is %d\n", n, sum);
return 0;
} |
<reponame>m-nakagawa/sample
/*
* 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.jena.hadoop.rdf.io.output;
import java.io.IOException;
import java.io.Writer;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.jena.hadoop.rdf.io.registry.HadoopRdfIORegistry;
import org.apache.jena.hadoop.rdf.types.QuadWritable;
import org.apache.jena.riot.Lang;
import org.apache.jena.riot.RDFLanguages;
import org.apache.jena.sparql.core.Quad ;
/**
* An output format for RDF quads that dynamically selects the appropriate quad
* writer to use based on the file extension of the output file.
* <p>
* For example this is useful when the output format may be controlled by a user
* supplied filename i.e. the desired RDF output format is not precisely known
* in advance
* </p>
*
* @param <TKey>
* Key type
*/
public abstract class QuadsOutputFormat<TKey> extends AbstractNodeTupleOutputFormat<TKey, Quad, QuadWritable> {
@Override
protected RecordWriter<TKey, QuadWritable> getRecordWriter(Writer writer, Configuration config, Path outputPath)
throws IOException {
Lang lang = RDFLanguages.filenameToLang(outputPath.getName());
if (lang == null)
throw new IOException("There is no registered RDF language for the output file " + outputPath.toString());
if (!RDFLanguages.isQuads(lang))
throw new IOException(
lang.getName()
+ " is not a RDF quads format, perhaps you wanted TriplesOutputFormat or TriplesOrQuadsOutputFormat instead?");
// This will throw an appropriate error if the language does not support
// writing quads
return HadoopRdfIORegistry.<TKey> createQuadWriter(lang, writer, config);
}
}
|
import { apiTestRegion } from './regions';
function createTestNodeBalancer(id) {
return {
label: `nodebalancer-${id}`,
region: apiTestRegion,
status: 'new_active',
updated: '2017-03-06T22:00:48',
created: '2017-03-03T18:08:44',
hostname: 'nb-1-1-1-1.newark.nodebalancer.linode.com',
id: 23,
client_conn_throttle: 0,
ipv4: '1.1.1.1',
_configs: {
configs: {
1: {
check_timeout: 30,
nodebalancer_id: 23,
check_path: '',
check_attempts: 3,
id: 1,
label: 'none',
check_interval: 0,
protocol: 'http',
algorithm: 'roundrobin',
cipher_suite: 'recommended',
stickiness: 'none',
check_passive: true,
nodes_status: {
up: 1,
down: 0,
},
port: 80,
check_body: '',
check: 'none',
_nodes: {
nodes: {
1: {
nodebalancer_id: 23,
id: 1,
mode: 'accept',
address: '192.168.4.5:80',
label: 'greatest_node_ever',
weight: 40,
config_id: 0,
status: 'online',
},
},
},
},
2: {
check_timeout: 30,
nodebalancer_id: 23,
check_path: '',
check_attempts: 3,
id: 2,
label: 'none',
check_interval: 0,
protocol: 'http',
algorithm: 'roundrobin',
cipher_suite: 'recommended',
stickiness: 'none',
check_passive: true,
nodes_status: {
up: 0,
down: 0,
},
port: 81,
check_body: '',
check: 'none',
},
},
},
};
}
export const genericNodeBalancer = createTestNodeBalancer(1);
export const noGroupNodeBalancer = {
...createTestNodeBalancer(2),
group: '',
};
export const nodebalancers = [
genericNodeBalancer,
noGroupNodeBalancer,
].reduce((object, nodebalancer) => ({ ...object, [nodebalancer.id]: nodebalancer }), {});
|
package room
import (
"PZ_GameServer/common/random_name"
"PZ_GameServer/common/util"
"PZ_GameServer/model"
"PZ_GameServer/protocol/pb"
"PZ_GameServer/sdk"
"PZ_GameServer/server/game/room/ningbo"
"PZ_GameServer/server/game/room/pinshi"
"PZ_GameServer/server/game/room/srddz"
"PZ_GameServer/server/game/room/xiangshan"
"PZ_GameServer/server/game/room/xizhou"
"PZ_GameServer/server/game/roombase"
"PZ_GameServer/server/user"
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"math/rand"
"strconv"
"sync"
"time"
)
// 房间结构
type RoomHandle struct {
RoomId int //
Room interface{} // 房间实例
CreateTime int64 // 创建时间
GameType int // 房间类型
}
type MatchItemList struct {
List []*MatchItem
}
type MatchItem struct {
Match *mjgame.Match_Room
User *user.User
}
var (
RoomList = make(map[int]*RoomHandle) // 房间
MatchList = make(map[string]*MatchItemList)
RoomDefInfo = make(map[int32]*roombase.RoomRule) // 房间默认规则
mutex sync.RWMutex
Config = make(map[string]map[string]string)
matchMutex sync.Mutex
)
const (
XiZhou = int32(mjgame.MsgID_GTYPE_ZheJiang_XiZhou)
XiangShan = int32(mjgame.MsgID_GTYPE_ZheJiang_XiangShan)
NingBo = int32(mjgame.MsgID_GTYPE_SanDizhu)
ZhenHai = int32(mjgame.MsgID_GTYPE_ZheJiang_ZhenHai)
BeiLun = int32(mjgame.MsgID_GTYPE_ZheJiang_Beilun)
Srddz = int32(mjgame.MsgID_GTYPE_SirenDizhu)
Pinshi = int32(mjgame.MsgID_GTYPE_Pinshi)
)
func LoadConfig(path string) error {
data, err := ioutil.ReadFile(path)
if err != nil {
return err
}
//UTF-8 text string with a Byte Order Mark (BOM). The BOM identifies that the text is UTF-8 encoded,
// but it should be removed before decoding
data = bytes.TrimPrefix(data, []byte("\xef\xbb\xbf"))
err = json.Unmarshal(data, &Config)
if err != nil {
return err
}
return nil
}
// 初始化注册游戏类型
func InitGames() {
RoomDefInfo[XiZhou] = &xizhou.XiZhou_RoomRule
RoomDefInfo[XiangShan] = &xiangshan.XiangShan_RoomRule
RoomDefInfo[NingBo] = &ningbo.NingBo_RoomRule
RoomDefInfo[Srddz] = &srddz.Srddz_RoomRule
RoomDefInfo[Pinshi] = &pinshi.Pinshi_RoomRule
XueLiu_Init() // 血流
go WatchRoom()
}
// 创建房间
func CreateRoom(roomId int, croom *mjgame.Create_Room, user *user.User) *RoomHandle {
_, ok := RoomDefInfo[croom.Type]
if !ok {
return nil // 没有这种房间类型
}
// 创建房间
room := GetNewRoom(roomId, croom.Type, user, croom.Rule)
mutex.Lock()
defer mutex.Unlock()
RoomList[roomId] = &RoomHandle{
RoomId: roomId,
Room: room,
CreateTime: time.Now().Unix(),
GameType: int(croom.Type),
}
return RoomList[roomId]
}
//匹配玩家
func MatchRoom(param *mjgame.Match_Room, muser *user.User) (*RoomHandle, []*user.User) {
matchMutex.Lock()
defer matchMutex.Unlock()
var t = param.Type
mt := ""
ruleArr := append(param.Rule, t)
for _, v := range ruleArr {
mt += strconv.Itoa(int(v))
}
fmt.Println("mt:", mt)
if MatchList[mt] == nil {
MatchList[mt] = &MatchItemList{
List: make([]*MatchItem, 0),
}
}
MatchList[mt].List = append(MatchList[mt].List, &MatchItem{
Match: param,
User: muser,
})
var matchLen int
switch mjgame.MsgID(t) {
case mjgame.MsgID_GTYPE_ZheJiang_XiZhou: // 西周
matchLen = 4
case mjgame.MsgID_GTYPE_SiChuan_XueLiu: // 血流
matchLen = 4
case mjgame.MsgID_GTYPE_ZheJiang_XiangShan: // 象山
matchLen = 4
case mjgame.MsgID_GTYPE_SanDizhu:
matchLen = 3
case mjgame.MsgID_GTYPE_SirenDizhu:
matchLen = 4
case mjgame.MsgID_GTYPE_Pinshi:
matchLen = 2 //拼十两个人就可以玩哈
}
fmt.Println("len(MatchList[t].List):", len(MatchList[mt].List))
fmt.Println("matchLen:", matchLen)
if len(MatchList[mt].List) >= matchLen { //可以匹配
tempList := append(MatchList[mt].List[:matchLen])
MatchList[mt].List = append(MatchList[mt].List[matchLen:])
creatRoom := &mjgame.Create_Room{
SID: tempList[0].Match.SID,
Type: tempList[0].Match.Type,
City: tempList[0].Match.City,
PWD: tempList[0].Match.PWD,
Rule: tempList[0].Match.Rule,
}
//创建房间
roomHandle, roomId := CreateLockRoom(creatRoom, tempList[0].User, -1)
if roomId > 0 {
users := make([]*user.User, 0)
for _, v := range tempList {
users = append(users, v.User)
}
//直接这几个玩家请求加入这个房间即可
return roomHandle, users
}
} else if mjgame.MsgID(t) == mjgame.MsgID_GTYPE_SanDizhu { //三人斗地主目前直接给机器人
tempList := append(MatchList[mt].List[:1])
//给这个家伙弄两个ai
for i := 0; i < 2; i++ {
user := user.GetUser(nil)
unionId := util.GetSID()
openid := util.GetSID()
usAi := CreateAiUser(23, 32, "255.255.0.255", nil, unionId, openid, i)
if usAi.Sid == "" {
usAi.Sid = usAi.OpenID
}
user.User = usAi
tempList = append(tempList, &MatchItem{
Match: tempList[0].Match,
User: user,
})
}
MatchList[mt].List = append(MatchList[mt].List[1:])
creatRoom := &mjgame.Create_Room{
SID: tempList[0].Match.SID,
Type: tempList[0].Match.Type,
City: tempList[0].Match.City,
PWD: tempList[0].Match.PWD,
Rule: tempList[0].Match.Rule,
}
//创建房间
roomHandle, roomId := CreateLockRoom(creatRoom, tempList[0].User, -1)
if roomId > 0 {
users := make([]*user.User, 0)
for _, v := range tempList {
users = append(users, v.User)
}
//直接这几个玩家请求加入这个房间即可
return roomHandle, users
}
}
return nil, nil
}
//创建新的用户 ```
func CreateAiUser(GPS_LNG, GPS_LAT float32, ip string, userInfo *sdk.UserInfo, unionID string, openid string, add int) *model.User {
var user model.User
user.Sid = util.GetSID()
user.LastIp = ip
user.Coin = 50000
user.IsRobot = 1
user.Diamond = 1000
user.GPS_LAT = GPS_LNG
user.GPS_LNG = GPS_LAT
if userInfo != nil {
user.NickName = userInfo.Nickname
user.Sex = userInfo.Sex
user.Province = userInfo.Province
user.City = userInfo.City
user.Country = userInfo.Country
user.Icon = userInfo.Headimgurl
} else {
user.NickName = random_name.GetRandomName()
//user.Icon = "icon_" + strconv.Itoa(util.RandInt(0, 5))
user.Icon = ""
user.Sex = 1
}
user.OpenID = openid
user.UnionID = unionID
fmt.Println("chuangjianxinyonghu meiwenti")
//这个就不需要了，机器人嘛
rand.Seed(time.Now().Unix())
user.ID = rand.Intn(100000) + add
// err := model.GetUserModel().Create(&user)
// if err != nil {
// fmt.Println("charushibai::", err.Error())
// }
return &user
}
//查找当前玩家的匹配信息
func GetMatchInfo(muser *user.User) *mjgame.Match_Room {
matchMutex.Lock()
defer matchMutex.Unlock()
for _, v := range MatchList {
for _, v1 := range v.List {
if v1.User.ID == muser.ID {
v1.User = muser
return v1.Match
}
}
}
return nil
}
//将玩家从匹配列表中删除
func DeleMatchFromList(muser *user.User) bool {
matchMutex.Lock()
defer matchMutex.Unlock()
for _, v := range MatchList {
for idx, v1 := range v.List {
if v1.User.ID == muser.ID {
v.List = append(v.List[:idx], v.List[idx+1:]...)
return true
}
}
}
return false
}
// 得到房间
func GetNewRoom(rid int, t int32, user *user.User, rules []int32) interface{} {
var v interface{} = int64(0)
key := strconv.Itoa(int(t))
switch mjgame.MsgID(t) {
case mjgame.MsgID_GTYPE_ZheJiang_XiZhou: // 西周
room := xizhou.RoomXiZhou{}
xizhou.XiZhou_RoomRule.Rules = rules
room.Rules = xizhou.XiZhou_RoomRule
room.RoomBase.InitRoomRule(rules, Config[key], 4)
room.Create(rid, t, user, &room.Rules)
room.CostType = rules[4]
return &room
case mjgame.MsgID_GTYPE_SiChuan_XueLiu: // 血流
room := RoomXueLiu{}
room.Rules = XueLiu_RoomRule
room.Create(rid, t, user, &room.Rules)
room.CostType = rules[4]
return &room
case mjgame.MsgID_GTYPE_ZheJiang_XiangShan: // 象山
room := xiangshan.RoomXiangshan{}
xiangshan.XiangShan_RoomRule.Rules = rules
room.Rules = xiangshan.XiangShan_RoomRule
room.RoomBase.InitRoomRule(rules, Config[key], 4)
room.Create(rid, t, user, &room.Rules)
room.CostType = rules[4]
return &room
case mjgame.MsgID_GTYPE_SanDizhu:
room := ningbo.RoomNingBo{}
ningbo.NingBo_RoomRule.Rules = rules
room.Rules = ningbo.NingBo_RoomRule
room.RoomBase.InitRoomRule(rules, Config[key], 3)
room.Create(rid, t, user, &room.Rules)
room.SubType = rules[3]
room.CostType = rules[4]
return &room
case mjgame.MsgID_GTYPE_SirenDizhu:
room := srddz.RoomSrddz{}
srddz.Srddz_RoomRule.Rules = rules
room.Rules = srddz.Srddz_RoomRule
room.RoomBase.InitRoomRule(rules, Config[key], 4)
room.Create(rid, t, user, &room.Rules)
room.SubType = rules[3]
room.CostType = rules[4]
return &room
case mjgame.MsgID_GTYPE_Pinshi:
room := pinshi.RoomPinshi{}
pinshi.Pinshi_RoomRule.Rules = rules
room.Rules = pinshi.Pinshi_RoomRule
room.RoomBase.InitRoomRule(rules, Config[key], 10)
room.Create(rid, t, user, &room.Rules)
room.SubType = rules[3]
room.CostType = rules[4]
return &room
}
return v
}
// 查询规则存在
func CheckRule(rule int, pRule *[]int) bool {
for _, v := range *pRule {
if v == rule {
return true
}
}
return false
}
//
func WatchRoom() {
for {
select {
case roomId := <-roombase.ChanRoom:
go func() {
fmt.Println("shanchufangjian...0")
time.Sleep(1 * time.Second)
mutex.Lock()
fmt.Println("shanchufangjian...1")
delete(RoomList, roomId)
fmt.Println("shanchufangjian...2")
roombase.Redis_RemovePlayingUser(roomId)
roombase.Redis_RemoveRoom(roomId)
fmt.Println("Room delete ", roomId, RoomList[roomId])
mutex.Unlock()
}()
// mutex.Lock()
// delete(RoomList, roomId)
// roombase.Redis_RemovePlayingUser(roomId)
// roombase.Redis_RemoveRoom(roomId)
// fmt.Println("Room delete ", roomId, RoomList[roomId])
// mutex.Unlock()
}
}
}
//@andy新房间ID
func NewRoomId() int {
mutex.Lock()
defer mutex.Unlock()
roomId := 0
total := len(RoomList)
var tempTime int64
if total > 0 {
for _, v := range RoomList {
if tempTime < v.CreateTime {
tempTime = v.CreateTime
roomId = v.RoomId
}
}
}
return roomId
}
//@andy获取房间
func GetLockRoomHandle(roomId int) (*RoomHandle, bool) {
mutex.Lock()
defer mutex.Unlock()
room, ok := RoomList[roomId]
return room, ok
}
//@andy创建房间
func CreateLockRoom(croom *mjgame.Create_Room, user *user.User, rid int) (*RoomHandle, int) {
mutex.Lock()
defer mutex.Unlock()
var roomId = rid
if rid <= 0 {
for {
roomId = GetNewRoomID()
_, haved := RoomList[roomId]
if !haved {
break
}
}
}
_, ok := RoomDefInfo[croom.Type]
if !ok {
fmt.Println("ddddddddddddddddddddddcaonima")
return nil, -1 // 没有这种房间类型
}
// 创建房间
room := GetNewRoom(roomId, croom.Type, user, croom.Rule)
RoomList[roomId] = &RoomHandle{
RoomId: roomId,
Room: room,
CreateTime: time.Now().Unix(),
GameType: int(croom.Type),
}
return RoomList[roomId], roomId
}
//获取新房间号
func GetNewRoomID() int {
temp := strconv.Itoa(util.RandInt(1, 999999))
mlen := 6 - len(temp)
for i := 0; i < mlen; i++ {
temp += "0"
}
roomId, _ := strconv.Atoi(temp)
return roomId
}
|
<gh_stars>1-10
package com.mc.common.config;
import org.springframework.context.annotation.Bean;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
/**
* [DefaultPasswordConfig 密码工具类]
*
* @author likai
* @version 1.0
* @date 2019/12/11 0011 09:37
* @company Gainet
* @copyright copyright (c) 2019
*/
public class DefaultPasswordConfig {
/**
* 装配BCryptPasswordEncoder用户密码的匹配
* @return
*/
@Bean
public PasswordEncoder passwordEncoder() {
return new BCryptPasswordEncoder();
}
}
|
#!/usr/bin/env bash
#SBATCH --job-name=da-cst-im-roi_cs6-HP-WIDER
#SBATCH -o gypsum/logs/%j_cs6-HP-WIDER.txt
#SBATCH -e gypsum/errs/%j_cs6-HP-WIDER.txt
#SBATCH -p 1080ti-long
#SBATCH --gres=gpu:4
#SBATCH --mem=60000
##SBATCH --cpus-per-task=4
##SBATCH --mem-per-cpu=4096
# starts from WIDER pre-trained model
# trial run: just using CS6 data (imdb merging not done)
python tools/train_net_step.py \
--dataset bdd_peds+HP18k_rainy_any_night \
--cfg configs/baselines/bdd_domain_im.yaml \
--set NUM_GPUS 1 TRAIN.SNAPSHOT_ITERS 5000 \
--iter_size 2 \
--use_tfboard \
#--load_ckpt /mnt/nfs/scratch1/pchakrabarty/ped_models/bdd_peds.pth \
#--load_ckpt Outputs/e2e_faster_rcnn_R-50-C4_1x/Jul30-15-51-27_node097_step/ckpt/model_step79999.pth \
# -- debugging --
# python tools/train_net_step.py \
# --dataset cs6-train-easy-gt-sub+WIDER \
# --cfg configs/cs6/e2e_faster_rcnn_R-50-C4_1x_quick.yaml \
# --load_ckpt Outputs/e2e_faster_rcnn_R-50-C4_1x/Jul30-15-51-27_node097_step/ckpt/model_step79999.pth \
# --iter_size 2 \
# --use_tfboard
|
python3 setup.py install --single-version-externally-managed --record=record.txt # Python command to install the script.
|
<reponame>JustinDFuller/purchase-saving-planner<gh_stars>1-10
import * as uuid from "uuid";
import * as Notifications from "notifications";
import { getterSetters } from "object/getterSetters";
import * as Purchases from "./purchases";
const defaults = {
id: uuid.v4(),
email: "",
saved: 0,
frequency: "Every 2 Weeks",
contributions: 0,
lastPaycheck: new Date(),
purchases: Purchases.New(),
pushNotificationTokens: [],
};
export function New(data = defaults) {
return {
...getterSetters(data, New),
isReady() {
return data.email && data.email !== "";
},
from(user) {
const d = {
...defaults,
...data,
...user,
};
return New({
...d,
lastPaycheck: d.lastPaycheck
? new Date(d.lastPaycheck)
: d.lastPaycheck,
purchases: data.purchases.from(d.purchases),
pushNotificationTokens: d.pushNotificationTokens.map((t) =>
Notifications.New(t)
),
});
},
setLastPaycheck(lastPaycheck) {
return New({
...data,
lastPaycheck: new Date(lastPaycheck + "T00:00:00"),
});
},
addPurchase(purchase) {
return New({
...data,
purchases: data.purchases.addPurchase(purchase),
});
},
setPurchase(purchase) {
return New({
...data,
purchases: data.purchases.setPurchase(purchase),
});
},
lastPaycheckDisplay() {
const t = new Date();
const l = data.lastPaycheck;
if (
l.getYear() === t.getYear() &&
l.getMonth() === t.getMonth() &&
l.getDate() === t.getDate()
) {
return "Today";
}
return l.toLocaleDateString("en-US");
},
purchase(purchase) {
return New({
...data,
saved: data.saved - purchase.price(),
purchases: data.purchases.purchase(purchase),
});
},
undoPurchase(purchase) {
return New({
...data,
saved: data.saved + purchase.price(),
purchases: data.purchases.undoPurchase(purchase),
});
},
remaining() {
return data.saved - data.purchases.total();
},
addPushNotificationTokens(newTokens) {
const found = data.pushNotificationTokens.findIndex(
(t) => t.deviceToken() === newTokens.deviceToken()
);
const pushNotificationTokens =
found > -1
? data.pushNotificationTokens
: [...data.pushNotificationTokens, newTokens];
return New({
...data,
pushNotificationTokens,
});
},
};
}
|
#!/usr/bin/env sh
#
# Ping Identity DevOps - Docker Build Hooks
#
#- This hook runs through the followig phases:
#-
${VERBOSE} && set -x
# shellcheck source=../../pingcommon/hooks/pingcommon.lib.sh
. "${HOOKS_DIR}/pingcommon.lib.sh"
_pinFile="${SECRETS_DIR}/.autogen-truststore.pin"
# _storeFile="${STAGING_DIR}/autogen-truststore"
_storeFile="${AUTOGEN_TRUSTSTORE_FILE}"
ensure_trust_store_present ()
{
test -f "${_pinFile}" || head -c 1024 /dev/urandom | tr -dc 'a-zA-Z0-9-' | cut -c 1-64 > "${_pinFile}"
_storePass="$( cat "${_pinFile}" )"
if ! test -f "${_storeFile}" ;
then
keytool \
-genkey\
-keyalg RSA \
-alias stub \
-keystore "${_storeFile}" \
-storepass "${_storePass}" \
-validity 30 \
-keysize 2048 \
-noprompt \
-dname "CN=ephemeral, OU=Docker, O=PingIdentity Corp., L=Denver, ST=CO, C=US"
keytool \
-delete \
-alias stub \
-keystore "${_storeFile}" \
-storepass "${_storePass}"
fi
}
# this function conveniently allows to trust a remote server
trust_server ()
{
_server="${1}"
# shellcheck disable=SC2039
_alias="$( echo -n ${_server} | tr : _ )_$(date '+%s')"
_certFile="/tmp/${_alias}.cert"
keytool -printcert -sslserver ${_server} -rfc > "${_certFile}"
_certFingerPrint=$( keytool -printcert -file "${_certFile}" | awk '/SHA256:/{print $2}' )
if test -f "${_storeFile}" ;
then
_certificateFound="false"
if keytool -list -keystore "${_storeFile}" -storepass ${_storePass} | awk 'BEGIN{x=1}/SHA-256/ && $4~/'${_certFingerPrint}'/{x=0}END{exit x}' ;
then
_certificateFound="true"
fi
fi
if test "${_certificateFound}" != "true" ;
then
echo "Processinng ${_server} certificate"
_storePass="$( cat "${_pinFile}" )"
keytool -import -file "${_certFile}" -noprompt -alias "${_alias}" -keystore "${_storeFile}" -storepass "${_storePass}"
else
echo "${_server} certificate was NOT added to keystore" >/dev/null
fi
rm "${_certFile}"
}
is_reachable ()
{
if test -n "${1}" ;
then
# shellcheck disable=SC2046
nc -z $( echo "${1}" | tr : " " ) 2>/dev/null 1>/dev/null
return ${?}
else
return 2
fi
}
watch_server ()
{
if test -n "${1}" ;
then
while true ;
do
is_reachable "${1}" && trust_server "${1}"
sleep 113
done
fi
}
if test -n "${AUTOGEN_TRUSTSTORE_ENABLED}" ;
then
ensure_trust_store_present
for server in "pingdirectory:${LDAPS_PORT}" "pingdirectoryproxy:${LDAPS_PORT}" "pingdatasync:${LDAPS_PORT}" "pingdatagovernance:${LDAPS_PORT}" ;
do
sleep 3
watch_server "${server}" &
done
fi |
<gh_stars>0
#! /usr/bin/env python3
# -*-coding:UTF-8 -*-
# @Time : 2019/01/04 16:44:26
# @Author : che
# @Email : <EMAIL>
import getpass
def svc_login(user, passwd):
return True
user = getpass.getuser()
passwd = getpass.getpass()
if svc_login(user, passwd):
print('Yay!')
else:
print('Boo!')
|
'use strict';
// LOWER INCOMPLETE GAMMA SERIES //
/**
* FUNCTION: lower_incomplete_gamma_series( a1, z1 )
* Creates a function to evaluate a series expansion of the incomplete gamma function.
*
* @param {Number} a1 - function parameter
* @param {Number} z1 - function parameter
* @returns {Function} series function
*/
function lower_incomplete_gamma_series( a1, z1 ) {
var a = a1;
var z = z1;
var result = 1;
return function() {
var r = result;
a += 1;
result *= z/a;
return r;
};
} // end FUNCTION lower_incomplete_gamma_series()
// EXPORTS //
module.exports = lower_incomplete_gamma_series;
|
package context
type Config interface {
Get(string) interface{}
Set(string,interface{}) error
}
var dic map[string]interface {}
func Get(key string) interface{} {
return dic[key]
}
func Set(key string,value interface{}) error{
if dic == nil {
dic = make(map[string]interface{})
}
dic[key]=value
return nil
} |
<filename>train.py
import torch
import torch.nn.functional as F
import torch.nn as nn
import numpy as np
import time
from tqdm import tqdm
from graphwriter import *
from utlis import *
from opts import *
import os
import sys
sys.path.append('./pycocoevalcap')
from pycocoevalcap.bleu.bleu import Bleu
from pycocoevalcap.rouge.rouge import Rouge
from pycocoevalcap.meteor.meteor import Meteor
def train_one_epoch(model, dataloader, optimizer, args, epoch):
model.train()
tloss = 0.
tcnt = 0.
st_time = time.time()
with tqdm(dataloader, desc='Train Ep '+str(epoch), mininterval=60) as tq:
for batch in tq:
pred = model(batch)
nll_loss = F.nll_loss(pred.view(-1, pred.shape[-1]), batch['tgt_text'].view(-1), ignore_index=0)
loss = nll_loss
optimizer.zero_grad()
loss.backward()
nn.utils.clip_grad_norm_(model.parameters(), args.clip)
optimizer.step()
loss = loss.item()
if loss!=loss:
raise ValueError('NaN appear')
tloss += loss * len(batch['tgt_text'])
tcnt += len(batch['tgt_text'])
tq.set_postfix({'loss': tloss/tcnt}, refresh=False)
print('Train Ep ', str(epoch), 'AVG Loss ', tloss/tcnt, 'Steps ', tcnt, 'Time ', time.time()-st_time, 'GPU', torch.cuda.max_memory_cached()/1024.0/1024.0/1024.0)
torch.save(model, args.save_model+str(epoch%100))
val_loss = 2**31
def eval_it(model, dataloader, args, epoch):
global val_loss
model.eval()
tloss = 0.
tcnt = 0.
st_time = time.time()
with tqdm(dataloader, desc='Eval Ep '+str(epoch), mininterval=60) as tq:
for batch in tq:
with torch.no_grad():
pred = model(batch)
nll_loss = F.nll_loss(pred.view(-1, pred.shape[-1]), batch['tgt_text'].view(-1), ignore_index=0)
loss = nll_loss
loss = loss.item()
tloss += loss * len(batch['tgt_text'])
tcnt += len(batch['tgt_text'])
tq.set_postfix({'loss': tloss/tcnt}, refresh=False)
print('Eval Ep ', str(epoch), 'AVG Loss ', tloss/tcnt, 'Steps ', tcnt, 'Time ', time.time()-st_time)
if tloss/tcnt < val_loss:
print('Saving best model ', 'Ep ', epoch, ' loss ', tloss/tcnt)
torch.save(model, args.save_model+'best')
val_loss = tloss/tcnt
def test(model, dataloader, args):
scorer = Bleu(4)
m_scorer = Meteor()
r_scorer = Rouge()
hyp = []
ref = []
model.eval()
gold_file = open('tmp_gold.txt', 'w')
pred_file = open('tmp_pred.txt', 'w')
with tqdm(dataloader, desc='Test ', mininterval=1) as tq:
for batch in tq:
with torch.no_grad():
seq = model(batch, beam_size=args.beam_size)
r = write_txt(batch, batch['tgt_text'], gold_file, args)
h = write_txt(batch, seq, pred_file, args)
hyp.extend(h)
ref.extend(r)
hyp = dict(zip(range(len(hyp)), hyp))
ref = dict(zip(range(len(ref)), ref))
print(hyp[0], ref[0])
print('BLEU INP', len(hyp), len(ref))
print('BLEU', scorer.compute_score(ref, hyp)[0])
print('METEOR', m_scorer.compute_score(ref, hyp)[0])
print('ROUGE_L', r_scorer.compute_score(ref, hyp)[0])
gold_file.close()
pred_file.close()
def main(args):
if os.path.exists(args.save_dataset):
train_dataset, valid_dataset, test_dataset = pickle.load(open(args.save_dataset, 'rb'))
else:
train_dataset, valid_dataset, test_dataset = get_datasets(args.fnames, device=args.device, save=args.save_dataset)
args = vocab_config(args, train_dataset.ent_vocab, train_dataset.rel_vocab, train_dataset.text_vocab, train_dataset.ent_text_vocab, train_dataset.title_vocab)
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_sampler = BucketSampler(train_dataset, batch_size=args.batch_size), \
collate_fn=train_dataset.batch_fn)
valid_dataloader = torch.utils.data.DataLoader(valid_dataset, batch_size=args.batch_size, \
shuffle=False, collate_fn=train_dataset.batch_fn)
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=args.batch_size, \
shuffle=False, collate_fn=train_dataset.batch_fn)
model = GraphWriter(args)
model.to(args.device)
if args.test:
model = torch.load(args.save_model)
model.args = args
print(model)
test(model, test_dataloader, args)
else:
optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, weight_decay=args.weight_decay, momentum=0.9)
print(model)
for epoch in range(args.epoch):
train_one_epoch(model, train_dataloader, optimizer, args, epoch)
eval_it(model, valid_dataloader, args, epoch)
if __name__ == '__main__':
args = get_args()
main(args)
|
#!/bin/bash
APPNAME=<%= appName %>
CLIENTSIZE=<%= nginxClientUploadLimit %>
APP_PATH=/opt/$APPNAME
BUNDLE_PATH=$APP_PATH/current
ENV_FILE=$APP_PATH/config/env.list
PORT=<%= port %>
BIND=<%= bind %>
NGINX_PROXY_VERSION="0.8.0"
LETS_ENCRYPT_VERSION="v1.13.1"
APP_IMAGE=<%- imagePrefix %><%= appName.toLowerCase() %>
IMAGE=$APP_IMAGE:latest
VOLUME="--volume=$BUNDLE_PATH:/bundle"
LOCAL_IMAGE=false
<% if (!privateRegistry) { %>
sudo docker image inspect $IMAGE >/dev/null || IMAGE=<%= docker.image %>
if [ $IMAGE == $APP_IMAGE:latest ]; then
VOLUME=""
LOCAL_IMAGE=true
fi
<% } else { %>
VOLUME=""
LOCAL_IMAGE=true
# We want this pull to fail on error since
# otherwise we might try to run an old version of the app
set -e
sudo docker pull $IMAGE
set +e
<% } %>
echo "Image" $IMAGE
echo "Volume" $VOLUME
# We want this message with the errors in stderr when shown to the user.
>&2 echo "Removing docker containers. Errors about nonexistent endpoints and containers are normal.";
# Remove previous version of the app, if exists
sudo docker rm -f $APPNAME
# Remove container network if still exists
sudo docker network disconnect bridge -f $APPNAME
<% for(var network in docker.networks) { %>
sudo docker network disconnect <%= docker.networks[network] %> -f $APPNAME
<% } %>
# Remove frontend container if exists
sudo docker rm -f $APPNAME-frontend
sudo docker network disconnect bridge -f $APPNAME-frontend
# Remove let's encrypt containers if exists
sudo docker rm -f $APPNAME-nginx-letsencrypt
sudo docker network disconnect bridge -f $APPNAME-nginx-letsencrypt
sudo docker rm -f $APPNAME-nginx-proxy
sudo docker network disconnect bridge -f $APPNAME-nginx-proxy
>&2 echo "Finished removing docker containers"
# We don't need to fail the deployment because of a docker hub downtime
if [ $LOCAL_IMAGE == "false" ]; then
set +e
sudo docker pull <%= docker.image %>
echo "Pulled <%= docker.image %>"
set -e
else
set -e
fi
sudo docker run \
-d \
--restart=always \
$VOLUME \
<% if((sslConfig && typeof sslConfig.autogenerate === "object") || (typeof proxyConfig === "object" && !proxyConfig.loadBalancing)) { %> \
--expose=<%= docker.imagePort %> \
<% } else { %> \
--publish=$BIND:$PORT:<%= docker.imagePort %> \
<% } %> \
--hostname="$HOSTNAME-$APPNAME" \
--env-file=$ENV_FILE \
<% if(logConfig && logConfig.driver) { %>--log-driver=<%= logConfig.driver %> <% } %> \
<% for(var option in logConfig.opts) { %>--log-opt <%= option %>=<%= logConfig.opts[option] %> <% } %> \
<% for(var volume in volumes) { %>-v <%= volume %>:<%= volumes[volume] %> <% } %> \
<% for(var args in docker.args) { %> <%- docker.args[args] %> <% } %> \
<% if(sslConfig && typeof sslConfig.autogenerate === "object") { %> \
-e "VIRTUAL_HOST=<%= sslConfig.autogenerate.domains %>" \
-e "LETSENCRYPT_HOST=<%= sslConfig.autogenerate.domains %>" \
-e "LETSENCRYPT_EMAIL=<%= sslConfig.autogenerate.email %>" \
-e "HTTPS_METHOD=noredirect" \
<% } %> \
--name=$APPNAME \
$IMAGE
echo "Ran <%= docker.image %>"
# When using a private docker registry, the cleanup run in
# Prepare Bundle is only done on one server, so we also
# cleanup here so the other servers don't run out of disk space
<% if (privateRegistry) { %>
echo "pruning images"
sudo docker image prune -f || true
<% } %>
if [[ $VOLUME == "" ]]; then
# The app starts much faster when prepare bundle is enabled,
# so we do not need to wait as long
sleep 3s
else
sleep 15s
fi
<% if(typeof sslConfig === "object") { %>
<% if(typeof sslConfig.autogenerate === "object") { %>
echo "Running autogenerate"
# Get the nginx template for nginx-gen
wget https://raw.githubusercontent.com/jwilder/nginx-proxy/master/nginx.tmpl -O /opt/$APPNAME/config/nginx.tmpl
# Update nginx config based on user input or default passed by js
sudo cat <<EOT > /opt/$APPNAME/config/nginx-default.conf
client_max_body_size $CLIENTSIZE;
EOT
# We don't need to fail the deployment because of a docker hub downtime
set +e
sudo docker pull jrcs/letsencrypt-nginx-proxy-companion:$LETS_ENCRYPT_VERSION
sudo docker pull jwilder/nginx-proxy:$NGINX_PROXY_VERSION
set -e
echo "Pulled autogenerate images"
sudo docker run -d -p 80:80 -p 443:443 \
--name $APPNAME-nginx-proxy \
--restart=always \
-e "DEFAULT_HOST=<%= sslConfig.autogenerate.domains.split(',')[0] %>" \
-v /opt/$APPNAME/config/nginx-default.conf:/etc/nginx/conf.d/my_proxy.conf:ro \
-v /opt/$APPNAME/certs:/etc/nginx/certs:ro \
-v /opt/$APPNAME/config/vhost.d:/etc/nginx/vhost.d \
-v /opt/$APPNAME/config/html:/usr/share/nginx/html \
-v /var/run/docker.sock:/tmp/docker.sock:ro \
jwilder/nginx-proxy:$NGINX_PROXY_VERSION
echo "Ran nginx-proxy"
sleep 15s
sudo docker run -d \
--name $APPNAME-nginx-letsencrypt \
--restart=always\
--volumes-from $APPNAME-nginx-proxy \
-v /opt/$APPNAME/certs:/etc/nginx/certs:rw \
-v /var/run/docker.sock:/var/run/docker.sock:ro \
jrcs/letsencrypt-nginx-proxy-companion:$LETS_ENCRYPT_VERSION
echo "Ran jrcs/letsencrypt-nginx-proxy-companion"
<% } else { %>
# We don't need to fail the deployment because of a docker hub downtime
set +e
sudo docker pull <%= docker.imageFrontendServer %>
set -e
sudo docker run \
-d \
--restart=always \
--volume=/opt/$APPNAME/config/bundle.crt:/bundle.crt \
--volume=/opt/$APPNAME/config/private.key:/private.key \
--link=$APPNAME:backend \
--publish=$BIND:<%= sslConfig.port %>:443 \
--name=$APPNAME-frontend \
<%= docker.imageFrontendServer %> /start.sh
<% } %>
<% } %>
<% for(var network in docker.networks) { %>
sudo docker network connect <%= docker.networks[network] %> $APPNAME
<% } %>
|
<filename>src/App.js
import React, { useState, useEffect } from "react";
import CryptoCard from "./components/CryptoCard";
export default function App() {
const [data, setData] = useState(null);
useEffect(() => {
fetch("https://api.coinstats.app/public/v1/coins?skip=0&limit=3")
.then((response) => {
if (!response.ok) {
throw response;
}
return response.json();
})
.then((result) => {
setData(result);
})
.catch((error) => console.error(error));
}, []);
return (
<div className="container">
<div className="row mb-4">
<div className="col-12 text-center page-title">
<h1>Crypto Rankings</h1>
<p>Top three</p>
</div>
</div>
<div className="row">
{data?.coins.map((item) => (
<div key={item.id} className="col-lg-4 col-xs-12 mb-5 crypto-card">
<CryptoCard
key={item.id}
coinID={item.id}
title={item.name}
symbol={item.symbol}
image={item.icon}
price={item.price}
aSupply={item.availableSupply}
tSupply={item.totalSupply}
priceChangeH={item.priceChange1h}
priceChangeD={item.priceChange1d}
priceChangeW={item.priceChange1w}
/>
</div>
))}
</div>
</div>
);
}
|
<gh_stars>0
from typing import List
from pydantic import BaseModel
# 먼 지도
class AreaList(BaseModel):
areaCode: int
lat: float
long: float
businessCount: int
class MapFarSchema(BaseModel):
focusLat: float
focusLong: float
areaList: List[AreaList]
# 가까운 지도
class MapCloseSchema(BaseModel):
name: str
lat: float
long: float
areaCode: int
areaName: str
businessCode: int
businessName: str
|
<filename>src/js/lib/fullImgSroll.js
/**
* Created by Administrator on 2016/6/30.
*/
(function ($){
var FullScroll=function(dom,options){
this.$dom=$(dom);
this.init(options);
};
FullScroll.prototype={
constructor:FullScroll,
index:0,
clearId:null,
defaults:{
time:3000,
showTool:true
},
init:function(options){
var that=this;
$.extend(that,that.defaults,options);
that.scrollWidth=this.$dom.width();
that.renderHtml().initEvents();
return that;
},
renderHtml:function(){
var that=this;
var a=that.$dom.find('a');
that.count= a.length;
var wrapper=$('<div class="scroll-wrapper"></div>');
var liHtml='';
$.each(a,function(i,item){
var html='<a href="'+$(item).attr('href')+'" target="_blank" style="background-image:url('+$(item).find('img').attr('src');
wrapper.append(html+')"></a>');
liHtml+='<li></li>';
});
that.$dom.html(wrapper);
that.$dom.find('a').width(that.scrollWidth);
if(that.count>1){
that.$dom.append('<ul class="controlnav">'+liHtml+'</div>');
var controlNav=that.$dom.find('.controlnav');
controlNav.css({marginLeft:-controlNav.width()})
that.$dom.append('<span class="prevnav" data-key="-1"></span><span class="nextnav" data-key="1"></span>');
controlNav.find('li').eq(0).addClass('active');
that.clearId=window.setTimeout(function(){that._toIndex(1)},that.time);
}
return that;
},
initEvents:function(){
var that=this;
$(window).resize(function () {
var maxWidth=that.$dom.width();
that.scrollWidth=maxWidth;
that.$dom.find('.scroll-wrapper').stop();
that.$dom.find('a').width(that.scrollWidth);
that.$dom.find('.scroll-wrapper').css({ marginLeft:-that.scrollWidth*that.index });
});
that.$dom.on('click','.controlnav li',function(){
var index=$(this).index();
that.$dom.find('.scroll-wrapper').stop();
window.clearTimeout(that.clearId);
that._toIndex(index);
});
that.$dom.on('click','.prevnav,.nextnav',function(){
var currentIndex=that.index;
var nextIndex=that.index+parseInt($(this).attr('data-key'));
nextIndex<0?nextIndex=that.count-1:'';
nextIndex>that.count-1?nextIndex=0:'';
that.$dom.find('.scroll-wrapper').stop();
window.clearTimeout(that.clearId);
that._toIndex(nextIndex);
});
return that;
},
_toIndex:function(index){
//console.log(index);
var that=this;
$.when( that.$dom.find('.scroll-wrapper').animate({ marginLeft:-that.scrollWidth*index }, 'easein' ) ).then( function(){
that.index=index;
that.$dom.find('.controlnav li').removeClass('active').eq(index).addClass('active');
});
that.clearId=window.setTimeout(function(){
if(index+1>=that.count){
that._toIndex(0);
}else{
that._toIndex(index+1);
}
},that.time);
return that;
}
}
$.fn.fullScroll = function (options) {
return this.each(function (key, value) {
var element = $(this);
var nivoslider = new FullScroll(this, options);
});
};
})(jQuery); |
import factory.fuzzy
from factory.django import DjangoModelFactory
from ..cases.factories import CaseFactory
from ..channels.factories import ChannelFactory
from ..generic.factories import (
AbstractTimestampUserFactory,
FuzzyDateTimeFromNow,
FuzzyTrueOrFalse,
)
from ..institutions.factories import InstitutionFactory
from .models import DocumentType, Letter
class DocumentTypeFactory(DjangoModelFactory):
name = factory.Sequence(lambda n: "name-desscription-%04d" % n)
class Meta:
model = DocumentType
class LetterFactory(AbstractTimestampUserFactory, DjangoModelFactory):
final = FuzzyTrueOrFalse()
date = FuzzyDateTimeFromNow(max_days=10)
direction = factory.fuzzy.FuzzyChoice(("IN", "OUT"))
comment = factory.Sequence(lambda n: "letter-comment-%04d" % n)
excerpt = factory.Sequence(lambda n: "letter-excerpt-%04d" % n)
reference_number = factory.Sequence(lambda n: "letter-reference_number-%04d" % n)
case = factory.SubFactory(CaseFactory)
channel = factory.SubFactory(ChannelFactory)
institution = factory.SubFactory(InstitutionFactory)
document_type = factory.SubFactory(DocumentTypeFactory)
class Meta:
model = Letter
|
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import {PropType} from 'protocol';
import {deeplySerializeSelectedProperties} from './state-serializer';
const QUERY_1_1 = [];
const QUERY_1_2 = [
{
name: 'nested',
children: [
{
name: 'arr',
children: [
{
name: 2,
children: [
{
name: 0,
children: [
{
name: 'two',
},
],
},
],
},
],
},
],
},
];
const dir1 = {
one: 1,
nested: {
arr: [
{
obj: 1,
},
2,
[
{
two: 1,
},
],
],
},
};
const dir2 = {
nested: {
arr: [
{
obj: 1,
},
2,
[
{
two: 1,
},
],
],
},
};
describe('deeplySerializeSelectedProperties', () => {
it('should work with empty queries', () => {
const result = deeplySerializeSelectedProperties(dir1, QUERY_1_1);
expect(result).toEqual({
one: {
type: PropType.Number,
expandable: false,
editable: true,
preview: '1',
value: 1,
},
nested: {
type: PropType.Object,
editable: false,
expandable: true,
preview: '{...}',
value: {
arr: {
type: PropType.Array,
expandable: true,
editable: false,
preview: 'Array(3)',
},
},
},
});
});
it('should collect not specified but existing props below level', () => {
const result = deeplySerializeSelectedProperties(dir1, QUERY_1_2);
expect(result).toEqual({
one: {
type: PropType.Number,
expandable: false,
editable: true,
preview: '1',
value: 1,
},
nested: {
type: PropType.Object,
editable: false,
expandable: true,
preview: '{...}',
value: {
arr: {
type: PropType.Array,
editable: false,
expandable: true,
preview: 'Array(3)',
value: [
{
type: PropType.Array,
editable: false,
expandable: true,
preview: 'Array(1)',
value: [
{
type: PropType.Object,
editable: false,
expandable: true,
preview: '{...}',
value: {
two: {
type: PropType.Number,
expandable: false,
editable: true,
preview: '1',
value: 1,
},
},
},
],
},
],
},
},
},
});
});
it('should handle deletions even of the query asks for such props', () => {
const result = deeplySerializeSelectedProperties(dir2, [
{
name: 'one',
children: [],
},
{
name: 'nested',
children: [],
},
]);
expect(result).toEqual({
nested: {
type: PropType.Object,
editable: false,
expandable: true,
preview: '{...}',
value: {
arr: {
type: PropType.Array,
editable: false,
expandable: true,
preview: 'Array(3)',
},
},
},
});
});
it('should work with getters', () => {
const result = deeplySerializeSelectedProperties(
{
get foo(): any {
return {
baz: {
qux: 3,
},
};
},
},
[
{
name: 'foo',
children: [
{
name: 'baz',
children: [],
},
],
},
]);
expect(result).toEqual({
foo: {
type: PropType.Object,
editable: false,
expandable: true,
preview: '{...}',
value: {
baz: {
type: PropType.Object,
editable: false,
expandable: true,
preview: '{...}',
},
},
},
});
});
it('should getters should be readonly', () => {
const result = deeplySerializeSelectedProperties(
{
get foo(): number {
return 42;
},
get bar(): number {
return 42;
},
set bar(val: number) {},
},
[]);
expect(result).toEqual({
foo: {
type: PropType.Number,
expandable: false,
// Not editable because
// we don't have a getter.
editable: false,
preview: '42',
value: 42,
},
bar: {
type: PropType.Number,
expandable: false,
editable: true,
preview: '42',
value: 42,
},
});
});
it('should return the precise path requested', () => {
const result = deeplySerializeSelectedProperties(
{
state: {
nested: {
props: {
foo: 1,
bar: 2,
},
[Symbol(3)](): number {
return 1.618;
},
get foo(): number {
return 42;
},
},
},
},
[
{
name: 'state',
children: [
{
name: 'nested',
children: [
{
name: 'props',
children: [
{
name: 'foo',
children: [],
},
{
name: 'bar',
children: [],
},
],
},
{
name: 'foo',
children: [],
},
],
},
],
},
]);
expect(result).toEqual({
state: {
type: PropType.Object,
editable: false,
expandable: true,
preview: '{...}',
value: {
nested: {
type: PropType.Object,
editable: false,
expandable: true,
preview: '{...}',
value: {
props: {
type: PropType.Object,
editable: false,
expandable: true,
preview: '{...}',
value: {
foo: {
type: PropType.Number,
expandable: false,
editable: true,
preview: '1',
value: 1,
},
bar: {
type: PropType.Number,
expandable: false,
editable: true,
preview: '2',
value: 2,
},
},
},
foo: {
type: PropType.Number,
expandable: false,
editable: false,
preview: '42',
value: 42,
},
},
},
},
},
});
});
it('should not show setters at all when associated getters or values are unavailable', () => {
const result = deeplySerializeSelectedProperties(
{
set foo(_: any) {},
get bar(): number {
return 1;
},
},
[]);
expect(result).toEqual({
foo: {
type: PropType.Undefined,
editable: false,
expandable: false,
preview: '[setter]',
},
bar: {
type: PropType.Number,
editable: false,
expandable: false,
preview: '1',
value: 1,
},
});
});
});
|
<filename>nohttp/src/main/java/io/spring/nohttp/file/HttpReplacerProcessor.java<gh_stars>100-1000
/*
* Copyright 2002-2019 the original author or 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
*
* https://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 io.spring.nohttp.file;
import io.spring.nohttp.HttpMatchResult;
import io.spring.nohttp.HttpReplaceResult;
import io.spring.nohttp.HttpReplacer;
import java.io.File;
import java.util.List;
/**
* @author <NAME>
*/
public class HttpReplacerProcessor extends HttpProcessor {
private final HttpReplacer replacer;
public HttpReplacerProcessor(HttpReplacer replacer) {
if (replacer == null) {
throw new IllegalArgumentException("replacer cannot be null");
}
this.replacer = replacer;
}
@Override
List<HttpMatchResult> processHttpInFile(File file) {
String originalText = FileUtils.readTextFrom(file);
HttpReplaceResult result = this.replacer.replaceHttp(originalText);
if (result.isReplacement()) {
FileUtils.writeTextTo(result.getResult(), file);
}
return result.getMatches();
}
}
|
<reponame>ferki/curator
from .utils import *
def show(object_list):
"""
Helper method called by the CLI.
:arg client: The Elasticsearch client connection
:arg object_list: A list of indices or snapshots to show
:rtype: bool
"""
for obj in ensure_list(object_list):
print('{0}'.format(obj))
return True
|
<filename>test/lib/reportError.spec.js
'use strict'
/* global describe, it */
const expect = require('unexpected').clone()
const proxyquire = require('proxyquire').noPreserveCache()
const caches = require('../../lib/caches')
let lastError
const reportError = proxyquire('../../lib/reportError', {
'./globals': {
atom,
console: {
error (err) {
lastError = err
}
}
}
})
describe('lib/reportError', () => {
it('should add a notification', () => {
atom.notifications._errors = []
reportError(new Error('This is the message'))
expect(atom.notifications._errors, 'to have length', 1)
const [ notification ] = atom.notifications._errors
expect(notification, 'to satisfy', {
message: 'Standard Engine: An error occurred',
options: {
description: 'This is the message',
dismissable: true
}
})
})
it('should write to the console', () => {
const expected = new Error('This is the message')
reportError(expected)
expect(lastError, 'to be', expected)
lastError = null
reportError(expected)
expect(lastError, 'to be', expected)
})
it('should not add duplicate notifications, based on message', () => {
atom.notifications._errors = []
caches.clearAll()
reportError(new Error('This is the message'))
expect(atom.notifications._errors, 'to have length', 1)
})
it('should add duplicate notifications once the previous one has been dismissed', () => {
atom.notifications._errors = []
caches.clearAll()
reportError(new Error('This is the message'))
expect(atom.notifications._errors, 'to have length', 1)
atom.notifications._errors[0]._dismiss()
reportError(new Error('This is the message'))
expect(atom.notifications._errors, 'to have length', 2)
})
it('should add duplicate notifications after caches have been cleared', () => {
atom.notifications._errors = []
caches.clearAll()
reportError(new Error('This is the message'))
expect(atom.notifications._errors, 'to have length', 1)
caches.clearAll()
reportError(new Error('This is the message'))
expect(atom.notifications._errors, 'to have length', 2)
})
})
|
#!/bin/bash
while getopts :i:o:d: flag; do
case $flag in
i) input=$OPTARG;;
o) out_dir=$OPTARG;;
d) home_dir=$OPTARG;;
esac
done
#create output directory
mkdir -p $out_dir/mlplasmids_output
#clone mlplasmids
mkdir -p $home_dir/tools
if [[ ! -d $home_dir/tools/mlplasmids ]]; then
echo "Cloning mlplasmids into tools..."
git clone https://gitlab.com/sirarredondo/mlplasmids.git $home_dir/tools
else
echo "Found mlplasmids installation."
fi
run_mlplasmids(){
input=$1
out_dir=$2
#run mlplasmids on input file
echo "Running mlplasmids..."
name=$(basename $input .fasta)
Rscript $home_dir/tools/mlplasmids/scripts/run_mlplasmids.R $input ${out_dir}/mlplasmids_output/${name}.tsv 0.5 'Escherichia coli'
}
run_mlplasmids $input $out_dir
|
<filename>data-structures/src/main/java/com/github/bael/csprogram/AnalyzeEqualsViolationDemo.java
package com.github.bael.csprogram;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;
/**
* Проверка нарушения условия равенства переменных
*/
public class AnalyzeEqualsViolationDemo {
public static void main(String[] args) throws FileNotFoundException {
String fileName = "src/main/resources/equals_input.txt";
Scanner sc = new Scanner(new File(fileName));
// Scanner sc = new Scanner(System.in);
new AnalyzeEqualsViolationDemo().runDemo(sc);
}
private void runDemo(Scanner sc) {
int varCount = sc.nextInt();
int eqCount = sc.nextInt();
int notEqCount = sc.nextInt();
UnionFind simulation = new UnionFind(varCount);
for (int i = 0; i < eqCount; i++) {
simulation.union(sc.nextInt() - 1, sc.nextInt() - 1);
}
int areEquals = 1;
for (int i = 0; i < notEqCount; i++) {
int l = sc.nextInt();
int r = sc.nextInt();
if (simulation.areInSameSet(l - 1, r - 1)) {
areEquals = 0;
}
}
System.out.println(areEquals);
}
private static class UnionFind {
int[] parent;
int[] rank;
public UnionFind(int varsCount) {
parent = new int[varsCount];
rank = new int[varsCount];
for (int i = 0; i < parent.length; i++) {
parent[i] = i;
}
}
int find(int i) {
if (i != parent[i]) {
parent[i] = find(parent[i]);
}
return parent[i];
}
boolean areInSameSet(int i, int j) {
return find(i) == find(j);
}
void union(int i, int j) {
int iRoot = find(i);
int jRoot = find(j);
if (iRoot == jRoot) {
return;
}
// большое дерево поглощает маленькое
if (rank[iRoot] > rank[jRoot]) {
parent[jRoot] = iRoot;
} else {
parent[iRoot] = jRoot;
if (rank[iRoot] == rank[jRoot]) {
rank[jRoot] += 1;
}
}
}
}
}
|
// @flow
import * as React from 'react';
import {
MosaicWindow as RMMosaicWindow,
MosaicWithoutDragDropContext,
getLeaves,
} from 'react-mosaic-component';
import CloseButton from './CloseButton';
import ThemeConsumer from '../Theme/ThemeConsumer';
// EditorMosaic default styling:
import 'react-mosaic-component/react-mosaic-component.css';
import './style.css';
export type Editor = {|
type: 'primary' | 'secondary',
renderEditor: () => React.Node,
noTitleBar?: boolean,
title?: React.Node,
toolbarControls?: Array<React.Node>,
|};
type MosaicNode =
| {|
direction: 'row' | 'column',
splitPercentage: number,
first: ?MosaicNode,
second: ?MosaicNode,
|}
| string;
// Add a node (an editor) in the mosaic.
const addNode = (
currentNode: ?MosaicNode,
newNode: MosaicNode | string,
position: 'start' | 'end',
splitPercentage: number,
direction: 'row' | 'column' = 'row'
): MosaicNode => {
if (!currentNode) return newNode;
// Add the new node inside the current node...
if (typeof currentNode !== 'string') {
if (
position === 'end' &&
currentNode.second &&
typeof currentNode.second !== 'string'
) {
return {
...currentNode,
second: addNode(
currentNode.second,
newNode,
position,
splitPercentage,
direction
),
};
} else if (
position === 'start' &&
currentNode.first &&
typeof currentNode.first !== 'string'
) {
return {
...currentNode,
first: addNode(
currentNode.first,
newNode,
position,
splitPercentage,
direction
),
};
}
}
// Or add the node here.
return {
direction,
first: position === 'end' ? currentNode : newNode,
second: position === 'end' ? newNode : currentNode,
splitPercentage,
};
};
// Replace a node (an editor) by another.
const replaceNode = (
currentNode: ?MosaicNode,
oldNode: ?MosaicNode,
newNode: ?MosaicNode
): ?MosaicNode => {
if (!currentNode) {
return currentNode;
} else if (typeof currentNode === 'string') {
if (currentNode === oldNode) return newNode;
return currentNode;
} else {
if (currentNode === oldNode) return newNode;
return {
...currentNode,
first: replaceNode(currentNode.first, oldNode, newNode),
second: replaceNode(currentNode.second, oldNode, newNode),
};
}
};
const defaultToolbarControls = [<CloseButton key="close" />];
const renderMosaicWindowPreview = props => (
<div className="mosaic-preview">
<div className="mosaic-window-toolbar">
<div className="mosaic-window-title">{props.title}</div>
</div>
<div className="mosaic-window-body" />
</div>
);
/**
* A window that can be used in a EditorMosaic, with a close button
* by default in the toolbarControls and a preview when the window is
* dragged.
*/
const MosaicWindow = (props: any) => (
<RMMosaicWindow
{...props}
toolbarControls={props.toolbarControls || defaultToolbarControls}
renderPreview={renderMosaicWindowPreview}
/>
);
type Props = {|
initialNodes: MosaicNode,
editors: {
[string]: Editor,
},
limitToOneSecondaryEditor?: boolean,
|};
type State = {|
mosaicNode: ?MosaicNode,
|};
/**
* @class EditorMosaic
*
* Can be used to create a mosaic of resizable editors.
* Must be used inside a component wrapped in a DragDropContext.
*/
export default class EditorMosaic extends React.Component<Props, State> {
state = {
mosaicNode: this.props.initialNodes,
};
openEditor = (
editorName: string,
position: 'start' | 'end',
splitPercentage: number
) => {
const { editors, limitToOneSecondaryEditor } = this.props;
const editor = this.props.editors[editorName];
if (!editor) return false;
const openedEditorNames = getLeaves(this.state.mosaicNode);
if (openedEditorNames.indexOf(editorName) !== -1) {
return false;
}
if (limitToOneSecondaryEditor && editor.type === 'secondary') {
// Replace the existing secondary editor, if any.
const secondaryEditorName = openedEditorNames.find(
editorName => editors[editorName].type === 'secondary'
);
if (secondaryEditorName) {
this.setState({
mosaicNode: replaceNode(
this.state.mosaicNode,
secondaryEditorName,
editorName
),
});
return true;
}
}
// Open a new editor at the indicated position
this.setState({
mosaicNode: addNode(
this.state.mosaicNode,
editorName,
position,
splitPercentage
),
});
return true;
};
_onChange = (mosaicNode: MosaicNode) => this.setState({ mosaicNode });
render() {
const { editors } = this.props;
return (
<ThemeConsumer>
{muiTheme => (
<MosaicWithoutDragDropContext
className={`${
muiTheme.mosaicRootClassName
} mosaic-blueprint-theme mosaic-gd-theme`}
renderTile={(editorName: string, path: string) => {
const editor = editors[editorName];
if (!editor) {
console.error(
'Trying to render un unknown editor: ' + editorName
);
return null;
}
if (editor.noTitleBar) {
return editor.renderEditor();
}
return (
<MosaicWindow
path={path}
title={editor.title}
toolbarControls={editor.toolbarControls}
>
{editor.renderEditor()}
</MosaicWindow>
);
}}
value={this.state.mosaicNode}
onChange={this._onChange}
/>
)}
</ThemeConsumer>
);
}
}
|
#! /bin/bash
../src/qbsolv -i qubos/factoring.qubo -m -T 21 $1
../src/qbsolv -i qubos/factoring.qubo -m -T 21 -r 98796 $1
../src/qbsolv -i qubos/factoring.qubo -m -T 21 -r 12345678 $1
|
<reponame>Dnpypy/java-oop
package academy.devonline.java.home_section001_classes.dyna_array;
public class HomeDynaArrayVer2 {
int[] result = new int[5];
int count;
public int[] getResult() {
return result;
}
public void setResult(int[] result) {
this.result = result;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
}
|
/**
* Creates different opacity variants for provided color
*
* @param color CSS Variable name without double dash
*/
const withOpacity = (color) => {
return Array.from({ length: 9 }).reduce(
(prev, _cur, i) => ({
...prev,
[(i + 1) * 10]: `var(--${color}-${(i + 1) * 10})`,
}),
{}
);
};
module.exports = {
mode: process.env.NODE_ENV && 'jit',
purge: ['./src/**/*.{js,ts,jsx,tsx}'],
darkMode: false,
theme: {
fontSize: {
xs: '0.75rem',
sm: '0.875rem',
base: '1rem',
lg: '1.125rem',
xl: '1.25rem',
'2xl': '1.5rem',
'3xl': '1.875rem',
'4xl': '2.25rem',
'5xl': '3rem',
'6xl': '4rem',
},
extend: {
inset: {
'full+2': `calc(100% + 0.5rem)`,
},
// Inset borders using to ensure that component have same dimensions
boxShadow: {
'border-blue': `inset 0 0 0 2px var(--blue)`,
'border-darkblue': `inset 0 0 0 2px var(--darkblue)`,
'border-red': `inset 0 0 0 2px var(--red)`,
'border-gray': `inset 0 0 0 2px var(--gray)`,
'border-lightgray': `inset 0 0 0 2px var(--lightgray)`,
},
outline: {
blue: '2px solid var(--blue)',
},
keyframes: {
shine: {
'0%': {
backgroundPosition: 0,
backgroundImage:
'linear-gradient(90deg, #dddddd 0px, #e8e8e8 40px, #dddddd 80px)',
backgroundSize: '400px',
},
'100%': {
backgroundPosition: '400px',
backgroundImage:
'linear-gradient(90deg, #dddddd 0px, #e8e8e8 40px, #dddddd 80px)',
backgroundSize: '400px',
},
},
},
animation: {
shine: 'shine 2.4s infinite linear',
},
colors: {
blue: {
DEFAULT: `var(--blue)`,
...withOpacity('blue'),
},
darkblue: {
DEFAULT: 'var(--darkblue)',
},
dark: {
DEFAULT: 'var(--dark)',
...withOpacity('dark'),
},
violet: {
DEFAULT: 'var(--violet)',
...withOpacity('violet'),
},
red: {
DEFAULT: 'var(--red)',
},
green: {
DEFAULT: 'var(--green)',
},
gray: 'var(--gray)',
lightgray: `var(--lightgray)`,
darkgray: 'var(--darkgray)',
control: `var(--control)`,
overlay: `rgba(0,0,0, 0.5)`,
},
},
},
variants: {},
plugins: [],
};
|
#! /bin/sh
# This file can be modified by user to provide local path or afs path to
# different platofrm or version of HepMC, Pythia8, MC-Tester and ROOT.
# Safeguard test if running with /afs paths.
if test ! -d /afs/cern.ch/sw/lcg; then
echo ""
echo "This script is for use on CERN server only."
echo ""
exit 0
fi
# Prevents user to modify these paths by using e.g.
# ./configure --with-HepMC=<path>
export AFS_PATHS=yes
export HEPMCLOCATION=/afs/cern.ch/sw/lcg/external/HepMC/2.03.11/slc4_amd64_gcc34
export PYTHIALOCATION=/afs/cern.ch/sw/lcg/external/MCGenerators/pythia8/135/slc4_amd64_gcc34
export TAUOLALOCATION=/afs/cern.ch/sw/lcg/external/MCGenerators/tauola++/1.0.2a/slc4_amd64_gcc34
export MCTESTERLOCATION=/afs/cern.ch/sw/lcg/external/MCGenerators/mctester/1.24/slc4_amd64_gcc34
export PYTHIA8DATA=$PYTHIALOCATION/xmldoc
export PATH=/afs/cern.ch/sw/lcg/app/releases/ROOT/5.22.00/slc4_amd64_gcc34/root/bin:$PATH
ROOTLIBPATH=`root-config --libdir`
HERE=`(cd .. && pwd)`
export LD_LIBRARY_PATH=$HERE/lib:$ROOTLIBPATH:$HEPMCLOCATION/lib:$MCTESTERLOCATION/lib:$PYTHIALOCATION/lib:$TAUOLALOCATION/lib:$LD_LIBRARY_PATH
echo ""
echo "Paths for HepMC, Pythia8, MC-Tester and ROOT set to AFS software"
echo "WARNING: As of today (30 Oct 2010) MC-TESTER 1.24 is available on AFS."
echo " Note, however, that AFS path contains separate path for files"
echo " needed for analysis, therefore only generation step can be"
echo " performed. Analysis step used by advanced tests"
echo " must be done manualy."
echo ""
|
#!/bin/sh
tcpdump -x -vvv -r ping.pcap | less
|
<reponame>neoguru/axboot-origin<filename>ax-boot-admin/src/main/java/com/chequer/axboot/admin/domain/sample/parent/ParentSample.java<gh_stars>100-1000
package com.chequer.axboot.admin.domain.sample.parent;
import com.chequer.axboot.admin.domain.SimpleJpaModel;
import com.chequer.axboot.core.annotations.ColumnPosition;
import lombok.Getter;
import lombok.Setter;
import org.hibernate.annotations.DynamicInsert;
import org.hibernate.annotations.DynamicUpdate;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
@Setter
@Getter
@DynamicInsert
@DynamicUpdate
@Entity
@Table(name = "PARENT_SAMPLE")
public class ParentSample extends SimpleJpaModel<String> {
@Id
@Column(name = "SAMPLE_KEY")
@ColumnPosition(1)
private String key;
@Column(name = "SAMPLE_VALUE")
@ColumnPosition(2)
private String value;
@Column(name = "ETC1")
@ColumnPosition(3)
private String etc1;
@Column(name = "ETC2")
@ColumnPosition(4)
private String etc2;
@Column(name = "ETC3")
@ColumnPosition(5)
private String etc3;
@Column(name = "ETC4")
@ColumnPosition(6)
private String etc4;
@Override
public String getId() {
return key;
}
}
|
/*
* Copyright [2018] [<NAME>]
*
* 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 org.jacpfx.vxms.spring;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.DeploymentOptions;
import io.vertx.core.Future;
import io.vertx.core.Vertx;
import io.vertx.core.json.JsonObject;
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import org.jacpfx.vertx.spring.SpringVerticle;
import org.jacpfx.vertx.spring.SpringVerticleFactory;
import org.jacpfx.vxms.common.ServiceEndpoint;
import org.jacpfx.vxms.rest.annotation.OnRestError;
import org.jacpfx.vxms.rest.response.RestHandler;
import org.jacpfx.vxms.services.VxmsEndpoint;
import org.jacpfx.vxms.spring.beans.HelloWorldBean;
import org.jacpfx.vxms.spring.configuration.SpringConfig;
/**
* Created by <NAME> on 25.01.16.
*/
@ServiceEndpoint(port = 9090)
@SpringVerticle(springConfig = SpringConfig.class)
public class SimpleSpringRESTStaticInit extends AbstractVerticle {
public void start(Future<Void> startFuture) {
SpringVerticleFactory.initSpring(this);
VxmsEndpoint.start(startFuture,this);
}
@Inject
public HelloWorldBean bean;
@Path("/helloGET")
@GET
public void simpleRESTHello(RestHandler handler) {
handler.response().blocking().stringResponse(() -> bean.sayHallo()+" ..... 1").execute();
}
@Path("/helloGET/:name")
@GET
public void simpleRESTHelloWithParameter(RestHandler handler) {
handler.response().blocking().stringResponse(() -> {
final String name = handler.request().param("name");
return bean.sayHallo(name);
}).execute();
}
@Path("/simpleExceptionHandling/:name")
@GET
public void simpleExceptionHandling(RestHandler handler) {
handler.response().blocking().stringResponse(() -> bean.seyHelloWithException()).execute();
}
@OnRestError("/simpleExceptionHandling/:name")
@GET
public void simpleExceptionHandlingOnError(Throwable t, RestHandler handler) {
handler.response().stringResponse((future) -> future.complete("Hi "+handler.request().param("name")+" ::"+t.getMessage())).execute();
}
public static void main(String[] args) {
DeploymentOptions options = new DeploymentOptions();
Vertx.vertx().deployVerticle(SimpleSpringRESTStaticInit.class.getName(), options, handler -> {
if(handler.succeeded()) {
System.out.println("STATIC ready");
System.exit(0);
}
});
}
}
|
<gh_stars>1-10
require 'spec_helper'
describe HTTP::Response do
describe 'headers' do
let(:body) { double(:body) }
let(:headers) { {'Content-Type' => 'text/plain'} }
subject(:response) { HTTP::Response.new(200, '1.1', headers, body) }
it 'exposes header fields for easy access' do
expect(response['Content-Type']).to eq('text/plain')
end
it 'provides a #headers accessor too' do
expect(response.headers).to eq('Content-Type' => 'text/plain')
end
context 'with duplicate header keys (mixed case)' do
let(:headers) { {'Set-Cookie' => 'a=1;', 'set-cookie' => 'b=2;'} }
it 'groups values into Array' do
expect(response['Set-Cookie']).to eq(['a=1;', 'b=2;'])
end
end
end
describe '#[]=' do
let(:body) { double(:body) }
let(:response) { HTTP::Response.new(200, '1.1', {}, body) }
it 'normalizes header name' do
response['set-cookie'] = 'foo=bar;'
expect(response.headers).to eq('Set-Cookie' => 'foo=bar;')
end
it 'groups duplicate header values into Arrays' do
response['set-cookie'] = 'a=b;'
response['set-cookie'] = 'c=d;'
response['set-cookie'] = 'e=f;'
expect(response.headers).to eq('Set-Cookie' => ['a=b;', 'c=d;', 'e=f;'])
end
it 'respects if additional value is Array' do
response['set-cookie'] = 'a=b;'
response['set-cookie'] = ['c=d;', 'e=f;']
expect(response.headers).to eq('Set-Cookie' => ['a=b;', 'c=d;', 'e=f;'])
end
end
describe 'to_a' do
let(:body) { 'Hello world' }
let(:content_type) { 'text/plain' }
subject { HTTP::Response.new(200, '1.1', {'Content-Type' => content_type}, body) }
it 'returns a Rack-like array' do
expect(subject.to_a).to eq([200, {'Content-Type' => content_type}, body])
end
end
describe 'mime_type' do
subject { HTTP::Response.new(200, '1.1', headers, '').mime_type }
context 'without Content-Type header' do
let(:headers) { {} }
it { should be_nil }
end
context 'with Content-Type: text/html' do
let(:headers) { {'Content-Type' => 'text/html'} }
it { should eq 'text/html' }
end
context 'with Content-Type: text/html; charset=utf-8' do
let(:headers) { {'Content-Type' => 'text/html; charset=utf-8'} }
it { should eq 'text/html' }
end
end
describe 'charset' do
subject { HTTP::Response.new(200, '1.1', headers, '').charset }
context 'without Content-Type header' do
let(:headers) { {} }
it { should be_nil }
end
context 'with Content-Type: text/html' do
let(:headers) { {'Content-Type' => 'text/html'} }
it { should be_nil }
end
context 'with Content-Type: text/html; charset=utf-8' do
let(:headers) { {'Content-Type' => 'text/html; charset=utf-8'} }
it { should eq 'utf-8' }
end
end
end
|
# Load data
import pandas as pd
df = pd.read_csv('data.csv')
# Extract features and target
X = df.drop('price', axis=1).values
y = df['price'].values
# Split into train and test
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Train machine learning model
from sklearn.linear_model import LinearRegression
regressor = LinearRegression()
regressor.fit(X_train, y_train)
# Generate predictions
y_pred = regressor.predict(X_test) |
jQuery('.numbersOnly').keyup(function () {this.value = this.value.replace(/[^0-9\.]/g, '');});
$(document).ready(function(){
$('.datepickerr').datepicker({"setDate": new Date(),"autoclose": true,"format": "dd/mm/yyyy",todayHighlight: true});
setTimeout(function(){ $("#flashmsg").hide(); }, 7000);
$("#chk_secondaryTransport").change(function () {
if ($("#chk_secondaryTransport").is(':checked')) {
$("#div_SecondaryTr").css("display", "block");
} else {
$("#div_SecondaryTr").css("display", "none");
}
});
var TDocID = $("#hdn_param").val();
if (TDocID !== "") {
modifyTransEntry(TDocID);
}
});
function getVehicleNo(lnk) {
if (lnk == 1) {
var TransName = $("#drp_trans_name_1").val();
} else {
var TransName = $("#drp_trans_name_2").val();
}
$.ajax({
type: "POST",
async: false,
url: surl+"Transporter/getVehicleNo_show",
data: {TransName:TransName},
beforeSend: function () {
$.blockUI();
},
complete: function () {
$.unblockUI();
},
success: function (res) {
var data = jQuery.parseJSON(res);
if (lnk == 1) {
$("#drp_vehicleno_1").empty();
$("#drp_vehicleno_1").append('<option value="">---Select Vehicle Number---</option>');
for (var i = 0; i < data.length; i++) {
$("#drp_vehicleno_1").append("<option value='"+ data[i].Id +"'>"+ data[i].Vechile_no +"</option>");
}
} else {
for (var i = 0; i < data.length; i++) {
$("#drp_vehicleno_2").append("<option value='"+ data[i].Id +"'>"+ data[i].Vechile_no +"</option>");
}
}
},
error: function(res) {
$.unblockUI();
alert("Error in getVehicleNo_show("+ lnk +")-> " + res.responseText);
}
});
}
function getInvData() {
var FromDate = $('#txt_fdate').val();
if (FromDate !== "") {
var arr = FromDate.split('/');
var FromDate = arr[2] + '-' + arr[1] + '-' + arr[0];
}
var ToDate = $('#txt_tdate').val();
if (ToDate !== "") {
var arr = ToDate.split('/');
var ToDate = arr[2] + '-' + arr[1] + '-' + arr[0];
}
$.ajax({
type: "POST",
url: surl+"Transporter/getInvData_show",
data: {FromDate:FromDate,ToDate:ToDate},
beforeSend: function () {
$("#tbody_pop_invlist").empty();
$.blockUI();
},
complete: function () {
$.unblockUI();
},
success: function (res) {
var data = jQuery.parseJSON(res);
for (var i = 0; i < data.length; i++) {
$('#tbody_pop_invlist').append("<tr>\n\
<td style='text-align:center;'><input type='checkbox' name='chk_newpop_all[" + i + "]' id='chk_newpop_all[" + i + "]'></td>\n\
<td>\n\
<input type='hidden' name='hdn_newpop_docid[" + i + "]' id='hdn_newpop_docid[" + i + "]' value=" + data[i].Docid + ">\n\
" + data[i].Invno + "</td>\n\
<td>" + data[i].InvDate + "</td>\n\
<td>" + data[i].Inv_amt + "</td>\n\
<td>" + data[i].companyname + "</td>\n\
</tr>");
}
$("#myModalSelectInvoice").modal("toggle");
},
error: function(res) {
$.unblockUI();
alert("Error in getInvData_show()-> " + res.responseText);
}
});
}
function selected_Invoices() {
var string = "";
for (var i = 0; i < $('#tbody_pop_invlist tr').length; i++) {
if ($('#chk_newpop_all\\['+ i +'\\]').is(":checked") == true) {
var clientid = $('#hdn_newpop_docid\\['+ i +'\\]').val();
console.log(i + ": " +clientid);
string += "('" + clientid + "'),";
}
}
var strdata = string.substring(0, string.length - 1);
if (strdata != '') {
$.ajax({
type: "POST",
url: surl+"Transporter/selected_Invoices_show",
data: {strdata:strdata},
beforeSend: function () {
// $("#tbody_details").empty();
$.blockUI();
},
complete: function () {
$.unblockUI();
},
success: function (res) {
var main = jQuery.parseJSON(res);
var tbody_len = $('#tbody_details tr').length;
if (tbody_len == '' && tbody_len == 0) {
var b = 1;
} else {
var b = parseInt(tbody_len) + parseInt(1);
}
for (var i = 0; i < main.length; i++) {
$('#tbody_details').append("<tr>\n\
<td>\n\
<input type='hidden' name='hdn_detination[" + b + "]' id='hdn_detination[" + b + "]' value='" + main[i].Transportationper + "'>\n\
<input type='hidden' name='hdn_TDocid[" + b + "]' id='hdn_TDocid[" + b + "]' >\n\
<input type='hidden' name='hdn_TDetailid[" + b + "]' id='hdn_TDetailid[" + b + "]' >\n\
<input type='hidden' name='hdn_docid[" + b + "]' id='hdn_docid[" + b + "]' value='" + main[i].Docid + "'>\n\
" + main[i].Invno + "\n\
</td>\n\
<td>" + main[i].InvDate + "</td>\n\
<td><input type='text' value='" + main[i].companyname + "' style='background-color:transparent;border: none;width:100%;' readonly></td>\n\
<td><input type='text' value='" + main[i].shipadd + "' style='background-color:transparent;border: none;width:100%;' readonly></td>\n\
<td>\n\
<input type='hidden' name='hdn_InvoiceAmount[" + b + "]' id='hdn_InvoiceAmount[" + b + "]' value='" + main[i].Inv_amt + "'>\n\
" + main[i].Inv_amt + "\n\
</td>\n\
<td>\n\
<input type='hidden' name='hdn_frieght_primary[" + b + "]' id='hdn_frieght_primary[" + b + "]'>\n\
<input type='text' name='txt_totalcharge[" + b + "]' id='txt_totalcharge[" + b + "]' value='' readonly class='form-control controlmy'>\n\
</td>\n\
<td>\n\
<input type='hidden' name='hdn_hamali_primary[" + b + "]' id='hdn_hamali_primary[" + b + "]'>\n\
<input type='text' name='txt_HamaliCharges[" + b + "]' id='txt_HamaliCharges[" + b + "]' value='' readonly class='form-control controlmy'>\n\
</td>\n\
<td>\n\
<input type='hidden' name='hdn_detiation_primary[" + b + "]' id='hdn_detiation_primary[" + b + "]'>\n\
<input type='text' name='txt_detiationcharge[" + b + "]' id='txt_detiationcharge[" + b + "]' value='' readonly class='form-control controlmy'>\n\
</td>\n\
<td>\n\
<input type='text' name='txt_fright[" + b + "]' id='txt_fright[" + b + "]' value='" + main[i].Freight + "' readonly class='form-control controlmy'>\n\
</td>\n\
<td style='text-align:center;'><input type='checkbox' name='chk_selected[" + b + "]' id='chk_selected[" + b + "]' onclick='return hcharges();' checked></td>\n\
<td><label id='lbl_cal" + b + "'></label></td>\n\
<td style='text-align:center;'><input type='checkbox' id='chk_secondary[" + b + "]' name='chk_secondary[" + b + "]' onclick='return costvechile();'></td>\n\
</tr>");
b++;
}
costvechile();
$("#myModalSelectInvoice").modal("toggle");
},
error: function(res) {
$.unblockUI();
alert("Error in selected_Invoices_show()-> " + res.responseText);
}
});
}
}
function costvechile() {
var txt_costvechile = $('#txt_trans_cost_1').val();
var txt_hcharge = $('#txt_hamali_ch_1').val();
var txt_detinationchr = $('#txt_detenation_ch_1').val();
var tbody_detial = $('#tbody_details tr').length;
var totalamount = 0;
for (var i = 1; i <= tbody_detial; i++) {
var amount = $("#hdn_InvoiceAmount\\[" + i + "\\]").val();
totalamount += parseFloat(amount);
}
var totalamountaas = totalamount;
for (var i = 1; i <= tbody_detial; i++) {
var amoutn = $("#hdn_InvoiceAmount\\[" + i + "\\]").val();
var frigth = (parseFloat(txt_costvechile) * parseFloat(amoutn)) / parseFloat(totalamountaas);
var hamout_val = (parseFloat(txt_hcharge) * parseFloat(amoutn)) / parseFloat(totalamountaas);
var hdn_detination = $("#hdn_detination\\[" + i + "\\]").val();
var detetaioniomamout_val = (parseFloat(txt_detinationchr) * parseFloat(amoutn)) / parseFloat(totalamountaas);
var Actualtransper = (parseFloat(frigth) / parseFloat(amoutn)) * 100;
// var clienttranspr = $("input[type='hidden'][name='hdn_detination[" + i + "\\]']").val();
var Actualtransperval = Actualtransper.toFixed(2);
var lblcalval = (parseFloat(hdn_detination) * parseFloat(amoutn)) / parseFloat(100);
var lblcal = lblcalval.toFixed(2);
var frigthval1 = frigth.toFixed(0);
var hamout_val1 = hamout_val.toFixed(0);
var detetaioniom_val = detetaioniomamout_val.toFixed(0);
if (isNaN(frigthval1)) {
frigthval1 = 0;
}
if (isNaN(hamout_val1)) {
hamout_val1 = 0;
}
if (isNaN(detetaioniom_val)) {
detetaioniom_val = 0;
}
$("#hdn_frieght_primary\\[" + i + "\\]").val(frigthval1);
$("#txt_totalcharge\\[" + i + "\\]").val(frigthval1);
$("#hdn_hamali_primary\\[" + i + "\\]").val(hamout_val1);
$("#txt_HamaliCharges\\[" + i + "\\]").val(hamout_val1);
$("#hdn_detiation_primary\\[" + i + "\\]").val(detetaioniom_val);
$("#txt_detiationcharge\\[" + i + "\\]").val(detetaioniom_val);
$('#lbl_cal' + i).text(lblcal);
}
hcharges();
}
function hcharges() {
var txt_costvechile = $('#txt_trans_cost_1').val();
var txt_hcharge = $('#txt_hamali_ch_1').val();
var txt_detinationchr = $('#txt_detenation_ch_1').val();
var tbody_detial = $('#tbody_details tr').length;
var totalamout_vechile = 0;
var totalamout_vechile1 = 0;
var totalamount = 0;
var totalamount1 = 0;
for (var i = 1; i <= tbody_detial; i++) {
var checkall = $("#chk_selected\\[" + i + "\\]").is(":checked");
if (checkall == true) {
var amount = $("#hdn_InvoiceAmount\\[" + i + "\\]").val();
totalamount += parseFloat(amount);
}
var amount1 = $("#hdn_InvoiceAmount\\[" + i + "\\]").val();
totalamount1 += parseFloat(amount1);
}
var totalamountaas = totalamount;
var k = 1;
for (var i = 1; i <= tbody_detial; i++) {
var checkall = $("#chk_selected\\[" + i + "\\]").is(":checked");
var hdn_detination = $("#hdn_detination\\[" + i + "\\]").val();
var amoutn_val = $("#hdn_InvoiceAmount\\[" + i + "\\]").val();
if (checkall == true) {
var amoutn = $("#hdn_InvoiceAmount\\[" + i + "\\]").val();
var hamout_val = (parseFloat(txt_hcharge) * parseFloat(amoutn)) / parseFloat(totalamountaas);
var detetaioniomamout_val = (parseFloat(txt_detinationchr) * parseFloat(amoutn)) / parseFloat(totalamountaas);
var hamout_val1 = hamout_val.toFixed(0);
var detetaioniom_val = detetaioniomamout_val.toFixed(0);
if (isNaN(hamout_val1)) {
hamout_val1 = 0;
}
if (isNaN(detetaioniom_val)) {
detetaioniom_val = 0;
}
$("#txt_HamaliCharges\\[" + i + "\\]").val(hamout_val1);
$("#txt_detiationcharge\\[" + i + "\\]").val(detetaioniom_val);
} else {
var frigth = (parseFloat(txt_costvechile) * parseFloat(amoutn_val)) / parseFloat(totalamount1);
var frigthval1 = frigth.toFixed(0);
if (isNaN(frigthval1)) {
frigthval1 = 0;
}
$("#hdn_hamali_primary\\[" + i + "\\]").val(0);
$("#hdn_frieght_primary\\[" + i + "\\]").val(frigthval1);
$("#hdn_detiation_primary\\[" + i + "\\]").val(0);
$("#txt_HamaliCharges\\[" + i + "\\]").val(0);
$("#txt_totalcharge\\[" + i + "\\]").val(frigthval1);
$("#txt_detiationcharge\\[" + i + "\\]").val(0);
}
var lblcalval = (parseFloat(hdn_detination) * parseFloat(amoutn_val)) / parseFloat(100);
var lblcal = lblcalval.toFixed(2);
$('#lbl_cal' + i).text(lblcal);
totalamout_vechile1 = parseFloat(totalamout_vechile1) + parseFloat(lblcalval);
$('#hdn_totalamout_vechile1').val(totalamout_vechile1);
}
var totalamout_vechiletapan = $('#hdn_totalamout_vechile1').val();
if (txt_costvechile < totalamout_vechiletapan) {
document.getElementById("txt_trans_cost_1").style.backgroundColor = "red";
}
else {
document.getElementById("txt_trans_cost_1").style.backgroundColor = "lightgreen";
}
costvechile_secondary();
}
function costvechile_secondary() {
var txt_costvechile = $('#txt_trans_cost_2').val();
if (txt_costvechile == '') {
txt_costvechile = 0;
}
var txt_hcharge = $('#txt_hamali_ch_2').val();
if (txt_hcharge == '') {
txt_hcharge = 0;
}
var txt_detinationchr = $('#txt_detenation_ch_2').val();
if (txt_detinationchr == '') {
txt_detinationchr = 0;
}
var tbody_detial = $('#tbody_details tr').length;
var totalamount = 0;
for (var i = 1; i <= tbody_detial; i++) {
var checksecondary = $("#chk_secondary\\[" + i + "\\]").is(":checked");
if (checksecondary == true) {
var amount = $("#hdn_InvoiceAmount\\[" + i + "\\]").val();
totalamount += parseFloat(amount);
}
}
var totalamountaas = totalamount;
for (var i = 1; i <= tbody_detial; i++) {
var amoutn = $("#hdn_InvoiceAmount\\[" + i + "\\]").val();
var checksecondary1 = $("#chk_secondary\\[" + i + "\\]").is(":checked");
var frigth = 0;
var hamout_val = 0;
var detetaioniomamout_val = 0;
var frieght_primary = parseFloat($("#txt_totalcharge\\[" + i + "\\]").val());
var hamout_primary = parseFloat($("#txt_HamaliCharges\\[" + i + "\\]").val());
var detiation_primary = parseFloat($("#txt_detiationcharge\\[" + i + "\\]").val());
if (checksecondary1 == true) {
frigth = (parseFloat(txt_costvechile) * parseFloat(amoutn)) / parseFloat(totalamountaas);
hamout_val = (parseFloat(txt_hcharge) * parseFloat(amoutn)) / parseFloat(totalamountaas);
detetaioniomamout_val = (parseFloat(txt_detinationchr) * parseFloat(amoutn)) / parseFloat(totalamountaas);
frigth = frieght_primary + frigth;
hamout_val = hamout_primary + hamout_val;
detetaioniomamout_val = detiation_primary + detetaioniomamout_val;
} else {
frigth = frieght_primary;
hamout_val = hamout_primary;
detetaioniomamout_val = detiation_primary;
}
var hdn_detination = $("#hdn_detination\\[" + i + "\\]").val();
var Actualtransper = (parseFloat(frigth) / parseFloat(amoutn)) * 100;
var Actualtransperval = Actualtransper.toFixed(2);
var lblcalval = (parseFloat(hdn_detination) * parseFloat(amoutn)) / parseFloat(100);
var lblcal = lblcalval.toFixed(2);
var frigthval1 = frigth.toFixed(0);
var hamout_val1 = hamout_val.toFixed(0);
var detetaioniom_val = detetaioniomamout_val.toFixed(0);
if (isNaN(frigthval1)) {
frigthval1 = 0;
}
if (isNaN(hamout_val1)) {
hamout_val1 = 0;
}
if (isNaN(detetaioniom_val)) {
detetaioniom_val = 0;
}
$("#txt_totalcharge\\[" + i + "\\]").val(frigthval1);
$("#txt_HamaliCharges\\[" + i + "\\]").val(hamout_val1);
$("#txt_detiationcharge\\[" + i + "\\]").val(detetaioniom_val);
$('#lbl_cal' + i).text(lblcal);
}
}
function submitform() {
var tbody_detial = $('#tbody_details tr').length;
if (tbody_detial == 0) {
alertModal("Please Select Invoices !!");
return false;
}
var transNm1 = $("#drp_trans_name_1").val();
if (transNm1 == "" || transNm1 == null) {
alertModal("Please Select Primary Transporter !!");
return false;
}
// var vehicleno1 = $("#drp_vehicleno_1").val();
// if (transNm1 != "") {
// if (vehicleno1 == "" || vehicleno1 == null) {
// alertModal("Please Select Primary Vehicle Number !!");
// return false;
// }
// }
if ($("#chk_secondaryTransport").is(":checked") == true) {
var transNm2 = $("#drp_trans_name_2").val();
if (transNm2 == "" || transNm2 == null) {
alertModal("Please Select Secondary Transporter !!");
return false;
}
// var vehicleno2 = $("#drp_vehicleno_2").val();
// if (transNm2 != "" || transNm2 != null) {
// if (vehicleno2 == "" || vehicleno2 == null) {
// alertModal("Please Select Secondary Vehicle Number !!");
// return false;
// }
// }
var chkflag = 0;
for (var i = 1; i <= $("#tbody_details tr").length; i++) {
var chk = $("#chk_secondary\\["+ i +"\\]").is(":checked");
if (chk == true) {
chkflag = 1;
break;
}
}
if (chkflag == 0) {
alertModal("Please Select Atleast 1 Invoice for Secondary Transporter !!","","400px");
return false;
}
}
// alertModal("ok");
$("#myform").submit();
}
function modifyTransEntry(TDocid) {
$.ajax({
type: "POST",
url: surl+"Transporter/modifyTransEntry_show",
data: {TDocid:TDocid},
beforeSend: function () {
$.blockUI();
},
complete: function () {
$.unblockUI();
},
success: function (res) {
var main = jQuery.parseJSON(res);
$('#txt_remarks').val(main[0].remarks);
$('#txt_despatch_date').val(main[0].DespatchDate);
$('#drp_trans_mode_1').val(main[0].modeoftransport);
$('#drp_trans_name_1').val(main[0].Transporterid);
getVehicleNo(1);
$('#drp_vehicleno_1').val(main[0].vehicleid);
$('#txt_trans_cost_1').val(main[0].mvehicleamt);
$('#txt_hamali_ch_1').val(main[0].mhamaliamt);
$('#txt_detenation_ch_1').val(main[0].mdetenationamt);
$('#txt_lr_no_1').val(main[0].LRNo);
$('#txt_lr_date_1').val(main[0].LRDate);
$('#txt_bill_no_1').val(main[0].bill_no);
$('#txt_docdate_1').val(main[0].bill_date);
var is_secondary = main[0].is_secondary;
if (is_secondary == '1') {
$('#chk_secondaryTransport').attr("checked", "checked");
$("#div_SecondaryTr").css("display", "block");
$('#drp_trans_mode_2').val(main[0].secondary_modeoftransport);
$('#drp_trans_name_2').val(main[0].secondary_Transporterid);
getVehicleNo(2);
$('#drp_vehicleno_2').val(main[0].secondary_vehicleid);
$('#txt_trans_cost_2').val(main[0].msecondary_vehicleamt);
$('#txt_hamali_ch_2').val(main[0].msecondary_hamaliamt);
$('#txt_detenation_ch_2').val(main[0].msecondary_detenationamt);
$('#txt_lr_no_2').val(main[0].Secondary_LRNo);
$('#txt_lr_date_2').val(main[0].Secondary_LR_date);
$('#txt_bill_no_2').val(main[0].Secondary_bill_no);
$('#txt_docdate_2').val(main[0].Secondary_bill_date);
}
$("#tbody_details").empty();
var b = 1;
for (var i = 0; i < main.length; i++) {
if (main[i].ishamalicharge == 1) {
ishamalicharg = 'checked="checked"';
} else {
ishamalicharg = '';
}
if (main[i].secondary_detail == 1) {
secondrydetail = 'checked="checked"';
} else {
secondrydetail = '';
}
$('#tbody_details').append("<tr>\n\
<td>\n\
<input type='hidden' name='hdn_detination[" + b + "]' id='hdn_detination[" + b + "]' value='" + main[i].Ctransporationper + "'>\n\
<input type='hidden' name='hdn_TDocid[" + b + "]' id='hdn_TDocid[" + b + "]' value='" + main[i].TDocid + "'>\n\
<input type='hidden' name='hdn_TDetailid[" + b + "]' id='hdn_TDetailid[" + b + "]' value='" + main[i].ID + "'>\n\
<input type='hidden' name='hdn_docid[" + b + "]' id='hdn_docid[" + b + "]' value='" + main[i].Docid + "'>\n\
" + main[i].invno + "\n\
</td>\n\
<td>" + main[i].invdate + "</td>\n\
<td><input type='text' value='" + main[i].companyname + "' style='background-color:transparent;border: none;width:100%;' readonly></td>\n\
<td><input type='text' value='" + main[i].shipadd + "' style='background-color:transparent;border: none;width:100%;' readonly></td>\n\
<td>\n\
<input type='hidden' name='hdn_InvoiceAmount[" + b + "]' id='hdn_InvoiceAmount[" + b + "]' value='" + main[i].Inv_amt + "'>\n\
" + main[i].Inv_amt + "\n\
</td>\n\
<td>\n\
<input type='hidden' name='hdn_frieght_primary[" + b + "]' id='hdn_frieght_primary[" + b + "]' value='" + main[i].freightamt + "'>\n\
<input type='text' name='txt_totalcharge[" + b + "]' id='txt_totalcharge[" + b + "]' value='" + main[i].total_frieghtamt + "' readonly class='form-control controlmy'>\n\
</td>\n\
<td>\n\
<input type='hidden' name='hdn_hamali_primary[" + b + "]' id='hdn_hamali_primary[" + b + "]' value='" + main[i].hamaliamt + "'>\n\
<input type='text' name='txt_HamaliCharges[" + b + "]' id='txt_HamaliCharges[" + b + "]' value='" + main[i].Total_hamaliamt + "' readonly class='form-control controlmy'>\n\
</td>\n\
<td>\n\
<input type='hidden' name='hdn_detiation_primary[" + b + "]' id='hdn_detiation_primary[" + b + "]' value='" + main[i].detenationamt + "'>\n\
<input type='text' name='txt_detiationcharge[" + b + "]' id='txt_detiationcharge[" + b + "]' value='" + main[i].total_detenationamt + "' readonly class='form-control controlmy'>\n\
</td>\n\
<td>\n\
<input type='text' name='txt_fright[" + b + "]' id='txt_fright[" + b + "]' value='" + main[i].Freight + "' readonly class='form-control controlmy'>\n\
</td>\n\
<td style='text-align:center;'><input type='checkbox' name='chk_selected[" + b + "]' id='chk_selected[" + b + "]' "+ ishamalicharg +" onclick='return hcharges();' checked></td>\n\
<td><label id='lbl_cal" + b + "'></label></td>\n\
<td style='text-align:center;'><input type='checkbox' id='chk_secondary[" + b + "]' name='chk_secondary[" + b + "]' "+ secondrydetail +" onclick='return costvechile();'></td>\n\
</tr>");
b++;
}
$('#btn_submit').val('Update');
costvechile();
},
error: function(res) {
$.unblockUI();
alert("Error in modifyTransEntry_show()-> " + res.responseText);
}
});
}
function addNewVehicle() {
$("#hdn_transporterID").val($("#drp_trans_name_1").val());
$("#myModaladdNewVehicle").modal("toggle");
}
function saveNewVehicle() {
var TrID = $("#hdn_transporterID").val();
if (TrID == "") {
alertModal("Please select Transporter !!");
return false;
}
$.ajax({
type: "POST",
url: surl+"Transporter/addNewVehicleUtility",
data: $("#form_addNewVehicle").serialize(),
beforeSend: function () {
$.blockUI();
},
complete: function () {
$.unblockUI();
},
success: function (res) {
if (res == 1) {
alertModal("Vehicle Added Successfully !!");
$("#myModaladdNewVehicle").modal("toggle");
} else {
alertModal("Error in new Vehicle addition !!");
}
},
error: function(res) {
$.unblockUI();
alert("Error in addNewVehicleUtility()-> " + res.responseText);
}
});
} |
/**
* Created by henryleu on 9/6/16.
*/
const ApiDef = require('./api');
const apis = [];
const apiBaseUrl = 'https://api.netease.im/nimserver/team';
const teamApis = {
createTeam: 'create',
deleteTeam: 'remove',
updateTeam: 'update',
queryTeams: 'query',
addTeamMember: 'add',
removeTeamMember: 'kick',
removeTeamManager: 'removeManager',
changeTeamManager: 'changeOwner',
addTeamManger: 'addManager',
getJoinedTeams:'joinTeams',
updateTeamNickname:'updateTeamNick',
muteTeam:'muteTeam',
muteTeamMembers: 'muteTlist',
muteAllTeamMembers: 'muteTlistAll',
listTeamMute: 'listTeamMute',
leaveTeam:'leave',
}
for (let key of Object.keys(teamApis)) {
apis.push(new ApiDef(key, `${apiBaseUrl}/${teamApis[key]}.action`))
}
const types = {};
//被邀请人验证模式
types.inviteeApproveMode = {
no: 0 //不需要验证
, yes: 1 //需要验证
};
//主动申请加入验证模式
types.joinMode = {
withoutApproving: 0 //不需要验证
, withApproving: 1 //需要验证
, forbidden: 2 //不允许任何人加入
};
//被邀请人同意方式
types.inviteeMode = {
withApproving: 0 //不需要验证 (默认)
, withoutApproving: 1 //需要验证
};
//谁可以邀请他人入群
types.inviterMode = {
admin: 0 //管理员 (默认)
, all: 1 //所有人
};
//谁可以修改群资料
types.updateMode = {
admin: 0 //管理员 (默认)
, all: 1 //所有人
};
//谁可以更新群自定义属性
types.updateCustomMode = {
admin: 0 //管理员 (默认)
, all: 1 //所有人
};
//查询群时是否带成员列表
types.queryFlag = {
withMembers: 1 //带群成员列表
, withoutMembers: 0 //不带群成员列表
};
module.exports = { apis: apis, types: types };; |
#!/bin/bash
PGPASSWORD="password"
#Download the data here
wget https://github.com/CrunchyData/crunchy-demo-data/releases/download/V0.6.5.1/crunchy-demo-fire.dump.sql.gz
###### Ucomment for cloud or new database
#createdb -h 52.167.136.70 -U postgres -p 5432 fire
# Create the extension here
###### Ucomment for cloud or new database
#psql -h 52.167.136.70 -U postgres -p 5432 -c 'create extension postgis' fire
#psql -h 52.167.136.70 -U postgres -p 5432 -c 'create extension tsm_system_rows' fire
# load the data
gunzip -c crunchy-demo-fire.dump.sql.gz | psql -h localhost -U postgres -p 5432 fire
psql -h localhost -U postgres -p 5432 -c 'vacuum freeze analyze;' fire |
<filename>src/require.js
const path = require('path');
const fs = require('fs');
module.exports.folder = (dir, exclude = [], result = {}, recursive = true) => {
let stat, field, names = fs.readdirSync(dir);
for (let name of names) {
stat = fs.statSync(`${dir}/${name}`);
if (stat.isDirectory() && recursive) {
result[name] = {};
module.exports.folder(`${dir}/${name}`, exclude, result[name]);
continue;
}
if (path.extname(name) !== '.js')
continue;
field = path.basename(name, '.js');
if (exclude.includes(field))
continue;
result[field] = require(path.normalize(path.join(dir, name)));
}
return result;
}; |
#!/bin/bash
#
# Copyright 2012 Google Inc. All Rights Reserved.
# Author: kwinter@google.com (Kevin Winter)
#
# Runs both bug "unit" tests as well integration tests.
# Expects pickles to work.
BASE_DIR=$1
LIB=$2
MAX_VER=$3
BUGS_DIR="tests/adspygoogle/$LIB/bugs"
INTEGRATION_TEST_DIR="tests/adspygoogle/$LIB/$MAX_VER/"
# Move into base release directory.
pushd $BASE_DIR
# Move into and test all integration tests.
pushd $INTEGRATION_TEST_DIR
python alltests.py
popd
# If we have a bugs dir, run those to.
if [ -d $BUGS_DIR ]; then
pushd $BUGS_DIR
python alltests.py
popd
fi
# Final pop.
popd
|
import React from 'react';
const SearchForm = ({ inputCheck }) => (
<form className="search-form">
<input
onChange={inputCheck}
type="text"
autoComplete="off"
placeholder="Search images..."
/>
</form>
);
export default SearchForm;
|
package io.opensphere.featureactions.editor.ui;
import java.awt.Component;
import javafx.scene.Node;
import javafx.scene.control.ListView;
import javafx.scene.layout.BorderPane;
import io.opensphere.core.Toolbox;
import io.opensphere.featureactions.editor.model.SimpleFeatureAction;
import io.opensphere.featureactions.editor.model.SimpleFeatureActionGroup;
import io.opensphere.featureactions.editor.model.SimpleFeatureActions;
import io.opensphere.mantle.data.DataTypeInfo;
/** Allows the user to edit feature actions for a specific feature group. */
public class SimpleFeatureActionPane extends BorderPane
{
/** The current layer. */
private final DataTypeInfo layer;
/** The model containing all the feature actions for a layer. */
private final SimpleFeatureActions myActions;
/** The {@link ListView} showing all feature actions. */
private ListView<SimpleFeatureAction> myActionsList;
/**
* Handles drag and drop to and from this list view.
*/
private final DragDropHandler myDnDHandler;
/** The model containing all the feature actions for the group. */
private final SimpleFeatureActionGroup myGroup;
/** The system toolbox. */
private final Toolbox myToolbox;
/** The parent dialog for the detail editor. */
private final Component parentDialog;
/**
* Constructs a new feature action pane to edit a
* {@link SimpleFeatureActionGroup}.
*
* @param toolbox The system toolbox.
* @param allActions The model containing all the feature actions for a
* layer.
* @param group The model containing all the feature actions for the group.
* @param type the layer to which the group of feature actions apply
* @param dialog the dialog containing this editor
* @param dndHandler Allows the user to drag and drop actions.
*/
public SimpleFeatureActionPane(Toolbox toolbox, SimpleFeatureActions allActions, SimpleFeatureActionGroup group,
DataTypeInfo type, Component dialog, DragDropHandler dndHandler)
{
myToolbox = toolbox;
myActions = allActions;
myGroup = group;
layer = type;
parentDialog = dialog;
myDnDHandler = dndHandler;
createCenterPane();
bindUI();
}
/**
* Gets the list view showing the actions within the group.
*
* @return The actions list view.
*/
protected ListView<SimpleFeatureAction> getListView()
{
return myActionsList;
}
/** Connects the model and the UI together. */
private void bindUI()
{
myActionsList.setItems(myGroup.getActions());
}
/** Creates the center pane. */
private void createCenterPane()
{
setCenter(createCriteriaList());
}
/**
* Creates the criteria list view.
*
* @return the list view
*/
private Node createCriteriaList()
{
myActionsList = new ListView<>();
myActionsList.setCellFactory((param) ->
{
SimpleFeatureActionRow row = new SimpleFeatureActionRow(myToolbox, myActions, myGroup, layer, parentDialog);
myDnDHandler.handleNewCell(myGroup, row);
return row;
});
return myActionsList;
}
}
|
#!/usr/bin/env sh
# Copyright 2018 First Rust Competition Developers.
# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
# http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
# <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
# option. This file may not be copied, modified, or distributed
# except according to those terms.
# Script for deploying to crates.io
# Called by travis ci
set -e
# source: https://github.com/semver/semver/issues/232, with added "v"
TAG_REGEX="^v(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(-(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(\.(0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*)?(\+[0-9a-zA-Z-]+(\.[0-9a-zA-Z-]+)*)?\$"
if [ -z "$TRAVIS_TAG" ]; then
echo "Skipping publish because \$TRAVIS_TAG is empty."
exit
fi
if ! echo "$TRAVIS_TAG" | grep -Eq "$TAG_REGEX"; then
echo "WARNING! Found \$TRAVIS_TAG with value $TRAVIS_TAG, but it isn't a valid version name. Skipping Publish."
exit
fi
verify_version() {
cd $1
echo "Verifying version for $1"
if [ ! "v$(cargo pkgid | cut -d"#" -f2)" = "$TRAVIS_TAG" ]; then
echo "ERROR! \$TRAVIS_TAG '$TRAVIS_TAG' != $1 Cargo.toml#version 'v$(cargo pkgid | cut -d"#" -f2)'. Aborting."
exit 1
fi
cd ..
}
publish () {
cd $1
echo "Attempting to publish $1"
cargo package
echo "Package successful, publishing $1..."
cargo publish --token $CRATESIO_TOKEN
cd ..
}
publish_dirty() {
cd $1
echo "Attempting to publish $1"
cargo package --allow-dirty
echo "Package successful, publishing $1..."
cargo publish --allow-dirty --token $CRATESIO_TOKEN
cd ..
}
verify_version wpilib
verify_version wpilib-sys
verify_version cargo-frc
publish_dirty wpilib-sys
publish wpilib
publish cargo-frc
|
define(['./scroll_module'], function(scrollModule) {
var scroll;
scroll = new scrollModule();
function isHidden(element) {
return (element.offsetParent === null)
}
function filterEvents(query) {
var i, j, len, len1, event, events, results, results1;
events = document.getElementsByClassName('list-group-item');
if (query.length > 0) {
results = [];
for (i = 0, len = events.length; i < len; i++) {
event = events[i];
results.push((function(event) {
if (event.children[0].innerHTML.toLowerCase().indexOf(query) > -1) {
event.classList.remove('hide');
} else {
event.classList.add('hide');
}
})(event));
}
return results;
} else {
scroll.toTop();
results2 = [];
for (j = 0, len1 = events.length; j < len1; j++) {
event = events[j];
results2.push((function(event) {
event.classList.remove('hide');
})(event));
}
return results2;
}
}
var searchModule = function() {
this.initialize = function() {
document.getElementById('search').addEventListener("keyup", function(event){
var query = document.getElementById('search').value.toLowerCase();
// reset favoriteTool
document.getElementById('favorite').classList.add('empty');
filterEvents(query);
});
}
this.search = function(query) {
filterEvents(query);
}
}
return searchModule;
});
|
package testpb
import (
"testing"
"google.golang.org/protobuf/reflect/protoreflect"
)
func getFastType() (fastReflectionType protoreflect.MessageType) {
return (&A{}).ProtoReflect().Type()
}
func getSlowType() protoreflect.MessageType {
return (&A{}).slowProtoReflect().Type()
}
func Benchmark_MessageType_New_FR(b *testing.B) {
typ := getFastType() // if casted to concrete type, performance goes down to: Benchmark_MessageType_New_FR-12 1000000000 0.2431 ns/op
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = typ.New()
}
}
func Benchmark_MessageType_New_SR(b *testing.B) {
typ := getSlowType()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = typ.New()
}
}
func Benchmark_MessageType_Zero_FR(b *testing.B) {
typ := getFastType()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = typ.Zero()
}
}
func Benchmark_MessageType_Zero_SR(b *testing.B) {
typ := getSlowType()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = typ.Zero()
}
}
func Benchmark_MessageType_Descriptor_FR(b *testing.B) {
typ := getFastType()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = typ.Descriptor()
}
}
func Benchmark_MessageType_Descriptor_SR(b *testing.B) {
typ := getSlowType()
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = typ.Descriptor()
}
}
|
alter table sessions add hash_code bigint;
|
<reponame>ministryofjustice/prison-visits-2
class Cancellation < ApplicationRecord
class Reason
include ActiveModel::Model
attr_accessor :explanation, :id, :label
end
end
|
export CODE_TRANSFORMER_DATA_PATH=/scratch1/08401/ywen/data/code-transformer
export CODE_TRANSFORMER_BINARY_PATH=/scratch1/08401/ywen/code/code-transformer/sub_modules
export CODE_TRANSFORMER_MODELS_PATH=/scratch1/08401/ywen/code/code-transformer/models
export CODE_TRANSFORMER_LOGS_PATH=/scratch1/08401/ywen/code/code-transformer/logs
export CODE_TRANSFORMER_DATA_PATH_STAGE_2=/scratch1/08401/ywen/data/code-transformer/stage2
python generate_data.py
|
#!/bin/sh
echo "Uninstalling ..."
systemctl --user stop gesture_improvements_gesture_daemon.service
rm -v ~/.config/systemd/user/gesture_improvements_gesture_daemon.service
rm -v ~/.local/bin/gesture_improvements_gesture_daemon
echo "Uninstalled ..."
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.