content
stringlengths 10
4.9M
|
|---|
/**
* This class hosts several constants related to the network configuration of
* Marauroa
*/
public class NetConst {
/**
* Number of the protocol version.
* 0 - Initial version
* 1 - Added Action message
* 2 - Added Perception message
* 3 - Multipacket udp
* 4 - Added server info
* 5 - Modified Action message
* 6 - Added zlib support to Perception message
* 7 - Modified Perception Added Invalid Version message
* 8 - Added Delta-delta support
* 9 - Added Timestamp to the Perception message
* 10 - Added conditional myRPObject send to Perception
* 11 - Added Map message
* - Added Timestamp to all Messages
* - Changed the ordering inside Perception message
* 12 - Changed perception to send only what is hidden on myRPObject
* - Added Out of Sync Message
* - Improved speed of perception creation
* 13 - Redefined Map message
* 14 - Compressed the Map message
* 15 - Modified ServerInfo message to add RPClass stuff
* 16 - Added Transfer Content
* - Added zone in perception
* 17 - Secured login
* 18 - Game name and version C2S and S2C on Login messages
* 19 - Added Perception Delta^2 MyRPObject
* 20 - Compressed server info message.
* 21 - Added capacity to RPSlot
* - Changed the RPClass serialization scheme
* 22 - Changed signature method. Two bytes now.
* 30 - Marauroa 2.0 refactoring
* - Dropped UDP support
* 31 - Added KeepAlive message.
* 32 - Include RPObjects in S2CCharacterList
* 33 - Added support for maps as attributes
* 34 - Added hash on content transfer, empty perceptions are now omittable
* 35 - Aded data type long
*/
public static final byte NETWORK_PROTOCOL_VERSION = 35;
/** Oldest supported protocol version */
public static final byte NETWORK_PROTOCOL_VERSION_MIN = 31;
/** Newest supported protocol version */
// 40 up to Marauroa version 3.8.8
public static final byte NETWORK_PROTOCOL_VERSION_MAX = 80;
/** the first version with details on the MessageS2CCharacterList. */
public static final byte FIRST_VERSION_WITH_DETAILS_IN_CHARACTER_LIST = 32;
/** the first version with support for older versions. */
public static final byte FIRST_VERSION_WITH_MULTI_VERSION_SUPPORT = 33;
/** the first version that supports maps in rpobjects. */
public static final byte FIRST_VERSION_WITH_MAP_SUPPORT = 33;
/** the first version that supports maps in rpobjects. */
public static final byte FIRST_VERSION_WITH_CONTENT_HASH = 34;
/**
* the first version which allows the omittion of empty perceptions
* because the client does not depend sending of the KeepAlive message
* anymore on counting perception messages
*/
public static final int FIRST_VERSION_WITH_OMITTABLE_EMPTY_PERCEPTIONS = 34;
/** longer reasons for bans */
public static final int FIRST_VERSION_WITH_LONG_BAN_MESSAGE = 34;
/** data type long */
public static final int FIRST_VERSION_WITH_TYPE_LONG = 35;
} |
// checks if string or array is empty
func isValidArrayOrString(value interface{}) bool {
if value == nil {
return false
}
if isString(value) {
return value.(string) != ""
}
if isArrayLike(value) {
a, err := arrayify(value)
if err != nil {
return false
}
for _, v := range a {
if !isString(v) || v.(string) == "" {
return false
}
}
return true
}
return false
} |
/**
*
* Fixed number of bins for a histogram. Unless configured, the range will
* expand dynamically, redistributing the data as necessary into the wider bins.
*
* The advantage of constraining the range of the statistic is to ignore values
* outside the range, such as erroneous values. Erroneous values force extremes
* in the histogram. For example, if the expected range of values falls between
* 0 and 1 and a value of 10000 occurs, then a single bin contains the entire
* population between 0 and 1, a single bin represents the single value of
* 10000. If there are extremes in the data, then use
* {@link FeatureNumericHistogramStatistics} instead.
*
*
* The default number of bins is 32.
*
*/
public class FeatureFixedBinNumericStatistics extends
AbstractDataStatistics<SimpleFeature> implements
FeatureStatistic
{
public static final String STATS_TYPE = "ATT_BIN";
private long count[] = new long[32];
private long totalCount = 0;
private double minValue = Double.MAX_VALUE;
private double maxValue = Double.MIN_VALUE;
private boolean constrainedRange = false;
protected FeatureFixedBinNumericStatistics() {
super();
}
public FeatureFixedBinNumericStatistics(
final ByteArrayId dataAdapterId,
final String fieldName ) {
super(
dataAdapterId,
composeId(
STATS_TYPE,
fieldName));
}
public FeatureFixedBinNumericStatistics(
final ByteArrayId dataAdapterId,
final String fieldName,
final int bins ) {
super(
dataAdapterId,
composeId(
STATS_TYPE,
fieldName));
count = new long[bins];
}
public FeatureFixedBinNumericStatistics(
final ByteArrayId dataAdapterId,
final String fieldName,
final int bins,
final double minValue,
final double maxValue ) {
super(
dataAdapterId,
composeId(
STATS_TYPE,
fieldName));
count = new long[bins];
this.minValue = minValue;
this.maxValue = maxValue;
constrainedRange = true;
}
public static final ByteArrayId composeId(
final String fieldName ) {
return composeId(
STATS_TYPE,
fieldName);
}
@Override
public String getFieldName() {
return decomposeNameFromId(getStatisticsId());
}
@Override
public DataStatistics<SimpleFeature> duplicate() {
return new FeatureFixedBinNumericStatistics(
dataAdapterId,
getFieldName());
}
public double[] quantile(
final int bins ) {
final double[] result = new double[bins];
final double binSize = 1.0 / bins;
for (int bin = 0; bin < bins; bin++) {
result[bin] = quantile(binSize * (bin + 1));
}
return result;
}
public double cdf(
final double val ) {
final double range = maxValue - minValue;
// one value
if ((range <= 0.0) || (totalCount == 0)) {
return clip(val - minValue);
}
final int bin = Math.min(
(int) Math.floor((((val - minValue) / range) * count.length)),
count.length - 1);
double c = 0;
final double perBinSize = binSize();
for (int i = 0; i < bin; i++) {
c += count[i];
}
final double percentageOfLastBin = Math.min(
1.0,
(val - ((perBinSize * (bin)) + minValue)) / perBinSize);
c += (percentageOfLastBin * count[bin]);
return c / totalCount;
}
private double clip(
final double p ) {
return p < 0 ? 0.0 : (p > 1.0 ? 1.0 : p);
}
private double binSize() {
final double v = (maxValue - minValue) / count.length;
return (v == 0.0) ? 1.0 : v;
}
public double quantile(
final double percentage ) {
final double fractionOfTotal = percentage * totalCount;
double countThisFar = 0;
int bin = 0;
for (; (bin < count.length) && (countThisFar < fractionOfTotal); bin++) {
countThisFar += count[bin];
}
if (bin == 0) {
return minValue;
}
final double perBinSize = binSize();
final double countUptoLastBin = countThisFar - count[bin - 1];
return minValue + ((perBinSize * bin) + (perBinSize * ((fractionOfTotal - countUptoLastBin) / count[bin - 1])));
}
public double percentPopulationOverRange(
final double start,
final double stop ) {
return cdf(stop) - cdf(start);
}
public long totalSampleSize() {
return totalCount;
}
public long[] count(
final int binSize ) {
return count;
}
@Override
public void merge(
final Mergeable mergeable ) {
if (mergeable instanceof FeatureFixedBinNumericStatistics) {
final FeatureFixedBinNumericStatistics tobeMerged = (FeatureFixedBinNumericStatistics) mergeable;
final double newMinValue = Math.min(
minValue,
tobeMerged.minValue);
final double newMaxValue = Math.max(
maxValue,
tobeMerged.maxValue);
this.redistribute(
newMinValue,
newMaxValue);
tobeMerged.redistribute(
newMinValue,
newMaxValue);
for (int i = 0; i < count.length; i++) {
count[i] += tobeMerged.count[i];
}
maxValue = newMaxValue;
minValue = newMinValue;
totalCount += tobeMerged.totalCount;
}
}
@Override
public byte[] toBinary() {
final int bytesNeeded = 4 + (16 * (2 + (count.length * 2)));
final ByteBuffer buffer = super.binaryBuffer(bytesNeeded);
buffer.putLong(totalCount);
buffer.putDouble(minValue);
buffer.putDouble(maxValue);
buffer.putInt(count.length);
for (int i = 0; i < count.length; i++) {
buffer.putLong(count[i]);
}
final byte result[] = new byte[buffer.position()];
buffer.rewind();
buffer.get(result);
return result;
}
@Override
public void fromBinary(
final byte[] bytes ) {
final ByteBuffer buffer = super.binaryBuffer(bytes);
totalCount = buffer.getLong();
minValue = buffer.getDouble();
maxValue = buffer.getDouble();
final int s = buffer.getInt();
for (int i = 0; i < s; i++) {
count[i] = buffer.getLong();
}
}
@Override
public void entryIngested(
final DataStoreEntryInfo entryInfo,
final SimpleFeature entry ) {
final Object o = entry.getAttribute(getFieldName());
if (o == null) {
return;
}
if (o instanceof Date)
add(
1,
((Date) o).getTime());
else if (o instanceof Number) add(
1,
((Number) o).doubleValue());
}
private void add(
final long amount,
final double num ) {
if (Double.isNaN(num) || (constrainedRange && ((num < minValue) || (num > maxValue)))) {
return;
}
// entry of the the same value or first entry
if ((totalCount == 0) || (minValue == num)) {
count[0] += amount;
minValue = num;
maxValue = Math.max(
num,
maxValue);
} // else if entry has a different value
else if (minValue == maxValue) { // && num is neither
if (num < minValue) {
count[count.length - 1] = count[0];
count[0] = amount;
minValue = num;
}
else if (num > maxValue) {
count[count.length - 1] = amount;
// count[0] is unchanged
maxValue = num;
}
}
else {
if (num < minValue) {
redistribute(
num,
maxValue);
minValue = num;
}
else if (num > maxValue) {
redistribute(
minValue,
num);
maxValue = num;
}
final double range = maxValue - minValue;
final double b = (((num - minValue) / range) * count.length);
final int bin = Math.min(
(int) Math.floor(b),
count.length - 1);
count[bin] += amount;
}
totalCount += amount;
}
private void redistribute(
final double newMinValue,
final double newMaxValue ) {
redistribute(
new long[count.length],
newMinValue,
newMaxValue);
}
private void redistribute(
final long[] newCount,
final double newMinValue,
final double newMaxValue ) {
final double perBinSize = binSize();
final double newRange = (newMaxValue - newMinValue);
final double newPerBinsSize = newRange / count.length;
double currentWindowStart = minValue;
double currentWindowStop = minValue + perBinSize;
for (int bin = 0; bin < count.length; bin++) {
long distributionCount = 0;
int destinationBin = Math.min(
(int) Math.floor((((currentWindowStart - newMinValue) / newRange) * count.length)),
count.length - 1);
double destinationWindowStart = newMinValue + (destinationBin * newPerBinsSize);
double destinationWindowStop = destinationWindowStart + newPerBinsSize;
while (count[bin] > 0) {
if (currentWindowStart < destinationWindowStart) {
// take whatever is left over
distributionCount = count[bin];
}
else {
final double diff = Math.min(
Math.max(
currentWindowStop - destinationWindowStop,
0.0),
perBinSize);
distributionCount = Math.round(count[bin] * (1.0 - (diff / perBinSize)));
}
newCount[destinationBin] += distributionCount;
count[bin] -= distributionCount;
if (destinationWindowStop < currentWindowStop) {
destinationWindowStart = destinationWindowStop;
destinationWindowStop += newPerBinsSize;
destinationBin += 1;
if ((destinationBin == count.length) && (count[bin] > 0)) {
newCount[bin] += count[bin];
count[bin] = 0;
}
}
}
currentWindowStart = currentWindowStop;
currentWindowStop += perBinSize;
}
count = newCount;
}
@Override
public String toString() {
final StringBuffer buffer = new StringBuffer();
buffer.append(
"histogram[adapter=").append(
super.getDataAdapterId().getString());
buffer.append(
", field=").append(
getFieldName());
final MessageFormat mf = new MessageFormat(
"{0,number,#.######}");
buffer.append(", range={");
buffer.append(
mf.format(new Object[] {
Double.valueOf(minValue)
})).append(
' ');
buffer.append(mf.format(new Object[] {
Double.valueOf(maxValue)
}));
buffer.append("}, bins={");
for (final double v : this.quantile(10)) {
buffer.append(
mf.format(new Object[] {
Double.valueOf(v)
})).append(
' ');
}
buffer.deleteCharAt(buffer.length() - 1);
buffer.append("}, counts={");
for (final long v : count(10)) {
buffer.append(
mf.format(new Object[] {
Long.valueOf(v)
})).append(
' ');
}
buffer.deleteCharAt(buffer.length() - 1);
buffer.append("}]");
return buffer.toString();
}
public static class FeatureFixedBinConfig implements
StatsConfig<SimpleFeature>
{
/**
*
*/
private static final long serialVersionUID = 6309383518148391565L;
private double minValue = Double.MAX_VALUE;
private double maxValue = Double.MIN_VALUE;
private int bins;
public FeatureFixedBinConfig() {
}
public FeatureFixedBinConfig(
final double minValue,
final double maxValue,
final int bins ) {
super();
this.minValue = minValue;
this.maxValue = maxValue;
this.bins = bins;
}
public double getMinValue() {
return minValue;
}
public void setMinValue(
final double minValue ) {
this.minValue = minValue;
}
public double getMaxValue() {
return maxValue;
}
public void setMaxValue(
final double maxValue ) {
this.maxValue = maxValue;
}
public int getBins() {
return bins;
}
public void setBins(
final int bins ) {
this.bins = bins;
}
@Override
public DataStatistics<SimpleFeature> create(
final ByteArrayId dataAdapterId,
final String fieldName ) {
return new FeatureFixedBinNumericStatistics(
dataAdapterId,
fieldName,
bins,
minValue,
maxValue);
}
}
} |
/**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*/
/**
* Holds all of the documents and data necessary to inflate an APL component hierarchy.
*/
export declare class Content {
/**
* Creates an instance of a Content object. a single Content instance
* can be used with multiple [[APLRenderer]]s.
* @param doc The main APL document
*/
static create(doc: string): Content;
/**
* Retrieve a set of packages that have been requested. This method only returns an
* individual package a single time. Once it has been called, the "requested" packages
* are moved internally into a "pending" list of packages.
* @return The set of packages that should be loaded.
*/
getRequestedPackages(): Set<APL.ImportRequest>;
/**
* Add a requested package to the document.
* @param request The requested package import structure.
* @param data Data for the package.
*/
addPackage(request: APL.ImportRequest, data: string): void;
/**
* @return True if this content is in an error state and can't be inflated.
*/
isError(): boolean;
/**
* @return True if this content is complete and ready to be inflated.
*/
isReady(): boolean;
/**
* @return true if this document is waiting for any valid packages to be loaded.
*/
isWaiting(): boolean;
/**
* Add data
* @param name The name of the data source
* @param data The raw data source
*/
addData(name: string, data: string): void;
/**
* Get document version specified in the input
*/
getAPLVersion(): string;
/**
* Deletes this obejct and all data associated with it.
*/
delete(): void;
/**
* @return The set of requested custom extensions (a list of URI values)
*/
getExtensionRequests(): Set<string>;
/**
* Retrieve the settings associated with an extension request.
* @param uri The uri of the extension.
* @return Map of settings, Object::NULL_OBJECT() if no settings are specified in the document.
*/
getExtensionSettings(uri: string): object;
}
|
<reponame>scmwinlinaung/ionic-native_for_jp_encode_decode
import { IonicNativePlugin } from '@ionic-native/core';
/**
* @hidden
*/
export declare class PLNObject {
private _objectInstance;
constructor(title: string, options: LocalNotificationOptions);
close(): void;
}
export interface LocalNotificationOptions {
/**
* Sets the direction of the notification. One of "auto", "ltr" or "rtl"
*/
dir?: string;
/**
* Sets the language of the notification
*/
lang?: string;
/**
* Sets the body of the notification
*/
body?: string;
/**
* Sets the identifying tag of the notification
*/
tag?: string;
/**
* Sets the icon of the notification
*/
icon?: string;
}
/**
* @name Phonegap Local Notification
* @description
* The Local Notification plugin gives developers the ability to post notifications from their app that show up in the device’s notification area.
* The API for the local notification plugin follows the W3C Web Notifications specification: https://www.w3.org/TR/notifications/
*
* @usage
* ```
* import { PhonegapLocalNotification } from '@ionic-native/phonegap-local-notification/ngx';
*
*
* constructor(private localNotification: PhonegapLocalNotification) { }
*
* ...
*
* this.localNotification.requestPermission().then(
* (permission) => {
* if (permission === 'granted') {
*
* // Create the notification
* this.localNotification.create('My Title', {
* tag: 'message1',
* body: 'My body',
* icon: 'assets/icon/favicon.ico'
* });
*
* }
* }
* );
*
* ```
*
* @interfaces
* LocalNotificationOptions
*/
export declare class PhonegapLocalNotification extends IonicNativePlugin {
/**
* A global object that lets you interact with the Notification API.
* @param title {string} Title of the local notification.
* @param Options {LocalNotificationOptions} An object containing optional property/value pairs.
* @returns {PLNObject}
*/
create(title: string, options: LocalNotificationOptions): PLNObject;
/**
* requests permission from the user to show a local notification.
* @returns {Promise<any>}
*/
requestPermission(): Promise<any>;
}
|
import bytes from 'bytes';
import type { CommitRecord } from 'bundlemon-utils';
export const stringToColor = function (str: string): string {
let hash = 0;
for (let i = 0; i < str.length; i++) {
hash = str.charCodeAt(i) + ((hash << 5) - hash);
}
let color = '#';
for (let i = 0; i < 3; i++) {
const value = (hash >> (i * 8)) & 0xff;
color += ('00' + value.toString(16)).substr(-2);
}
return color;
};
export const getVal =
(path: string, type: 'files' | 'groups') =>
(value: CommitRecord): number | undefined =>
value[type].find((f) => f.path === path)?.size;
export const bytesTickFormatter = (value: number) => bytes(value);
export const dateTickFormatter = (value: string) => new Date(value).toLocaleDateString();
|
import React, { useEffect, useState } from "react";
import { InertiaLink } from "@inertiajs/inertia-react";
// eslint-disable-next-line import/no-duplicates
import { format } from "date-fns";
// eslint-disable-next-line import/no-duplicates
import fr from "date-fns/locale/fr";
import { PostType } from "@/utils/types";
interface Props {
post: PostType;
}
export default ({ post }: Props) => {
const [author, setAuthor] = useState(post.creator);
useEffect(() => {
if (post.propose) {
setAuthor(post.propose);
}
}, []);
return (
<div className="w-full">
<InertiaLink
className="block rounded-lg bg-white h-75 shadow-md hover:shadow-lg overflow-hidden"
href={`/blog/${post.slug}`}
>
<img
src={post.image}
className="object-cover w-full h-45 lg:h-40"
alt={post.title}
/>
<div className="p-4 flex flex-col justify-between">
<div className="space-y-1">
<span className="inline-flex items-center px-2.5 py-0.5 rounded-full text-xs font-medium leading-4 bg-green-100 text-green-800">
{post.category.name}
</span>
<span className="h-10 flex text-truncate">
<h4 className="text-sm text-gray-700 font-medium text-wrap">{post.title}</h4>
</span>
</div>
<span className="flex mt-6 items-center">
<img
src={author.picture}
className="h-12 w-12 rounded-full mr-4"
alt={author.full_name}
/>
<span className="flex flex-col">
<span className="text-sm text-gray-600">{author.full_name}</span>
<small className="text-xs text-gray-400 capitalize">Le {format(new Date(post.published_at), "dd MMMM, y", { locale: fr })}</small>
</span>
</span>
</div>
</InertiaLink>
</div>
);
};
|
<filename>SRC/TEST/SCENARIO_PLAYER/sp_common_xml.c
/*
* Copyright (c) 2015, EURECOM (www.eurecom.fr)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* The views and conclusions contained in the software and documentation are those
* of the authors and should not be interpreted as representing official policies,
* either expressed or implied, of the FreeBSD Project.
*/
#include <stdbool.h>
#include <stdint.h>
#include <pthread.h>
#include <libxml/xmlwriter.h>
#include <libxml/xpath.h>
#include "bstrlib.h"
#include "dynamic_memory_check.h"
#include "hashtable.h"
#include "obj_hashtable.h"
#include "log.h"
#include "assertions.h"
#include "conversions.h"
#include "3gpp_23.003.h"
#include "3gpp_24.008.h"
#include "3gpp_33.401.h"
#include "3gpp_24.007.h"
#include "3gpp_36.401.h"
#include "3gpp_36.331.h"
#include "3gpp_24.301.h"
#include "security_types.h"
#include "common_defs.h"
#include "common_types.h"
#include "mme_scenario_player.h"
#include "xml_msg_tags.h"
#include "sp_common_xml.h"
//------------------------------------------------------------------------------
SP_NUM_FROM_XML_GENERATE( qci, QCI );
//------------------------------------------------------------------------------
SP_NUM_FROM_XML_GENERATE( priority_level, PRIORITY_LEVEL );
//------------------------------------------------------------------------------
SP_NUM_FROM_XML_GENERATE( pre_emption_capability, PRE_EMPTION_CAPABILITY );
//------------------------------------------------------------------------------
SP_NUM_FROM_XML_GENERATE( pre_emption_vulnerability, PRE_EMPTION_VULNERABILITY );
//------------------------------------------------------------------------------
SP_NUM_FROM_XML_GENERATE( teid, TEID );
//------------------------------------------------------------------------------
int sp_assign_value_to_var(scenario_t *scenario, char* var_name, char* str_value)
{
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Assigning to var %s value %s\n", var_name, str_value);
scenario_player_item_t * var = sp_get_var(scenario, (unsigned char *)var_name);
AssertFatal (var, "Could not find var %s", var_name);
AssertFatal (SCENARIO_PLAYER_ITEM_VAR == var->item_type, "Bad type var item UID %d", var->item_type);
if (VAR_VALUE_TYPE_INT64 == var->u.var.value_type) {
int ret = sscanf((const char*)str_value, "%"SCNx64, &var->u.var.value.value_u64);
if (1 == ret) {
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Set var %s=0x%" PRIx64 "\n", var_name, var->u.var.value.value_u64);
} else if (str_value[0] == '-') {
int ret = sscanf((const char*)str_value, "%"SCNi64, &var->u.var.value.value_64);
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Set var %s=%" PRIi64 "\n", var_name, var->u.var.value.value_u64);
if (1 != ret) return RETURNerror;
} else {
int ret = sscanf((const char*)str_value, "%"SCNu64, &var->u.var.value.value_u64);
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Set var %s=%" PRIu64 "\n", var_name, var->u.var.value.value_u64);
if (1 != ret) return RETURNerror;
}
} else if (VAR_VALUE_TYPE_HEX_STREAM == var->u.var.value_type) {
if (var->u.var.value.value_bstr) {
bdestroy_wrapper(&var->u.var.value.value_bstr);
}
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Set hex stream var %s=%s\n", var_name, str_value);
int len = strlen((const char*)str_value);
uint8_t hex[len/2];
int ret = ascii_to_hex ((uint8_t *) hex, (const char *)str_value);
if (!ret) return RETURNerror;
var->u.var.value.value_bstr = blk2bstr(hex,len/2);
} else if (VAR_VALUE_TYPE_ASCII_STREAM == var->u.var.value_type) {
if (var->u.var.value.value_bstr) {
bdestroy_wrapper(&var->u.var.value.value_bstr);
}
var->u.var.value.value_bstr = bfromcstr(str_value);
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Set ascii stream var %s=%s\n", var_name, str_value);
if (!var->u.var.value.value_bstr) return RETURNerror;
} else {
AssertFatal (0, "Bad var value type %d", var->u.var.value_type);
return RETURNerror;
}
return RETURNok;
}
//------------------------------------------------------------------------------
int sp_compare_string_value_with_var(scenario_t *scenario, char* var_name, char* str_value)
{
scenario_player_item_t * var = sp_get_var(scenario, (unsigned char *)var_name);
AssertFatal ((var), "Could not find var %s", var_name);
AssertFatal (SCENARIO_PLAYER_ITEM_VAR == var->item_type, "Bad type var item UID %d", var->item_type);
if (VAR_VALUE_TYPE_INT64 == var->u.var.value_type) {
uint64_t uintvar;
int ret = sscanf((const char*)str_value, "%"SCNx64, &uintvar);
// by default a value is dumped in hexa
if (1 == ret) {
if (var->u.var.value.value_u64 != uintvar) {
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Compare var %s failed %s!=0x%" PRIx64 "\n", var->u.var.name->data, str_value, var->u.var.value.value_u64);
return RETURNerror;
}
} else if (str_value[0] == '-') {
int64_t intvar;
int ret = sscanf((const char*)str_value, "%"SCNi64, &intvar);
if ((var->u.var.value.value_64 != intvar) || (1 != ret)) {
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Compare var %s failed %s!=%" PRIi64 "\n", var->u.var.name->data, str_value, var->u.var.value.value_64);
return RETURNerror;
}
} else {
uint64_t uintvar;
int ret = sscanf((const char*)str_value, "%"SCNu64, &uintvar);
if ((var->u.var.value.value_u64 != uintvar) || (1 != ret)) {
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Compare var %s failed %s!=0x%" PRIu64 "\n", var->u.var.name->data, str_value, var->u.var.value.value_u64);
return RETURNerror;
}
}
} else if (VAR_VALUE_TYPE_HEX_STREAM == var->u.var.value_type) {
int len = strlen((const char*)str_value);
if ((len/2) == blength(var->u.var.value.value_bstr)) {
uint8_t hex[len/2];
int ret = ascii_to_hex ((uint8_t *) hex, (const char *)str_value);
if (!ret) return RETURNerror;
if (memcmp(hex, var->u.var.value.value_bstr->data, len/2)) {
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Compare var %s failed (binary bstring) %s\n", var_name, str_value);
return RETURNerror;
}
} else {
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Compare var %s failed len %d != %d\n",
var_name, len, blength(var->u.var.value.value_bstr));
return RETURNerror;
}
} else if (VAR_VALUE_TYPE_ASCII_STREAM == var->u.var.value_type) {
if ( (blength(var->u.var.value.value_bstr) != strlen(str_value)) ||
(memcmp(str_value, var->u.var.value.value_bstr->data, blength(var->u.var.value.value_bstr)))) {
OAILOG_TRACE (LOG_MME_SCENARIO_PLAYER, "Compare var %s failed %s!=%s\n", var_name, str_value, bdata(var->u.var.value.value_bstr));
return RETURNerror;
}
} else {
AssertFatal (0, "Bad var value type %d", var->u.var.value_type);
return RETURNerror;
}
return RETURNok;
}
|
/**
* Demand-driven alias query.
* @param var1
* @param m1
* @param var2
* @param m2
* @return
*
* pre-condition: var1.type == var2.type -> this condition is not checked in the method
* because it's usually the case; the types would differ only when we are doing an
* exhaustive test
*/
public boolean mayAlias(Local var1, SootMethod m1, Local var2, SootMethod m2) {
if (var1.getName().equals(var2.getName()) && m1.getSignature().equals(m2.getSignature())) {
return true;
}
NodeFactory nf1 = NodeFactory.v(m1);
NodeFactory nf2 = NodeFactory.v(m2);
VarNode vn1 = nf1.makeLocalVarNode(m1, var1);
VarNode vn2 = nf2.makeLocalVarNode(m2, var2);
boolean res = true;
if (res) {
/*HashSet<Type> types = new HashSet<>();
types.addAll(AliasGlobalVariables.relevantTypesMap.get(var1.getType()));
types.addAll(AliasGlobalVariables.relevantTypesMap.get(var2.getType()));*/
res = mayAlias_bfs(vn1, vn2);
} else {
Util.sparkFalsePairs++;
}
return res;
} |
/*
* Copyright (c) 1999, <NAME>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by <NAME>.
* 4. Neither the name of the author nor the names of any co-contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD: src/lib/libncp/ncpl_subr.c,v 1.3 2000/01/01 14:21:31 bp Exp $
*/
#include <sys/param.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/sysctl.h>
#include <sys/syscall.h>
#include <unistd.h>
#include <ctype.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <netncp/ncp_lib.h>
#include <netncp/ncp_rcfile.h>
#include <netncp/ncp_nls.h>
/*#include <netncp/ncp_cfg.h>*/
#include "ncp_mod.h"
extern char *__progname;
int sysentoffset;
void
ncp_add_word_lh(struct ncp_buf *conn, u_int16_t x) {
setwle(conn->packet, conn->rqsize, x);
conn->rqsize += 2;
return;
}
void
ncp_add_dword_lh(struct ncp_buf *conn, u_int32_t x) {
setdle(conn->packet, conn->rqsize, x);
conn->rqsize += 4;
return;
}
void
ncp_add_word_hl(struct ncp_buf *conn, u_int16_t x){
setwbe(conn->packet, conn->rqsize, x);
conn->rqsize += 2;
return;
}
void
ncp_add_dword_hl(struct ncp_buf *conn, u_int32_t x) {
setdbe(conn->packet, conn->rqsize, x);
conn->rqsize += 4;
return;
}
void
ncp_add_mem(struct ncp_buf *conn, const void *source, int size) {
memcpy(conn->packet+conn->rqsize, source, size);
conn->rqsize += size;
return;
}
void
ncp_add_mem_nls(struct ncp_buf *conn, const void *source, int size) {
ncp_nls_mem_u2n(conn->packet+conn->rqsize, source, size);
conn->rqsize += size;
return;
}
void
ncp_add_pstring(struct ncp_buf *conn, const char *s) {
int len = strlen(s);
if (len > 255) {
ncp_printf("ncp_add_pstring: string too long: %s\n", s);
len = 255;
}
ncp_add_byte(conn, len);
ncp_add_mem(conn, s, len);
return;
}
void
ncp_add_handle_path(struct ncp_buf *conn, nuint32 volNumber, nuint32 dirNumber,
int handleFlag, const char *path)
{
ncp_add_byte(conn, volNumber);
ncp_add_dword_lh(conn, dirNumber);
ncp_add_byte(conn, handleFlag);
if (path) {
ncp_add_byte(conn, 1); /* 1 component */
ncp_add_pstring(conn, path);
} else {
ncp_add_byte(conn, 0);
}
}
void
ncp_init_request(struct ncp_buf *conn) {
conn->rqsize = 0;
conn->rpsize = 0;
}
void
ncp_init_request_s(struct ncp_buf *conn, int subfn) {
ncp_init_request(conn);
ncp_add_word_lh(conn, 0);
ncp_add_byte(conn, subfn);
}
u_int16_t
ncp_reply_word_hl(struct ncp_buf *conn, int offset) {
return getwbe(ncp_reply_data(conn, offset), 0);
}
u_int16_t
ncp_reply_word_lh(struct ncp_buf *conn, int offset) {
return getwle(ncp_reply_data(conn, offset), 0);
}
u_int32_t
ncp_reply_dword_hl(struct ncp_buf *conn, int offset) {
return getdbe(ncp_reply_data(conn, offset), 0);
}
u_int32_t
ncp_reply_dword_lh(struct ncp_buf *conn, int offset) {
return getdle(ncp_reply_data(conn, offset), 0);
}
int
ncp_connect(struct ncp_conn_args *li, int *connHandle) {
return syscall(NCP_CONNECT,li,connHandle);
}
int
ncp_disconnect(int cH) {
DECLARE_RQ;
ncp_init_request(conn);
ncp_add_byte(conn, NCP_CONN_CONNCLOSE);
return ncp_conn_request(cH, conn);
}
int
ncp_request(int connHandle,int function, struct ncp_buf *ncpbuf){
int err = syscall(SNCP_REQUEST,connHandle,function,ncpbuf);
return (err<0) ? errno : 0;
}
int
ncp_conn_request(int connHandle, struct ncp_buf *ncpbuf){
return syscall(SNCP_REQUEST, connHandle, NCP_CONN, ncpbuf);
}
int
ncp_conn_scan(struct ncp_conn_loginfo *li, int *connid) {
return syscall(NCP_CONNSCAN,li, connid);
}
NWCCODE
NWRequest(NWCONN_HANDLE cH, nuint16 fn,
nuint16 nrq, NW_FRAGMENT* rq,
nuint16 nrp, NW_FRAGMENT* rp)
{
int error;
struct ncp_conn_frag nf;
DECLARE_RQ;
ncp_init_request(conn);
ncp_add_byte(conn, NCP_CONN_FRAG);
nf.fn = fn;
nf.rqfcnt = nrq;
nf.rqf = rq;
nf.rpf = rp;
nf.rpfcnt = nrp;
ncp_add_mem(conn, &nf, sizeof(nf));
error = ncp_conn_request(cH, conn);
return error;
}
int
ncp_initlib(void){
int error;
size_t len = sizeof(sysentoffset);
int kv;
size_t kvlen = sizeof(kv);
static int ncp_initialized;
if (ncp_initialized)
return 0;
error = sysctlbyname("net.ncp.sysent", &sysentoffset, &len, NULL, 0);
if (error) {
fprintf(stderr, "%s: can't find kernel module\n", __func__);
return error;
}
error = sysctlbyname("net.ncp.version", &kv, &kvlen, NULL, 0);
if (error) {
fprintf(stderr, "%s: kernel module is old, please recompile it.\n", __func__);
return error;
}
if (NCP_VERSION != kv) {
fprintf(stderr, "%s: kernel module version(%d) don't match library(%d).\n", __func__, kv, NCP_VERSION);
return EINVAL;
}
if ((error = ncp_nls_setrecode(0)) != 0) {
fprintf(stderr, "%s: can't initialise recode\n", __func__);
return error;
}
if ((error = ncp_nls_setlocale("")) != 0) {
fprintf(stderr, "%s: can't initialise locale\n", __func__);
return error;
}
ncp_initialized++;
return 0;
}
/*
*/
int ncp_opterr = 1, /* if error message should be printed */
ncp_optind = 1, /* index into parent argv vector */
ncp_optopt, /* character checked for validity */
ncp_optreset; /* reset getopt */
char *ncp_optarg; /* argument associated with option */
#define BADCH (int)'?'
#define BADARG (int)':'
#define EMSG ""
int
ncp_getopt(int nargc, char * const *nargv, const char *ostr)
{
static char *place = EMSG; /* option letter processing */
char *oli; /* option letter list index */
int tmpind;
if (ncp_optreset || !*place) { /* update scanning pointer */
ncp_optreset = 0;
tmpind = ncp_optind;
while (1) {
if (tmpind >= nargc) {
place = EMSG;
return (-1);
}
if (*(place = nargv[tmpind]) != '-') {
tmpind++;
continue; /* lookup next option */
}
if (place[1] && *++place == '-') { /* found "--" */
ncp_optind = ++tmpind;
place = EMSG;
return (-1);
}
ncp_optind = tmpind;
break;
}
} /* option letter okay? */
if ((ncp_optopt = (int)*place++) == (int)':' ||
!(oli = strchr(ostr, ncp_optopt))) {
/*
* if the user didn't specify '-' as an option,
* assume it means -1.
*/
if (ncp_optopt == (int)'-')
return (-1);
if (!*place)
++ncp_optind;
if (ncp_opterr && *ostr != ':')
(void)fprintf(stderr,
"%s: illegal option -- %c\n", __progname, ncp_optopt);
return (BADCH);
}
if (*++oli != ':') { /* don't need argument */
ncp_optarg = NULL;
if (!*place)
++ncp_optind;
}
else { /* need an argument */
if (*place) /* no white space */
ncp_optarg = place;
else if (nargc <= ++ncp_optind) { /* no arg */
place = EMSG;
if (*ostr == ':')
return (BADARG);
if (ncp_opterr)
(void)fprintf(stderr,
"%s: option requires an argument -- %c\n",
__progname, ncp_optopt);
return (BADCH);
}
else /* white space */
ncp_optarg = nargv[ncp_optind];
place = EMSG;
++ncp_optind;
}
return (ncp_optopt); /* dump back option letter */
}
/*
* misc options parsing routines
*/
int
ncp_args_parserc(struct ncp_args *na, char *sect, ncp_setopt_t *set_callback) {
int len, error;
for (; na->opt; na++) {
switch (na->at) {
case NCA_STR:
if (rc_getstringptr(ncp_rc,sect,na->name,&na->str) == 0) {
len = strlen(na->str);
if (len > na->ival) {
fprintf(stderr,"rc: Argument for option '%c' (%s) too long\n",na->opt,na->name);
return EINVAL;
}
set_callback(na);
}
break;
case NCA_BOOL:
error = rc_getbool(ncp_rc,sect,na->name,&na->ival);
if (error == ENOENT) break;
if (error) return EINVAL;
set_callback(na);
break;
case NCA_INT:
if (rc_getint(ncp_rc,sect,na->name,&na->ival) == 0) {
if (((na->flag & NAFL_HAVEMIN) &&
(na->ival < na->min)) ||
((na->flag & NAFL_HAVEMAX) &&
(na->ival > na->max))) {
fprintf(stderr,"rc: Argument for option '%c' (%s) should be in [%d-%d] range\n",na->opt,na->name,na->min,na->max);
return EINVAL;
}
set_callback(na);
}
break;
default:
break;
}
}
return 0;
}
int
ncp_args_parseopt(struct ncp_args *na, int opt, char *optarg, ncp_setopt_t *set_callback) {
int len;
for (; na->opt; na++) {
if (na->opt != opt) continue;
switch (na->at) {
case NCA_STR:
na->str = optarg;
if (optarg) {
len = strlen(na->str);
if (len > na->ival) {
fprintf(stderr,"opt: Argument for option '%c' (%s) too long\n",na->opt,na->name);
return EINVAL;
}
set_callback(na);
}
break;
case NCA_BOOL:
na->ival = 0;
set_callback(na);
break;
case NCA_INT:
errno = 0;
na->ival = strtol(optarg, NULL, 0);
if (errno) {
fprintf(stderr,"opt: Invalid integer value for option '%c' (%s).\n",na->opt,na->name);
return EINVAL;
}
if (((na->flag & NAFL_HAVEMIN) &&
(na->ival < na->min)) ||
((na->flag & NAFL_HAVEMAX) &&
(na->ival > na->max))) {
fprintf(stderr,"opt: Argument for option '%c' (%s) should be in [%d-%d] range\n",na->opt,na->name,na->min,na->max);
return EINVAL;
}
set_callback(na);
break;
default:
break;
}
break;
}
return 0;
}
/*
* Print a (descriptive) error message
* error values:
* 0 - no specific error code available;
* -999..-1 - NDS error
* 1..32767 - system error
* the rest - requester error;
*/
void
ncp_error(const char *fmt, int error,...) {
va_list ap;
fprintf(stderr, "%s: ", __progname);
va_start(ap, error);
vfprintf(stderr, fmt, ap);
va_end(ap);
if (error == -1)
error = errno;
if (error > -1000 && error < 0) {
fprintf(stderr, ": dserr = %d\n", error);
} else if (error & 0x8000) {
fprintf(stderr, ": nwerr = %04x\n", error);
} else if (error) {
fprintf(stderr, ": syserr = %s\n", strerror(error));
} else
fprintf(stderr, "\n");
}
char *
ncp_printb(char *dest, int flags, const struct ncp_bitname *bnp) {
int first = 1;
strcpy(dest, "<");
for(; bnp->bn_bit; bnp++) {
if (flags & bnp->bn_bit) {
strcat(dest, bnp->bn_name);
first = 0;
}
if (!first && (flags & bnp[1].bn_bit))
strcat(dest, "|");
}
strcat(dest, ">");
return dest;
}
|
<reponame>aanviguliani/net-test<filename>pkg/akips/config.go
package akips
import (
"context"
"io"
"net/http"
"net/url"
"path"
"strings"
)
// Config is the client configuration
type Config struct {
AuthMethod AuthMethod
URL string
Transport http.RoundTripper
}
// Client creates an *http.Client
func (c *Config) Client() *http.Client {
if c.AuthMethod == nil {
return http.DefaultClient
}
return &http.Client{
Transport: &Transport{
Base: c.Transport,
AuthMethod: c.AuthMethod,
},
}
}
// NewRequest returns a new Request given a method, URL, and a contents
func (c *Config) NewRequest(ctx context.Context, method, endpointPath string, values url.Values) (*http.Request, error) {
u, err := url.Parse(c.URL)
if err != nil {
return nil, err
}
u.Path = path.Join(u.Path, endpointPath)
var body io.Reader
if len(values) != 0 {
if method == "PUT" || method == "POST" {
data := values.Encode()
body = strings.NewReader(data)
} else {
q := u.Query()
for k, v := range values {
q[k] = v
}
u.RawQuery = q.Encode()
}
}
req, err := http.NewRequestWithContext(ctx, method, u.String(), body)
if err != nil {
return nil, err
}
if body != nil {
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
}
return req, nil
}
|
Very Deep Graph Neural Networks Via Noise Regularisation
Graph Neural Networks (GNNs) perform learned message passing over an input graph, but conventional wisdom says performing more than handful of steps makes training difficult and does not yield improved performance. Here we show the contrary. We train a deep GNN with up to 100 message passing steps and achieve several state-of-the-art results on two challenging molecular property prediction benchmarks, Open Catalyst 2020 IS2RE and QM9. Our approach depends crucially on a novel but simple regularisation method, which we call “Noisy Nodes”, in which we corrupt the input graph with noise and add an auxiliary node autoencoder loss if the task is graph property prediction. Our results show this regularisation method allows the model to monotonically improve in performance with increased message passing steps. Our work opens new opportunities for reaping the benefits of deep neural networks in the space of graph and other structured prediction problems.
Introduction
Advances in the ability to successfully train very deep neural networks have been key to improving performance in image recognition, language modeling, and many other domains . Graph Neural Networks (GNNs) are a family of deep networks that operate on graph structured data by iteratively passing learned messages over the graph's structure . While GNNs are very effective in a wide variety of tasks , deep GNNs, which perform more than 5-10 message passing steps, have not typically yielded better performance than shallower GNNs . While in principle deep GNNs should have greater expressivity and ability to capture complex functions, it has been proposed that in practice "oversmoothing" and "bottleneck effects" limit the potential benefits of deep GNNs. The purpose of this work is to reap the benefits of deep GNNs while avoiding such limitations.
Oversmoothing is a proposed phenomenon where a GNN's latent node representations become increasing similar over successive steps of message passing . Once these representations are oversmoothed, adding further steps does not add expressive capacity, and so performance does not improve. Bottleneck effects are thought to limit the ability of a deep GNN to communicate information over long ranges, because as the number of steps increases and causes the receptive fields to grow, the intermediate nodes must propagate information between larger and larger sets of peripheral nodes, limiting the ability to precisely transmit individual pieces of information . We speculate that these are reasons why previous strong GNN results on the molecular property benchmarks we study here, Open Catalyst 2020 (OC20) and QM9 , report depths of only 4 and 8 , even with large hyperparameter searches.
Originally we trained a very deep GNN and, like previous work, we found negligible benefits from increasing depth on OC20 and QM9. However, we then developed a noise regularisation approach, which we term "Noisy Nodes", which provides dramatic improvements in performance: we found increasing the GNN's depth monotonically decreased error. During training, our noise regularisation approach corrupts the input graph's nodes with noise, and then adds an autoencoding loss if a node prediction task is not defined. We posit that our Noisy Nodes approach is effective because the model is rewarded for maintaining and refining distinct node representations through message passing to the final output, which causes it to resist oversmoothing and overfitting. Like denoising autoencoders, it may also encourage the model to explicitly learn the manifold on which the real graphs lie.
Using only atom types and positions, our model improves state-of-the-art (SOTA) performance on the OC20 IS2RE task by 43% over previous work and achieves top results on 4 out of 12 of the QM9 tasks. On OC20 IS2RS our model's raw performance is currently second behind SOTA, but it runs roughly 400x faster because it directly predicts the target rather than using the iterative relaxation technique previous models use. Moreover, there is nothing specific to molecules or 3D geometries in our regulariser-the Noisy Nodes technique can be applied to a wide range of graph prediction problems and has potential to make deep GNNs more generally valuable, analogous to how depth often uniquely benefits others neural network architectures.
Related Work
Scaling Graph Neural Networks with Depth. Recent work has aimed to understand why it is challenging to realise the benefits of training very deep GNNs . A key contribution has been the analysis of "oversmoothing" which describes how all node features become almost identical in GCNs after a few layers. Since first being noted in oversmoothing has been studied extensively and regularisation techniques have been suggested to overcome it , but these studies have not shown consistent improvements as depth increases. Another insight has been the analysis of the bottleneck effect in Alon and Yahav which may be alleviated by using a fully connected graph. Finally, deep GNNs have been trained using techniques developed for CNNs , but with no conclusive improvement from depth.
Machine Learning for Molecular Property Prediction. One application of GNNs is to speed up quantum chemistry calculations which operate on a graph structured representation of a molecule . In these graphs atoms are nodes and edges are constructed between close neighbours. Common goals are the prediction of molecular properties , forces , energies and charges . These datasets have spurred the development of GNNs that embed 3D physical symmetry inductive biases such as the rotation equivariance of forces. Such inductive biases typically improve performance and sample complexity.
A common approach to embed physical symmetries is to design a network that predicts a rotation and translation invariant energy . The derivatives of such a model with respect to its positions are energy conserving rotation equivariant forces. The input features of such models include distances , angles or torsions and higher order terms . As higher order terms such as angles are added the size of the input representation can increase significantly , and therefore the memory and compute requirements of the model.
An alternative approach to embedding symmetries is to design a rotation equivariant neural network that predicts quantities such as forces directly . However, the benefits of such models are typically seen on smaller data (e.g. Satorras et al. ), and such approaches have yet to achieve SOTA performance on large quantum chemistry datasets. Not all competitive models embed rotation symmetries-notably ForceNet does not enforce rotation equivariance.
Denoising Models. Training neural networks with noise has a long history . Of particular relevance are Denoising Autoencoders in which an autoencoder is trained to map corrupted inputsx to uncorrupted inputs x. Denoising Autoencoders have found particular success as a form of pre-training for representation learning . More recently, in research applying GNNs to simulation Gaussian noise is added during training to input positions of a ground truth simulator to mimic the distribution of errors of the learned simulator. Pre-training methods are another similar approach; most similarly to our method Hu et al. apply a reconstruction loss to graphs with masked nodes to generate graph embeddings for use in downstream tasks.
Graph prediction problem definition
Let G = (V, E, g) be an input graph. The nodes are V = {v 1 , . . . , v |V | }, where v i ∈ R dv . The directed, attributed edges are E = {e 1 , . . . , e |E| }: each edge includes a sender node index, receiver node index, and edge attribute, e k = (s k , r k , e k ), respectively, where s k , r k ∈ {1, . . . , |V |} and e k ∈ R de . The graph-level property is g ∈ R dg .
The goal is to predict a target graph, G , with the same structure as G, but different node, edge, and/or graph-level attributes. We denoteĜ as a model's prediction of G . Some error metric defines quality ofĜ with respect to the target G , Error(Ĝ , G ), which the training loss terms are defined to optimize. Figure 1: A) Model Overview. The system is encoded using Noisy Nodes, and then a graph is constructed by connecting neighboring atoms within a connectivity radius. A block of M unshared message passing steps is performed N times, for N × M total steps. B) Block. Each block consists of M steps of message passing. During training we decode the output of each block and compute a loss using Noisy Nodes against the same target. We optimise the average of the losses. During evaluation the prediction of the final block is used. C) Noisy Nodes. The input v i is corrupted with additive noise σ i . When input v i is used as v i , the auxiliary objective amounts to a denoising autoencoder.
Base GNN Model
Our base model is based on the Graph Net Simulator , but modified for molecular tasks and to make graph-level predictions. It operates on 3D points representing the positions of atoms, but apart from featurising interatomic distances using Radial Bessel functions, our model has no other quantum chemistry inspired features.
Our model has three parts the Encoder, the Processor and the Decoder. Let a i ∈ V be the set of atoms in a molecule (for convenience we use a i to represent atom positions in sections concerning 3D geometry). The Encoder, E : V → G 0 maps atoms, V ∈ V, to a latent graph, G (0) ∈ G (0) (the initial encoded latent graph). The Processor, P : G (n) → G (n+1) , passes messages across the latent graph using an Interaction Network , and the Decoder D : G (N ) → G , where G ∈ G represents target graph properties to predict. Here we use G = ({a ∆ , ∅, g ), where a ∆ are the atoms' position changes from input to target and g are molecular properties (the ∅ indicates the output graph's edge attributes are ignored). Our network is built from standard building blocks (overview in Figure 1A).
Encoder. During training Noisy Nodes is first applied to the atom positions (see Section 3.3 below). Then our encoder constructs a latent graph with a node per atom and adding edges between nodes within a "connectivity radius", R, which reflects the local interactions of atoms. Edges are computed using a k-nearest neighbors algorithm after noise has been applied to edges.
The node features are a learned embedding lookup of the atom type, and in the case of OC20 two additional binary features representing whether the atom is part of the adsorbate or catalyst and whether the atom remains fixed during the quantum chemistry simulation.
The edge features, e k are the distances |d| featurised using c Radial Bessel basis functions, , and the edge vector displacements, d, normalised by the edge distance: Where d = a s k − a r k . Note that since this encoding does not have absolute atom positions as an input it is translation invariant by construction.
Processor. The processor consists of "blocks", where each block contain a stack of Interaction Networks (each one known as a "message passing layer") with identical structure but different weights. The node and edge functions are 3 layer MLPs activated with shifted softplus (ssp(x) = ln(0.5e x + 0.5), ), followed by layer normalisation . Residual connections on both the nodes and edges are added to each message passing layer. We recurrently apply each block, a process we we call "block iteration". We calculate the number of message passing layers by multiplying the number of blocks by the block size, for example 10 applications of a block of size 10 corresponds to 100 (10 × 10) message passing layers.
Decoder. The decoder consists of two parts, a graph-level decoder which predicts a single output for the input graph, and a node-level decoder which predicts individual outputs for each node. The graph-level decoder implements the following equation: Where a Proc i are node latents from the Processor, a Enc i are node latents from the Encoder, W Enc and W Proc are linear layers, b Enc and b Proc are biases, and |V | is the number of nodes. The node-level decoder is simply an MLP applied to each a Proc i which predicts a ∆ i .
Our Noisy Nodes Regularisation Technique
We add the Noisy Nodes regulariser to our base model operating on 3D points. The Noisy Nodes loss has two components. First, we add noise to the input graph. Second, we add a node or edge level autoencoder auxiliary loss if the task is graph property prediction. Here we focus on 3D spatial problems, where noise is added to nodes which represent positions, but our technique can be applied to generally to the edges, nodes, or graph-level input features, and they need not be in R d .
The Noisy Nodes method modifies the original problem definition above in several ways. It introduces a graph corrupted by noise,G = (Ṽ ,Ẽ,g), whereṽ i ∈Ṽ is constructed by adding noise, σ i , to the input nodes,ṽ i = v i + σ i . The edges,Ẽ, and graph-level attribute,g, can either be uncorrupted by noise (i.e.,Ẽ = E,g = g), calculated from the noisy nodes (for example in a nearest neighbors graph), or corrupted independent of the nodes-these are minor choices that can be informed by the specific problem setting.
Our method also requires a node level target. For problems where the Error is defined with respect to graph-level predictions (e.g., predict the minimum energy value of some molecular system), a second output head can be added to the GNN architecture which requires denoising the noisy inputs as node-level targets, analogous to an auxiliary denoising autoencoder head and training objective. In other words, because the v i ∈ V is not specified by the goal, we can set v i = v i and train the model to predict the uncorrupted input nodes.
Alternatively, if the Error is defined with respect to node-level predictions, (e.g. predict the positions of atoms at their minimum energy state), it is possible to train the model to map directly from corrupted node inputs to targets. In our case, we use relative node targets to enforce translation invariance. Relative targets modified for noise become Figure 1B details the various scenarios in a single diagram.
The Noisy Nodes objective helps ameliorate oversmoothing by adding a diverse per-node prediction loss that regularises identical node latents. In addition, using noise corrupted inputs helps prevent overfitting by ensuring that input graphs cannot be memorised.
The Graph Manifold Learning Perspective. By using an implicit mapping from corrupted data to correct data, the Noisy Nodes objective encourages the model to learn the manifold on which the correct data lies-the GNN learns to go from low probability graphs to high probability graphs. In the autoencoder case the GNN learns the manifold of the input data. When node targets are provided, the GNN learns the manifold of the target data (e.g. the manifold of atoms at equilibrium). For graphs constructed from points in Euclidean space, such as atoms , the manifold may include commonly repeated substructures that are useful for downstream prediction tasks.
Training
Loss. We minimise the mean squared error loss on mean and standard deviation normalised targets in using the Adam optimiser with warmup and cosine decay. Node and edge latents as well as MLP hidden layers were sized 512, with 3 layers per MLP and using shifted softplus activations throughout. Models were trained on 8 TPU devices and evaluated on V100 GPUs. QM9 models were trained for up to 24 hours, and OC models for up to 200 hours. We provide the full set of hyper-parameters and computational resources used separately for each dataset in the Appendix.
Our model is implemented in JAX using Haiku and Jraph for GNNs, and Optax for training . We found that computing and averaging the loss over each block application improves training stability and gives a small improvement in performance. Model selection used early stopping.
Experiments and Results
We tested our model on two challenging molecular property prediction benchmarks: OC20 and QM9 . These benchmarks are detailed below, but as general distinctions, OC20 uses graphs 2-20x larger than QM9, and so we expected greater benefits on OC20 from deeper message passing. Also, while QM9 always requires graph-level prediction, one of OC20's two tasks (IS2RS) requires node-level predictions while the other (IS2RE) requires graph-level predictions.
Open Catalyst 2020
Dataset. The OC20 dataset (CC Attribution 4.0) describes the interaction of a small molecule (the adsorbate) and a large slab (the catalyst), with total systems consisting of 20-200 atoms. The data is generated using a process called "atomic relaxation" which uses a second order optimisation method (e.g. ) to minimise the energy of a system with respect to atom positions. In total, the dataset consists of 1m+ atomic relaxation trajectories, constructed from 70 million hours of Density Functional Theory (DFT) calculations, with an average relaxation trajectory length of 200.
We focus on two of the community challenges; the Initial Structure to Resulting Energy (IS2RE) task which takes the initial structure of the relaxation and predicts the energy at the relaxed state, and the Initial Structure to Resulting Structure (IS2RS) which takes the initial structure and predict the relaxed state structure. These are both very challenging tasks with benchmark relative errors far higher than those seen on QM9. Figure 2: Validation curves on OC20 IS2RE ID. A) Without any node targets our model has poor performance and realises no benefit from depth, reflecting commonly held views about scaling GNNs. B) After adding a position node loss, we see performance improves as the number of message passing layers increases even with the same number of parameters. However, we still see overfitting. C) As we add Noisy Nodes the model achieves SOTA and stops overfitting. D) Adding Noisy Nodes allows a model with block size 1 to achieve SOTA. Note in these charts "block size" is the number of message passing layers in a block.
One of the goals of the OC20 dataset is to stimulate the development a model that can be applied to catalyst screening. In order to do this the authors estimate a model must make predictions in 10 ms . For that reason in IS2RS we train a model to directly predict the resulting structure, rather than using a relaxation. If we assume that each iteration requires 2x the compute of a single forward pass to compute the derivative, and that each relaxation consists of 200 steps then predicting IS2RS using a relaxation is 400x more expensive than a single forward pass.
Models are evaluated on 4 held out test sets; a set of In Distribution (ID) catalysts and adsorbates, Out of Distribution (OOD) catalysts and ID adsorbates, ID catalysts and OOD adsorbates and finally a set of both OOD catalysts and adsorbates. Four canonical validation datasets are also provided. Test sets are evaluated on a remote server hosted by the dataset authors with a very limited number of submissions per team.
Source of Noise for Noisy Nodes. For OC20 we have access to intermediate 3D states along a relaxation trajectory, which provide a form of structured noise for Noisy Nodes. During training we first sample from a point in this relaxation trajectory, and then add I.I.D Gaussian noise with mean zero and σ 2 = 0.3. The Noisy Node target is the relaxed structure.
Additional Training Details. OC20 provides the periodic axes of the ground truth DFT simulation. We use these by first transforming the inputs to the periodic basis, apply the model there, and then transform back to the input co-ordinate system: A(GNN(A −1 ν)) where ν is the matrix of atom positions and A is the transformation matrix. In addition we append the following rotation and translation invariant vector (αβ T , βγ T , αγ T , |α|, |β|, |γ|) ∈ R 6 to the edge features where α, β, γ are vectors of the transformation matrix. This additional vector provides rotation invariant angular and extent information to the GNN. Figure 2 we show that depth improves performance for IS2RE. Figure 2 A) shows that without using the any node auxiliary targets there is no benefit to be gained adding depth. However, once the Noisy Nodes objective is used, performance increases monotonically as depth increases. Furthermore, Figure 2 D) shows our model can achieve SOTA with a single message passing step recurrently applied 50 times.
In Table 1 we conduct an ablation on our hyperparameters and find again that using Noisy Nodes allows us to realise the benefits of depth. Interestingly we find that increased parameter counts do not necessarily improve performance-our best model was a block of 10 message passing steps recurrently applied 10 times. Moreover, block iteration is computationally more efficient than running a single large block with the same number of message passing steps (typically requiring half the training time). Results were averaged over 3 seeds and standard errors on the best obtained checkpoint show little sensitivity to initialisation. Further analysis of the effect of Noisy Nodes on GNN activations can be found in the Appendix.
Our best model on IS2RE was a 100 layer GNN with a block size of 10 × 10 which achieved a 43.3% relative performance improvement against SOTA results ( Table 2). Due to limited permitted test submissions, results presented here were from one test upload of our best performing validation seed. IS2RS. In Table 3 we perform the same ablation studies on the IS2RS validation set using the Average Distance within Threshold (ADwT) metric and observe the same relative effects. In Table 4 we see that our model reaches comparable performance to relaxation approaches on the IS2RS test set on ADwT. Additional metrics reported by the leaderboard server can be found in the Appendix.
We note a drop between the validation and test sets, which we speculate is due to distribution shift. We also notice a consistent pattern that having energy predictions as an auxiliary loss inhibits both relaxation and direct position predictions, we speculate that adding more capacity to the positional decoder head may help ameliorate such effects but leave that to future work.
To our knowledge this is the first time a model has been trained to directly predict relaxed structures from initial positions. These results demonstrate the exciting potential of learned models to make as accurate predictions as relaxation approaches, but with 400x less compute.
QM9
Dataset. The QM9 benchmark contains 134k molecules in equilibrium with up to 9 heavy C, O, N and F atoms, targeting 12 associated chemical properties (License: CCBY 4.0). We use 114k molecules for training, 10k for validation and 10k for test. All results are on the test set. We subtract a fixed per atom energy from the target values computed from linear regression to reduce variance.
We perform training in eV units for energetic targets, and evaluate using MAE. We summarise the results across the targets using mean standardised MAE (std. MAE) in which MAEs are normalised by their standard deviation, and mean standardised logMAE. Std. MAE is dominated by targets with high relative error such as ∆ , whereas logMAE is sensitive to outliers such as R 2 . As is standard for this dataset, a model is trained separately for each target but with identical hyper parameters.
Source of Noise for Noisy Nodes. For this dataset we add I.I.D Gaussian noise with mean zero and σ = 0.02 to the input atom positions. A denoising autoencoder loss is used.
Results. In Table 2 we can see that adding the denoising objective significantly improves results by 23.1% relative. Furthermore increased depth monotonically increases performance.
Our best model is a 30 layer network with block size 3 × 10, which achieves SOTA on 4 of the 12 targets (SphereNet is the only other model that achieves SOTA on 4 of 12) and comparable performance on the remainder (Table 5). On the std. MAE aggregate metric our model performs better than all other reported results, and is thus SOTA. This is despite having no equivariance or invariance symmetries, or hand crafted molecular features.
R 2 , the electronic spatial extent, is an outlier for our model. Interestingly, we found that without noise our model achieves 0.33 for this target. We speculate that this target is particularly sensitive to noise, and the best noise value would be significantly lower than for the dataset as a whole.
Limitations
Depth can have diminishing returns. Since training additional layers incurs computational overhead, practitioners must identify the appropriate layer count to achieve optimal performance. Our method has also not been demonstrated in the small data regime on datasets such as MD17 , a regime in which models such as DimeNet++ perform well. This regime has particular importance for learning interatomic potentials since highly accurate experimental data is typically small. We focused on the generality of our approach, so did not integrate Noisy Nodes with existing molecular prediction models such as DimeNet, SphereNet, etc. We leave such integration to future work, and believe further improvements could be gained.
Broader impact
Who may benefit from this work? Molecular property prediction with deep networks is a fastgrowing area with applications across domains such as drug design, catalyst discovery, synthetic biology, and chemical engineering. Noisy Nodes could aid models applied to these domains. We also demonstrate on OC20 that our direct state prediction approach is nearly as accurate as learned relaxed approaches at a small fraction of the computational cost, which may support material design which requires many predictions.
Finally, Noisy Nodes is also a general technique. It could be adapted and applied to many areas in which GNNs are used-for example, knowledge base completion, physical simulation or traffic prediction. We hope that the benefits of training GNNs with depth could be realised in these domains.
Potential negative impact and reflection. Enabling the training of very deep GNNs could contribute to global warming. Care should be taken when utilising depth, and we note that Noisy Nodes settings can be calibrated at shallow depth (e.g. a single block). In future work we plan to further investigate depth-efficiency tradeoffs in GNNs.
Conclusions
In this work we present Noisy Nodes, a general purpose method for training very deep GNNs which is not specific to molecular property prediction. We demonstrate that graph networks of large depth outperform shallower models even on small graphs, such as QM9, and can lead to substantial gains on very difficult datasets such as OC20. Realising the benefits of very deep GNNs opens new opportunities in the space of graph and other structured prediction problems.
Appendix
The following sections include details on training setup, hyper-parameters, input processing, as well as additional experimental results.
Analysis of Effect of Noisy Nodes.
In Figure F3 we analyse the impact of Noisy Nodes by plotting the Mean Absolute Distance (MAD) of the residual updates of each layer. MAD is a measure of the diversity of graph node features, often used to quantify oversmoothing, the higher the number the more diverse the node features, the lower the number the less diverse. In this plot we can see that for Noisy Nodes the node updates remain diverse for all of the layers, whereas without noise the model makes very similar updates per node for the majority of layers.
Additional Metrics for Open Catalyst IS2RS Test Set
Relaxation approaches to IS2RS minimise forces with respect to positions, with the expectation that forces at the minimum are close to zero. One metric of such a model's success is to evaluate the forces at the converged structure using ground truth Density Functional Theory calculations and see how close they are to zero. Two metrics are provided by OC20 on the IS2RS test set: Force below Threshold (FbT), which is the percentage of structures that have forces below 0.05 eV/Angstrom, and Average Force below Threshold (AFbT) which is FbT calculated at multiple thresholds.
However, force evaluation is arguably not a good metric of structural fidelity. Very small physical error at tiny inter-atomic distances can lead to an extremely large force error if atoms become too close together. Such a large force, caused by a very small positional error, would lead to failure on the force metrics even though the structures are very similar on distance measures. For this reason we do not report force metrics in the main body of the paper for our direct prediction results, since our positional model was not trained with any force data and we expect it to make such small positional errors. However, we present them here for completeness, since they are computed automatically upon submission.
The OC20 project computes test DFT calculations on the evaluation server and presents a summary result for all IS2RS position predictions. Such calculations take 10-12 hours and they are not available for the validation set. Thus, we are not able to analyse the results in Tables 7 and 8 in any further detail. Before application to catalyst screening further work may be needed for direct approaches to ensure forces do not explode from atoms being too close together. Each Open Catalyst experiment was ran until convergence for up to 200 hours. Our best result, the large 10 × 10 block-iterative model, requires 7 days of training using the above setting. Each configuration was run at least 3 times in this hardware configuration, including all ablation settings.
We further note that making effective use of our regulariser requires sweeping noise values. These sweeps are dataset dependent and can be carried out using few message passing steps (e.g. a single block iteration).
QM9. Experiments were also run on TPU devices. Each seed was run using 8 TPU devices on a single host for training, and 2 V100 GPU devices for evaluation. QM9 targets were trained between 12-24 hours per experiment.
Following we define std. MAE as : , inputs X i and z i , and standard deviation σ m oft (m) .
Hyper-parameters
Open Catalyst. We list the hyper-parameters used to train the default Open Catalyst experiment. If not specified otherwise (e.g. in ablations of these parameters), experiments were ran with this configuration.
Dynamic batch sizes refers to constructing batches by specifying maximum node, edge and graph counts (as opposed to only graph counts) to better balance computational load. Batches are constructed until one of the limits is reached.
Parameter updates were smoothed using an EMA for the current training step with the current decay value computed through decay = min(decay, (1.0 + step)/(10.0 + step). As discussed in the evaluation, best results on Open Catalyst were obtained by utilising 10 block iterations with 10 message passing layers.
QM9 Table 10 lists QM9 hyper-parameters which primarily reflect the smaller dataset and geometries with fewer long range interactions. |
Antidepressant Potential of Chlorogenic Acid-Enriched Extract from Eucommia ulmoides Oliver Bark with Neuron Protection and Promotion of Serotonin Release through Enhancing Synapsin I Expression
Eucommia ulmoides Oliver (E. ulmoides) is a traditional Chinese medicine with many beneficial effects, used as a tonic medicine in China and other countries. Chlorogenic acid (CGA) is an important compound in E. ulmoides with neuroprotective, cognition improvement and other pharmacological effects. However, it is unknown whether chlorogenic acid-enriched Eucommia ulmoides Oliver bark has antidepressant potential through neuron protection, serotonin release promotion and penetration of blood-cerebrospinal fluid barrier. In the present study, we demonstrated that CGA could stimulate axon and dendrite growth and promote serotonin release through enhancing synapsin I expression in the cells of fetal rat raphe neurons in vitro. More importantly, CGA-enriched extract of E. ulmoides (EUWE) at 200 and 400 mg/kg/day orally administered for 7 days showed antidepressant-like effects in the tail suspension test of KM mice. Furthermore, we also found CGA could be detected in the the cerebrospinal fluid of the rats orally treated with EUWE and reach the level of pharmacological effect for neuroprotection by UHPLC-ESI-MS/MS. The findings indicate CGA is able to cross the blood-cerebrospinal fluid barrier to exhibit its neuron protection and promotion of serotonin release through enhancing synapsin I expression. This is the first report of the effect of CGA on promoting 5-HT release through enhancing synapsin I expression and CGA-enriched EUWE has antidepressant-like effect in vivo. EUWE may be developed as the natural drugs for the treatment of depression.
Introduction
Eucommia ulmoides Oliver (E. ulmoides) known as Du-zhong (in Chinese) or Tuchong (in Japanese), is a traditional Chinese medicine (TCM) used as a tonic medicine in China, Japan, Korea, and other countries for a long time . E. ulmoides has been widely used to tonify the liver and kidney, and strengthen tendons and bones according to the theory of TCM . Pharmacological studies have shown that E. ulmoides exhibits many beneficial effects, including neuroprotection , bone loss prevention , learning and memory improvement , ameliorating insulin resistance , antihypertension , antibacterial , lipid-lowering and anti-obesity , treatment of osteoarthritis and so on. Meanwhile, phytochemical studies have displayed the component complexity of E. ulmoides, from which 112 compounds have been isolated and identified, including 28 lignans, 24 iridoids, 27 phenolics, six steroids, five terpenoids, 13 flavonoids and nine others . Among them, chlorogenic acid (CGA, 3-O-caffeoylquinic acid), a flavonoid with neuroprotection , cognition improvement, and other pharmacological effects , has been frequently used as the quality control marker for E. ulmoides and its preparations. Therefore, CGA, as the mainly active compound of E. ulmoides may be used in treatment of various diseases of central nervous system (CNS). Usually, as the most important feature for the agents used in treatment of CNS diseases, the penetration ability of crossing the blood-cerebrospinal fluid barrier (BLB) and blood-brain barrier (BBB) is critical for their therapeutic effect in the CNS . However, CGA does not seem to be beneficial for crossing BLB and BBB due to its good aqueous solubility . Previous study has clearly demonstrated that CGA from E. ulmoides has CNS pharmacological therapeutic activities, but it is unknown whether it can penetrate the BLB and BBB or not. A study by Park et al. showed that CGA isolated from Artemisia capillaris Thunb exhibited a potent antidepressant effect in a mouse model (30 mg/kg/day for 14 day oral administration) . The study supports the idea that CGA may be able to cross the BLB and BBB of mice to display its therapeutical effects.
Depression is a state of affective disorder that can cause deficits in learning, memory and cognition and a major burden on society. These depression-related pathophysiological changes could be induced by excessive exposure to glucocorticoids, whose secretion is regulated by negative feedback loop in response to short-span mild stress . However, this feedback regulation is lost when exposed to major or prolonged stress, causing a significant rise of glucocorticoid levels . A main and potent glucocorticoid, corticosterone (Cort) could decrease serotonin (5-HT or 5-hydroxytryptamine) release and lead to neurodegeneration when chronic exposure to stress levels of Cort , which provided a basis for understanding the impairment of 5-HT decrease in depressive illness. Furthermore, clinical studies found that the hippocampal volume and the level of 5-HT were decreased in the patients with major depression . Meanwhile, agents with enhancing 5-HT concentration at the synapse could alleviate the symptoms of depression . Actually, 5-HT is an important monoamine neurotransmitter and can be found in neurons, platelets, mast cells, and enterochromaffin cells. Because 5-HT cannot cross the BBB, the brain synthesizes its own 5-HT which accounts for 1%-2% of the whole 5-HT supply of body, which is exclusively expressed in the dorsal and median raphe of the rostral brain, a heterogeneous region located between the periaquaduct and fourth ventricle of the midbrain . However, numerous evidence indicates that the expression level of synapsin I, a presynaptic phosphoprotein that anchors synaptic vesicles containing neurotransmitters to the actin cytoskeleton in the distal pool, is positively associated with the maturation of 5-HT release mechanisms and structural maintenance of presynaptic terminals , as well as neuronal differentiation, axonal outgrowth and synaptogenesis . Those revelations indicate that 5-HT release via synapsin I plays the key role in the depression. As mentioned above, CGA from the extract of E. ulmoides is involved various CNS pharmacological and therapeutic activities, but the mode of action and associated mechanism(s) are still unclear. In the present study, we investigate whether CGA can protect neurons from Cort-induced injury and promote 5-HT release through enhancing synapsin I expression in the cultured cells of fetal rat raphe neurons in vitro and CGA-enriched water extract from E. ulmoides (EUWE) can cross BLB of rats and exhibit antidepressant-like effect in mice in vivo.
CGA Promotes the Cell Growth of Fetal Rat Raphe Neurons in Vitro
In order to study the protective effect of CGA on Cort-induced cell injury of fetal rat raphe neurons, cell-proliferative assay was performed in vitro with cultured cells of raphe neurons treated Figure 1, treatment with 10 µM Cort decreased the cell growth of raphe neurons, whereas CGA reversed the Cort-induced decrease of raphe neurons in a dose-dependent ( Figure 1A) and time-dependent ( Figure 1B) manner. Furthermore, although CGA alone does not affect the cell growth of neurons as similar to the cells of control morphologically ( Figure 1C,D), we demonstrate that the inhibition of cell growth by Cort (10 µM) is involved in neuron damage including cell body atrophy, axon and dendrite loss ( Figure 1E). Whereas CGA (1 nM) prevents Cort-induced cell damage of raphe neurons by stimulating new axon and dendrite growth ( Figure 1F), suggesting the pharmacological effect of CGA on protection of Cort-induced neuron damage is likely to be associated with neurogenesis, which has been proved to be an important factor for antidepressant efficacy . although CGA alone does not affect the cell growth of neurons as similar to the cells of control morphologically ( Figure 1C,D), we demonstrate that the inhibition of cell growth by Cort (10 µM) is involved in neuron damage including cell body atrophy, axon and dendrite loss ( Figure 1E). Whereas CGA (1 nM) prevents Cort-induced cell damage of raphe neurons by stimulating new axon and dendrite growth ( Figure 1F), suggesting the pharmacological effect of CGA on protection of Cort-induced neuron damage is likely to be associated with neurogenesis, which has been proved to be an important factor for antidepressant efficacy .
Effect of CGA on 5-HT Release in the Cells of Fetal Rat Raphe Neurons in Vitro
In order to study the effect of CGA on 5-HT release, Enzyme-linked immunosorbent assay (ELISA) was applied to examine the concentrations of 5-HT in the cultured cells of fetal rat raphe neurons after the cells were treated with 10 µM Cort alone or in combination with CGA at 0.5 nM or 1.0 nM. As shown in Figure 2, the level of 5-HT in culture supernatant is significantly reduced after treatment with 10 µM Cort compared to that of the control (p < 0.01), however, the reduction induced by Cort is remarkably averted by co-treatment with 0.5 and 1 nM CGA (p < 0.01). These results suggest that CGA may promote 5-HT release in the cells of fetal rat raphe neurons.
Effect of CGA on 5-HT Release in the Cells of Fetal Rat Raphe Neurons in Vitro
In order to study the effect of CGA on 5-HT release, Enzyme-linked immunosorbent assay (ELISA) was applied to examine the concentrations of 5-HT in the cultured cells of fetal rat raphe neurons after the cells were treated with 10 µM Cort alone or in combination with CGA at 0.5 nM or 1.0 nM. As shown in Figure 2, the level of 5-HT in culture supernatant is significantly reduced after treatment with 10 µM Cort compared to that of the control (p < 0.01), however, the reduction induced by Cort is remarkably averted by co-treatment with 0.5 and 1 nM CGA (p < 0.01). These results suggest that CGA may promote 5-HT release in the cells of fetal rat raphe neurons.
CGA Enhances the Expression of Synapsin I of the Cells of Fetal Rat Raphe Neurons in Vitro
Synapsin I is an abundant synaptic vesicle-related protein that plays a critical role in the regulation of neurotransmitter release . We hypothesized that synapsin I may involve in the neurotransmitter release in neurons. For this purpose, we used anti-synapsin I to examine the location and expression of synapsin I in cultured cells of fetal rat raphe neurons. The fluorescence images shown in Figure 3 illustrate 14-day-old cells of fetal rat raphe neurons, at which point synapsin I distributes to presynaptic terminals in a punctuate manner, concurrent with the formation of synaptic network in normal neurons ( Figure 3A). CGA at 1.0 nM has no significant effect on the cells of neurons ( Figure 3B). However, the loss of synapsin I puncta and the synaptic network is obvious in the cells of neurons treated with Cort at the concentration of 10 µM ( Figure 3C). In contrast to Cort-treated cells of neurons, the loss of synapsin I puncta and the synaptic network are prevented by the co-treatment with CGA at the concentration of 1 nM ( Figure 3D). Western blot analysis shows that synapsin I expression levels are significantly down-regulated in Cort-treated cells of neurons compared to that of normal control (p < 0.01), while it is significantly up-regulated in Cort plus CGA-treated group compared to that of Cort-treated group (p < 0.01), even much higher than that of control, quantified by densitometric analysis (Figure 4). These results indicate that the neurotransmitter release caused by CGA is associated with the expression of synapsin I, suggesting a possible mechanism involved in presynaptic vesicle-related proteins and related signaling pathways. The results are representative of at least three independent experiments run in triplicate and expressed as the mean˘SD. ** p < 0.01 vs. Cort-treated group. The control cells were treated with culture medium with 0.1% DMSO.
CGA Enhances the Expression of Synapsin I of the Cells of Fetal Rat Raphe Neurons in Vitro
Synapsin I is an abundant synaptic vesicle-related protein that plays a critical role in the regulation of neurotransmitter release . We hypothesized that synapsin I may involve in the neurotransmitter release in neurons. For this purpose, we used anti-synapsin I to examine the location and expression of synapsin I in cultured cells of fetal rat raphe neurons. The fluorescence images shown in Figure 3 illustrate 14-day-old cells of fetal rat raphe neurons, at which point synapsin I distributes to presynaptic terminals in a punctuate manner, concurrent with the formation of synaptic network in normal neurons ( Figure 3A). CGA at 1.0 nM has no significant effect on the cells of neurons ( Figure 3B). However, the loss of synapsin I puncta and the synaptic network is obvious in the cells of neurons treated with Cort at the concentration of 10 µM ( Figure 3C). In contrast to Cort-treated cells of neurons, the loss of synapsin I puncta and the synaptic network are prevented by the co-treatment with CGA at the concentration of 1 nM ( Figure 3D). Western blot analysis shows that synapsin I expression levels are significantly down-regulated in Cort-treated cells of neurons compared to that of normal control (p < 0.01), while it is significantly up-regulated in Cort plus CGA-treated group compared to that of Cort-treated group (p < 0.01), even much higher than that of control, quantified by densitometric analysis (Figure 4). These results indicate that the neurotransmitter release caused by CGA is associated with the expression of synapsin I, suggesting a possible mechanism involved in presynaptic vesicle-related proteins and related signaling pathways.
EUWE Shows Antidepressant-like Effect in the Tail Suspension Test of KM Mice in Vivo
The tail suspension test is widely used for screening potential antidepressants. The immobility behavior displays in rodents when subjected to an unavoidable and inescapable stress has been hypothesized to reflect behavioral despair which in turn to reflect similar depressive disorders in human. There is, indeed, a significant correlation between clinical potency and effectiveness of antidepressants . In proof-of-principle study for antidepressant effect of EUWE, we performed the tail suspension test in KM mice with EUWE at 200 and 400 mg/kg/day daily for 7 days, while same volume of distilled water as vehicle control and fluoxetine at 8 mg/kg/day as positive control. As the data shown in Figure 5, the duration of immobility is highest in the distilled water-treated group (control, 130.3˘15.9 s), however, it is significantly lessened in fluoxetine (109.1˘17.8 s) or EUWE-treated (115.2˘16.0 and 109.8˘21.9 s, respectively) groups compared to that of control group (p < 0.05), indicating EUWE may have antidepressant effects in vivo.
EUWE Shows Antidepressant-like Effect in the Tail Suspension Test of KM Mice in Vivo
The tail suspension test is widely used for screening potential antidepressants. The immobility behavior displays in rodents when subjected to an unavoidable and inescapable stress has been hypothesized to reflect behavioral despair which in turn to reflect similar depressive disorders in human. There is, indeed, a significant correlation between clinical potency and effectiveness of antidepressants . In proof-of-principle study for antidepressant effect of EUWE, we performed the tail suspension test in KM mice with EUWE at 200 and 400 mg/kg/day daily for 7 days, while same volume of distilled water as vehicle control and fluoxetine at 8 mg/kg/day as positive control. As the data shown in Figure 5, the duration of immobility is highest in the distilled water-treated group (control, 130.3 ± 15.9 s), however, it is significantly lessened in fluoxetine (109.1 ± 17.8 s) or EUWE-treated (115.2 ± 16.0 and 109.8 ± 21.9 s, respectively) groups compared to that of control group (p < 0.05), indicating EUWE may have antidepressant effects in vivo.
Qualitative Analysis of CGA in the CSF of the Rats Treated with CGA-Enriched Water Extract of E. ulmoides
After we demonstrated the pharmacological effects of CGA on the cells of fetal rat raphe neurons, next, we investigate whether CGA can be absorbed into the CSF of the rats treated with CGA-Enriched water extract of E. ulmoides (EUWE). In order to qualitative analysis of CGA in the CSF of rat, ultra high performance liquid chromatography coupled to tandem mass spectrometry (UHPLC-ESI-MS/MS) was employed in positive and negative scan modes to optimize conditions of mass spectrum ( Figure 6A,B). Then MS/MS spectrum of m/z 353.10 in the negative ion mode was acquired ( Figure 6C), and MRM mode was used to monitor both quasimolecular and fragment ions. Therefore, MRM chromatogram of m/z 353.10 > m/z 191.15 and m/z 353.10 > m/z 179.00 for CGA and CSF samples in the rats treated with EUWE were obtained, respectively ( Figure 6D,E). The MRM negative mode was selected due to high sensitivity. As shown in Figure 7, the retention time and mass spectra of the CSF samples in the rats treated with EUWE are similar to that of CGA, indicating the CSF samples may contain CGA.
To further identify whether the CSF of the rats treated with EUWE contains CGA, UHPLC-ESI-MS/MS with both positive and negative ion modes were employed to study the fragmentation behaviors of authentic standard of CGA in ESI-MS/MS at first in order to facilitate the structure characterization of the marker constituent. The marker constituent are identified according to their fragmentation data and comparison with the authentic standard from previous studies . The ion fragmentations and structure of marker constituent are shown in Figure 7 and Scheme 1. After we demonstrated the pharmacological effects of CGA on the cells of fetal rat raphe neurons, next, we investigate whether CGA can be absorbed into the CSF of the rats treated with CGA-Enriched water extract of E. ulmoides (EUWE). In order to qualitative analysis of CGA in the CSF of rat, ultra high performance liquid chromatography coupled to tandem mass spectrometry (UHPLC-ESI-MS/MS) was employed in positive and negative scan modes to optimize conditions of mass spectrum ( Figure 6A,B). Then MS/MS spectrum of m/z 353.10 in the negative ion mode was acquired ( Figure 6C), and MRM mode was used to monitor both quasimolecular and fragment ions. Therefore, MRM chromatogram of m/z 353.10 > m/z 191.15 and m/z 353.10 > m/z 179.00 for CGA and CSF samples in the rats treated with EUWE were obtained, respectively ( Figure 6D,E). The MRM negative mode was selected due to high sensitivity. As shown in Figure 7, the retention time and mass spectra of the CSF samples in the rats treated with EUWE are similar to that of CGA, indicating the CSF samples may contain CGA.
To further identify whether the CSF of the rats treated with EUWE contains CGA, UHPLC-ESI-MS/MS with both positive and negative ion modes were employed to study the fragmentation behaviors of authentic standard of CGA in ESI-MS/MS at first in order to facilitate the structure characterization of the marker constituent. The marker constituent are identified according to their fragmentation data and comparison with the authentic standard from previous studies . The ion fragmentations and structure of marker constituent are shown in Figure 7 , which are also observed in the MS spectrum of the authentic standard. Therefore, the data demonstrate that the CSF of the rats treated with EUWE contains CGA and CGA-enriched EUWE can be absorbed into CSF of rats, indicating that CGA can cross the BLB of rats. , which are also observed in the MS spectrum of the authentic standard. Therefore, the data demonstrate that the CSF of the rats treated with EUWE contains CGA and CGA-enriched EUWE can be absorbed into CSF of rats, indicating that CGA can cross the BLB of rats.
Quantitative Measurement of CGA in the CSF of Rat
In order to achieve a better MS condition, both CGA and toosendanin (TSN, as the internal standard) were examined by negative scan in the MS or MS/MS scan mode ( Figure 8A-D). Then MRM mode was used to monitor both quasimolecular and fragment ions, in which channel ESI − m/z 353.10 > m/z 191.15 was selected for CGA and channel ESI − m/z 573.15 > m/z 531.15 was selected for TSN. Notably, no endogenous interfering peaks are observed at or near the retention times of CGA and TSN by comparing with blank CSF, and TSN doesn't contribute to CGA signal ( Figure 8E-H), indicating that CGA doesn't contribute to TSN response and endogenous interfering. Consequently, these results suggest the method has high selectivity for the measurement of CGA.
The calibration curve of CGA in the CSF of rat was constructed by plotting peak area ratios of CGA using the weight (1/C) linear regression. The method shows good linearity over the range from 0.5 to 200 ng/mL with a correlation coefficient r >0.999. The typical calibration curve is presented in Figure 9. The lower limit of quantitation is 0.5 ng/mL. The intra-day accuracy is 111.3% and the relative standard deviation (RSD) of intra-day precision is 7.11% at the concentration of 0.5 ng/mL. In addition, the matrix effect of CGA is 106.15%. Therefore, the method was proved to be sensitive for the measurement of CGA in the CSF of rat.
The established UHPLC-ESI-MS/MS analytical method was subsequently used to determine the CGA concentration in the CSF of the rats treated with EUWE at the dose of 4.0 g/kg and the mean CGA
Quantitative Measurement of CGA in the CSF of Rat
In order to achieve a better MS condition, both CGA and toosendanin (TSN, as the internal standard) were examined by negative scan in the MS or MS/MS scan mode ( Figure 8A-D). Then MRM mode was used to monitor both quasimolecular and fragment ions, in which channel ESI − m/z 353.10 > m/z 191.15 was selected for CGA and channel ESI − m/z 573.15 > m/z 531.15 was selected for TSN. Notably, no endogenous interfering peaks are observed at or near the retention times of CGA and TSN by comparing with blank CSF, and TSN doesn't contribute to CGA signal ( Figure 8E-H), indicating that CGA doesn't contribute to TSN response and endogenous interfering. Consequently, these results suggest the method has high selectivity for the measurement of CGA.
The calibration curve of CGA in the CSF of rat was constructed by plotting peak area ratios of CGA using the weight (1/C) linear regression. The method shows good linearity over the range from 0.5 to 200 ng/mL with a correlation coefficient r >0.999. The typical calibration curve is presented in Figure 9. The lower limit of quantitation is 0.5 ng/mL. The intra-day accuracy is 111.3% and the relative standard deviation (RSD) of intra-day precision is 7.11% at the concentration of 0.5 ng/mL. In addition, the matrix effect of CGA is 106.15%. Therefore, the method was proved to be sensitive for the measurement of CGA in the CSF of rat.
The established UHPLC-ESI-MS/MS analytical method was subsequently used to determine the CGA concentration in the CSF of the rats treated with EUWE at the dose of 4.0 g/kg and the mean CGA Scheme 1. The chemical structures and metabolic pathway of CGA fragmentations identified in the CSF of the rats treated with EUWE (4.0 g/kg).
Quantitative Measurement of CGA in the CSF of Rat
In order to achieve a better MS condition, both CGA and toosendanin (TSN, as the internal standard) were examined by negative scan in the MS or MS/MS scan mode ( Figure 8A-D). Then MRM mode was used to monitor both quasimolecular and fragment ions, in which channel ESI´m/z 353.10 > m/z 191.15 was selected for CGA and channel ESI´m/z 573.15 > m/z 531.15 was selected for TSN. Notably, no endogenous interfering peaks are observed at or near the retention times of CGA and TSN by comparing with blank CSF, and TSN doesn't contribute to CGA signal ( Figure 8E-H), indicating that CGA doesn't contribute to TSN response and endogenous interfering. Consequently, these results suggest the method has high selectivity for the measurement of CGA.
The calibration curve of CGA in the CSF of rat was constructed by plotting peak area ratios of CGA using the weight (1/C) linear regression. The method shows good linearity over the range from 0.5 to 200 ng/mL with a correlation coefficient r >0.999. The typical calibration curve is presented in Figure 9. The lower limit of quantitation is 0.5 ng/mL. The intra-day accuracy is 111.3% and the relative standard deviation (RSD) of intra-day precision is 7.11% at the concentration of 0.5 ng/mL. In addition, the matrix effect of CGA is 106.15%. Therefore, the method was proved to be sensitive for the measurement of CGA in the CSF of rat.
The established UHPLC-ESI-MS/MS analytical method was subsequently used to determine the CGA concentration in the CSF of the rats treated with EUWE at the dose of 4.0 g/kg and the mean CGA concentrations are 0.41954 ng/mL (1.184 nM) and 0.56224 ng/mL (1.588 nM) for 60 min and 90 min, respectively. concentrations are 0.41954 ng/mL (1.184 nM) and 0.56224 ng/mL (1.588 nM) for 60 min and 90 min, respectively.
Discussion
The present study aimed to explore whether CGA can protect from Cort-induced damage and promote 5-HT release through synapsin I expressionin in the cells of fetal rat raphe neurons in vitro and cross BLB of the rats orally treated with CGA-enriched EUWE in vivo. Our results indicate that CGA can indeed stimulate axon and dendrite growth, promote 5-HT release and enhance synapsin I expression in the cultured cells of fetal rat raphe neurons evidenced by immunofluorescence staining and western blots analysis. More important, our study of in vivo antidepressant-like effect in the tail suspension test of mice demonstrated that CGA-enriched EUWE exhibited antidepressant effect ( Figure 5). Furthermore, our results also show that CGA could be detected in the CSF of the rats orally treated with CGA-enriched EUWE at 4.0 g/kg and reach to the level of pharmacological effect for neuroprotection, indicating CGA can pass through the BLB of the rats treated with EUWE. Therefore, our findings suggest that CGA and CGA-enriched EUWE may have the potential to become the natural drugs for the treatment of depression. However, their action mode and associated mechanism(s) with anti-depression are still unclear and need to be further investigated.
Synapsin I is a presynaptic phosphoprotein that anchors synaptic vesicles containing neurotransmitters to the actin cytoskeleton in the distal pool . The striking evidence indicates that the expression level of synapsin I is positively associated with the maturation of neurotransmitter release mechanisms . In the present study, we found CGA significantly promoted 5-HT release and stimulated synapsin I expression in the cells of fetal rat raphe neurons in vitro, which may provide
Discussion
The present study aimed to explore whether CGA can protect from Cort-induced damage and promote 5-HT release through synapsin I expressionin in the cells of fetal rat raphe neurons in vitro and cross BLB of the rats orally treated with CGA-enriched EUWE in vivo. Our results indicate that CGA can indeed stimulate axon and dendrite growth, promote 5-HT release and enhance synapsin I expression in the cultured cells of fetal rat raphe neurons evidenced by immunofluorescence staining and western blots analysis. More important, our study of in vivo antidepressant-like effect in the tail suspension test of mice demonstrated that CGA-enriched EUWE exhibited antidepressant effect ( Figure 5). Furthermore, our results also show that CGA could be detected in the CSF of the rats orally treated with CGA-enriched EUWE at 4.0 g/kg and reach to the level of pharmacological effect for neuroprotection, indicating CGA can pass through the BLB of the rats treated with EUWE. Therefore, our findings suggest that CGA and CGA-enriched EUWE may have the potential to become the natural drugs for the treatment of depression. However, their action mode and associated mechanism(s) with anti-depression are still unclear and need to be further investigated.
Synapsin I is a presynaptic phosphoprotein that anchors synaptic vesicles containing neurotransmitters to the actin cytoskeleton in the distal pool . The striking evidence indicates that the expression level of synapsin I is positively associated with the maturation of neurotransmitter release mechanisms . In the present study, we found CGA significantly promoted 5-HT release and stimulated synapsin I expression in the cells of fetal rat raphe neurons in vitro, which may provide valuable information for the applications of CGA and CGA-enriched EUWE in potential treatment of depressive disorders in clinic.
However, synapsin I controls the fraction of synaptic vesicles available for release and thereby regulates the efficiency of neurotransmitter release by changing its phosphorylation state . The phosphorylation of synapsin I is mediated by multiple protein kinases involved in various signaling pathways, including extracellular signal-regulated kinase (ERK) in mitogen-associated protein kinase (MAPK)/ERK pathway that modulates presynaptic plasticity and learning , protein kinase A (PKA) in cAMP-dependent pathway that modulates synaptic vesicle exocytosis , and Ca 2+ /calmodulin-dependent protein kinase II (CaMK II) that modulates neurotransmitter release and synaptic plasticity . Therefore, our further investigation into the molecular mechanisms associated with the anti-depression effects of CGA and CGA-enriched EUWE should include the study of phosphorylation of the respective site-specific kinases ERK, PKA and CaMK II in MAPK/ERK, cAMP/PKA, and Ca 2+ /CaMK II pathways, which are upstream of synapsin I.
As we all know, several brain regions including hippocampus have been involved in depression. The hippocampus is an important region of the brain that is in charge of numerous cognitive and behavioral functions and related to the systems of 5-HT and glutamate, which are involved in the mechanism of action of antidepressants so the hippocampus is a key region in which to study depression . Moreover, 5-HT has been shown to regulate synaptic neurotransmission in the hippocampus . However, 5-HT is exclusively expressed in the dorsal and median raphe in the brain . Then in order to study the effect of CGA and CGA-enriched EUWE on 5-HT release and its effects in hippocampus simultaneously, the method with a neuronal raphe/hippocampal co-culture in vitro should be developed to perform electrophysiological experiments as literature reported .
A most important feature for development of antidepressant is the ability to cross BLB and BBB in vivo to display its therapeutic efficacy . In the present study, our data demonstrate that CGA-enriched EUWE at 200 and 400 mg/kg/day for 7 days showed antidepressant-like effect in the tail suspension test of mice and CGA from the rats orally treated with CGA-enriched EUWE can be detected in the CSF of rats by UHPLC-ESI-MS/MS analyses, indicating that CGA from EUWE can cross the BLB of the rats. This is the basic for further development of CGA and CGA-enriched EUWE as the antidepressants.
Plant Material and Extraction
The bark of E. ulmoides used in this study was purchased from Taiji Group Limited Company (Chongqing, China), and were authenticated by Professor Can Tang at the Sichuan Medical University (Luzhou, Sichuan, China). The dry bark of E. ulmoides (100 g) was extracted three times with 1 L distilled water at 100˝C for 60 min each. Then the total extract was concentrated to dryness using a rotary vacuum evaporator and yielded 10.26 g dried extract. This crude EUWE was used for the experiments.
Animals and Sample Collection
Eight-to-ten-week old (body weight 250-300 g), and pregnant (16-20 weeks old and body weight 300-350 g, for primary raphe neuron study) Sprague Dawley rats (SPF Grade, Certificate No. SCXK2013-24) and Six-to-eight-week old (body weight 20-25 g) KM mice (for tail suspension test, SPF Grade, Certificate No. SCXK2013-24) were purchased from Experimental Animal Centre, Sichuan Provincial Academy of Medical Sciences in China (Chengdu, Sichuan, China). All animal experiments were performed in accordance with institutional guidelines and were approved by the Committee on Use and Care of Animals, Sichuan, China (Permit number: SYXK2013-065). All animals were housed under standard environmental conditions and fed with standard diet and water ad libitum. The adult rats in the EUWE group were administrated orally with a single dose of 4.0 g/kg EUWE and in the control group with same volume of deionized water before the CSF samples were collected. According to literature , rats were anesthetized by 40 mg/kg pentobarbitone, then the atlanto-occipital membrane was exposed by blunt dissection. CSF was collected by lowering a 25-gauge needle attached to polyethylene tubing into the cisterna magna. The pregnant Sprague Dawley rats on embryonic day 15 were used for preparing primary raphe neurons as literature reported .
Cell Culture and Treatment
The cells of primary raphe neurons were prepared from pregnant Sprague Dawley rats on embryonic day 15 as previously reported with slight modification . Briefly, cells were gently dissociated with a pasteur pipette after digestion with 0.125% trypsin for 15 min at 37˝C, plated at a final density of 1ˆ10 6 cells/well on polylysine-coated 6-well plates and cultured at 37˝C in a 5% CO 2 humidified incubator. After 24 h culture, the DMEM medium (with 10% FBS) was replaced by neurobasal medium containing 2% B-27 supplement. For cell proliferative assay, the cells of neurons were seeded into 96-well plates at a density of 3ˆ10 4 cells/well and treated with 10 µM Cort for 24 h, then CGA was applied with different concentrations (0.001, 0.01, 0.1, 1 and 10 µM) or same volume of culture medium containing 0.1% DMSO as control. The assays were performed on the 2nd, 4th, 6th, 8th day using the Dojindo Cell Counting kit-8 according to the instruction supplied by the manufacturer. Absorbance values (490 nm) were recorded in triplicate using M5 Microplate Reader (Molecular Devices, Sunnyvale, CA, USA).
Neurotransmitter Detection
CGA was applied to Cort-pretreated cells of neurons for 5 days. Then the cells were washed 3 times and incubated in KPH buffer (130 mM NaCl, 5 mM KCl, 1.2 mM NaH 2 PO 4 , 1.8 mM CaCl 2 , 10 mM glucose, 1% BSA, 25 mM HEPES, pH 7.4) for 10 min at 37˝C, and subjected to 0.5 nM or 1.0 nM CGA, all treatments were brought up to final concentration in neurobasal medium containing 2% B-27 supplement. After 10 days, the supernatants were concentrated 10-fold using a nitrogen evaporator and the levels of 5-HT were determined using a rat 5-HT ELISA kit.
Immunofluorescence Staining
CGA (1 nM) was applied to Cort-pretreated cells of neurons for 8 days. The cells were fixed with 4% paraformaldehyde containing 0.05% Triton X-100 for 20 min and rinsed with PBS. After blocked with 4% BSA, the cells were incubated overnight at 4˝C with anti-synapsin I antibody (1:50). Afterward, fluorescein isothiocyanate (FITC) conjugated secondary antibodies (1:100) were applied at room temperature for 1 h. Immunoreactivity was observed with an IX51 fluorescence microscope (Olympus, Tokyo, Japan).
Western Blot Analysis
Neurons were harvested after 7 days CGA (1 nM), and/or Cort (10 µM) or medium with 0.1% DMSO (control) treatment and disrupted in cell RIPA buffer (0.5% NP-40, 50 mM Tris-HCl, 120 mM NaCl, 1 mM EDTA, 0.1mM Na 3 VO 4 , 1 mM NaF, 1 mM PMSF, 1 µg/mL leupeptin, pH 7.5), and then lysates were centrifuged at 12,000 rpm for 15 min at 4˝C. The protein concentration was determined using the BCA method, after which equal amounts of protein (30 µg) were electrophoresedon 10% density SDS-acrylamide gels. Following electrophoresis, the proteins were transferred from the gel to a nitrocellulose membrane using an electric transfer system. Non-specific binding was blocked with 5% skim milk in TBST buffer (5 mM Tris-HCl, pH 7.6, 136 mM NaCl and 0.1% Tween-20) for 1 h. The blots were incubated with antibodies against synapsin I (1:200) overnight at 4˝C and were washed three times with 1ˆTBST. Then, the blots were incubated for 1 h at room temperature with a 1:5000 dilution of horseradish peroxidase-labeled anti-rabbit or anti-mouse IgG and washed three times with 1ˆTBST, the membranes were developed by incubation within the ECL western detection reagents.
Tail Suspension Test of Mice
The experiments were performed according to the method of Park et al. . Briefly, forty-eight male KM mice were divided into four groups, and the mice were treated orally with distilled water (vehicle control), fluoxetine (FLX) at 8 mg/kg (as positive control), or EUWE at 200 and 400 mg/kg/day with a volume of 0.2 mL/20 g of body weight once a day for 7 days. One hour after the last administration of vehicle, FLX or EUWE, the mice were suspended by the tail to a horizontal ring stand bar (distance from floor 25 cm) using adhesive tape (distance from tip of tail 2 cm). Then the duration of immobility was recorded for the last 4 min during 6-min test session. There are 12 mice for each experimental group.
UHPLC-ESI-MS/MS Analysis
The UHPLC-ESI-MS/MS analyses were performed on a Shimadzu LCMS-8040 UHPLC system comprised of two LC-30AD pumps, a SIL-30AC autosampler with a CTO-30AC column oven, a DGU-20A 5 degasser, a Shimadzu CBM-20A system controller, a Labsolution LCMS Ver.5.75 workstation, an ESI ion source and a LCMS-8040 mass spectrometer. Chromatographic analyses were achieved at 45˝C with an InertSustain C18 column (GL Science, 2.0 µM particle size, 50 mmˆ2.1 mm), using water-formic acid (100:0.05, v/v) and acetonitrile as the mobile phase A and phase B, respectively. The mobile phase was delivered at a rate of 0.35 mL/min. The injection volume was 10 µL. For the gradient separation, the gradient program was as follows: 5%-5% B at 0-0.8 min, 5%-100% B at 0.8-1.3 min, 100%-100% B at 1.3-2.5 min, 100%-5% B at 2.5-3.0 min, 5%-5% B at 3.0-4.0 min. For mass detection, the mass spectrometer was programmed to carry out a full scan over m/z 100-500 (MS 1 ) and the secondary mass spectrum data were collected by dependence pattern (MS 2 ) in positive ion and negative ion detection modes with a spray capillary voltage of 3.0 kV. The detector voltage was 2.04 kV. The desolvation line was heated to 250˝C and the heat block was heated to 450˝C. Nebulizing gas was introduced at 2.5 L/min, and the drying gas was set to 10.0 L/min. Collision-induced dissociation gas pressure was set to 230 kPa. The data analysis was performed using LabSolutions software (version 5.75, Shimadzu).
Statistical Analysis
All data were presented as means˘SD. The statistical significance of the data was analyzed by one-way analysis of variance (ANOVA), and values of p < 0.05 were considered statistically significant.
Conclusions
In the present study, we demonstrated that CGA plays an important role in neuron protection, promotion of 5-HT release and enhancement of synapsin I expression in the cultured cells of fetal rat raphe neurons. Furthermore, using UHPLC-ESI-MS/MS we also detected and identified CGA in the CSF of the rats after oral administration of CGA-enriched EUWE, indicating CGA could pass through the BLB of rats treated with EUWE in vivo. These results may provide important insights into potential discovery and development of CGA and CGA-enriched EUWE as the new antidepressants clinically. However, more studies are needed to further investigate the action mode and associated mechanism(s) of CGA and EUWE as the novel antidepressants. In addition, the in vivo antidepressant efficacy of CGA and EUWE should be tested in animal models of depression to validate the results. |
/*
* Calculate the ULP checksum - try to use hardware.
* In the case of MULTIRT, broadcast or multicast the
* IXAF_NO_HW_CKSUM is set in which case we use software.
*
* If the hardware supports IP header checksum offload; then clear the
* contents of IP header checksum field as expected by NIC.
* Do this only if we offloaded either full or partial sum.
*
* Returns B_FALSE if the packet was too short for the checksum. Caller
* should free and do stats.
*/
static boolean_t
ip_output_cksum_v4(iaflags_t ixaflags, mblk_t *mp, ipha_t *ipha,
ip_xmit_attr_t *ixa, ill_t *ill)
{
uint_t pktlen = ixa->ixa_pktlen;
uint16_t *cksump;
uint16_t hck_flags;
uint32_t cksum;
uint8_t protocol = ixa->ixa_protocol;
uint16_t ip_hdr_length = ixa->ixa_ip_hdr_length;
if ((ixaflags & IXAF_NO_HW_CKSUM) || !ILL_HCKSUM_CAPABLE(ill) ||
!dohwcksum) {
return (ip_output_sw_cksum_v4(mp, ipha, ixa));
}
if (protocol == IPPROTO_TCP) {
cksump = IPH_TCPH_CHECKSUMP(ipha, ip_hdr_length);
cksum = IP_TCP_CSUM_COMP;
} else if (protocol == IPPROTO_UDP) {
cksump = IPH_UDPH_CHECKSUMP(ipha, ip_hdr_length);
cksum = IP_UDP_CSUM_COMP;
} else if (protocol == IPPROTO_SCTP) {
sctp_hdr_t *sctph;
ASSERT(MBLKL(mp) >= (ip_hdr_length + sizeof (*sctph)));
sctph = (sctp_hdr_t *)(mp->b_rptr + ip_hdr_length);
sctph->sh_chksum = 0;
#ifdef DEBUG
if (!skip_sctp_cksum)
#endif
sctph->sh_chksum = sctp_cksum(mp, ip_hdr_length);
goto ip_hdr_cksum;
} else if (protocol == IPPROTO_ICMP) {
return (ip_output_sw_cksum_v4(mp, ipha, ixa));
} else {
ip_hdr_cksum:
ipha->ipha_hdr_checksum = 0;
ipha->ipha_hdr_checksum = ip_csum_hdr(ipha);
return (B_TRUE);
}
ASSERT(((uchar_t *)cksump) + sizeof (uint16_t) <= mp->b_wptr);
hck_flags = ill->ill_hcksum_capab->ill_hcksum_txflags;
DB_CKSUMFLAGS(mp) &= ~HCK_FLAGS;
if (hck_flags & HCKSUM_INET_FULL_V4) {
*cksump = 0;
DB_CKSUMFLAGS(mp) |= HCK_FULLCKSUM;
ipha->ipha_hdr_checksum = 0;
if (hck_flags & HCKSUM_IPHDRCKSUM) {
DB_CKSUMFLAGS(mp) |= HCK_IPV4_HDRCKSUM;
} else {
ipha->ipha_hdr_checksum = ip_csum_hdr(ipha);
}
return (B_TRUE);
}
if ((hck_flags) & HCKSUM_INET_PARTIAL) {
ipaddr_t dst = ipha->ipha_dst;
ipaddr_t src = ipha->ipha_src;
cksum += (dst >> 16) + (dst & 0xFFFF) +
(src >> 16) + (src & 0xFFFF);
cksum += *(cksump);
cksum = (cksum & 0xFFFF) + (cksum >> 16);
*(cksump) = (cksum & 0xFFFF) + (cksum >> 16);
DB_CKSUMSTART(mp) = ip_hdr_length;
DB_CKSUMSTUFF(mp) = (uint8_t *)cksump - (uint8_t *)ipha;
DB_CKSUMEND(mp) = pktlen;
DB_CKSUMFLAGS(mp) |= HCK_PARTIALCKSUM;
ipha->ipha_hdr_checksum = 0;
if (hck_flags & HCKSUM_IPHDRCKSUM) {
DB_CKSUMFLAGS(mp) |= HCK_IPV4_HDRCKSUM;
} else {
ipha->ipha_hdr_checksum = ip_csum_hdr(ipha);
}
return (B_TRUE);
}
return (ip_output_sw_cksum_v4(mp, ipha, ixa));
} |
/**
* Communicates the popup form with the {@code Memory} object displayed in the graph
*
* @param event The event that triggered this action
*/
public void calculateDesiredFalseMCUs(ActionEvent event) {
boolean dataOk = true;
resultLabel.setText(null);
falseMCUsError.setText(null);
try {
this.desiredFalseMCUs = Double.parseDouble(falsemcusTextField.getText());
}catch(NumberFormatException e) {
falseMCUsError.setText("Please enter a number");
dataOk = false;
}
if(dataOk) {
Stage stage = (Stage)((Node)event.getSource()).getScene().getWindow();
Memory mem = (Memory) stage.getUserData();
this.resultLabel.setText(mem.findDesiredFalseMCUs(desiredFalseMCUs));
}
} |
Murder Attempt to Murder Homicide not amounting to Murder Rape Custodial Rape Other Rape Kidnapping Kidnapping of Girls/Women Kidnapping of Others Dacoity Preparation for Dacoity Robbery Burglary Theft Auto Theft Other Theft Riots Criminal breach of Trust Cheating Counterfeiting Arson Hurt Dowry Death Assault on Women's Dignity Insult to modesty of women Cruelty by Husband/Relative Importation of Girls from Foreign Countries Death by Negligence Other IPC Crimes
1. Total Crimes Per Year
Not a very exciting graph, but shows a dip in 2003 in total number of crimes, which have been increasing each year
1. How many Crimes Per Lakh Citizens
2. Which States register most Crimes?
Madhya Pradesh Maharashtra Tamil Nadu Andhra Pradesh Uttar Pradesh Rajasthan
3. Which Districts register the most crimes?
Maharashtra - Mumbai Commercial
Gujarat - Ahmedabad Commercial
Madhya Pradesh - Indore
Andhra Pradesh - Hyderabad
This brings forward an observation A
Apart from top districts there are other districts which contribute towards the crime rate in the top crime rate states.
This needs to be checked further.
State District Crimes karnataka bangalore commr 3,50,347 maharashtra mumbai commr. 2,22,670 gujarat ahmedabad commr. 2,18,005 madhya pradehs indore 2,04,398 andhra pradesh hyderabad city 2,0,2931 madhya pradesh bhopal 1,69,575 tamil nadu chennai 1,64,467 west bengal kolkata 1,5,8429 bihar patna 1,47,542 maharashtra mumbai 1,41,815 andhra pradesh cyberabad 1,41,743 maharashtra pune commr. 1,39,973 west bengal parganas north 1,22,795 kerala ernakulam rural 1,22,473 west bengal parganas south 1,20,912 madhya pradesh jabalpur 1,19,446 uttar pradesh lucknow 1,18,377 madhya pradesh gwalior 1,11,206 kerala ernakulam commr 1,04,786 maharashtra nagpur commr 1,04,410
Some points to note:
Maharashtra has 3 districts featured in the list. Mumbai Comm, Pune, Nagpur. All of them are the most populated cities. This trend follows for other states too
West Bengal has 2 Districts, Kolkata & Parganas South & Parganas North Next Article: Murders
Being a populous country, and with a high level of poverty, it is no surprise that the crime rate isin India. With data from 2001-2012, we can deep dive into many factors of crimes in India.What types of crimes does the data contain:I could have taken crimes per person, but as the population is above a billion, the crime statistic looks minuscule. Instead, I have taken per lakh person, as it shows the number of crimes in a city if you know the population of the city. We can see it starts just from above 150 crimes per 1 lakh people in 2001, and goes to 189 crimes per lakh people.Let's see which states are most notorious. Do note, this data tells us the states with total crimes from 2001-2012Top 6 States with most crimesHere I expect districts from the top states in Question 2. But we find something differentTop district in crime rate comes out to be Karnataka - Banglore Commr, while other districts are shown belowAs many Districts have a low crime rate, ignoring them, let's focus on the some of the top onesThe Graph didn't turn out very nice, but we can see some of the top districts.--> |
def rewind_adjoint(self, times, output_grad):
l0 = output_grad[-1]
nt = self.full_times.shape[0]
grad_result = tuple(torch.zeros(p.shape,
device = times.device) for p in self.adjoint_params)
j = times.shape[0]-2
for curr in range(nt-2,-1,-1):
last = curr + 1
tcurr = self.full_times[curr]
tlast = self.full_times[last]
dt = tlast - tcurr
l1 = self._adjoint_update(dt, self.full_jacobian[last], l0)
if self.use_curr:
p = self._get_param_partial(tcurr, self.full_result[curr], l0 * dt[:,None])
else:
p = self._get_param_partial(tlast, self.full_result[last], l1 * dt[:,None])
grad_result = self._accumulate(grad_result, p)
if torch.any(tcurr <= times[j]):
l1 = linear(tcurr, tlast, l1, l0, times[j])
l0 = l1 + output_grad[j]
j -= 1
else:
l0 = l1
return grad_result |
Excuse the back-to-back updates, but we thought some of you would be interested in this awesome tidbit.
Our very own Dr. Jason Wright will be participating in a panel discussion titled "Are We Alone in the Universe", hosted by Ira Flatow at the New York Academy of Sciences. To listen, tune in to the live stream tonight from 7-8:30pm eastern.
Description: The Fermi Paradox—the apparent contradiction between the high probability of the existence of extraterrestrial civilizations and the lack of contact with such civilizations—continues to captivate our minds. Are we alone in the universe or were other civilizations destroyed as a result of ecological catastrophes or conflict? Join our panel of leading physicists and philosophers as they explore Enrico Fermi's question: "Where is everybody?" as well as other questions: How does scientific knowledge direct our future scientific and technological pursuits on Earth and in space? How does science inform human ethics? Does science make us better citizens of the universe?
Featuring:
Adam Frank, PhD Professor of Physics and Astronomy, University of Rochester; author of About Time: Cosmology and Culture at the Twilight of the Big Bang
Stephen M. Gardiner, PhD Professor of Philosophy, University of Washington; author of A Perfect Moral Storm: The Ethical Tragedy of Climate Change
Louisa Preston, PhD Astrobiologist, London; author of forthcoming Goldilocks and the Water Bears: The Search for Life in the Universe
Jason Thomas Wright, PhD Associate Professor of Astronomy and Astrophysics, Pennsylvania State University; Principal Investigator at NASA's Nexus for Exoplanet Systems Science (NExSS)
Moderator Ira Flatow Host of PRI's Science Friday® |
A video posted by celebrity gossip website TMZ reportedly shows how Bieber shouts out “What’s up, bitch?” at Bloom, spurring the English actor to lunge at the 20 year old but not connecting the hit.
Spanish newspaper ABC also claimed other big names such as Paris Hilton were present at Ibiza’s Cipriani restaurant.
The daily added that the entire restaurant erupted in applause after Justin fled the scene.
The UK’s Mirror newspaper quoted witnesses as saying: “Within seconds people intervened. There was some minor pushing and shoving between their entourages. They were eventually separated and Justin, who was being cordial, stayed for a while longer outside the restaurant without incident.”
The British tabloid and other new sources such as the New York Daily News have also reported there may have been some previous ‘beef’ between Bieber and Bloom caused by the pop star’s close friendship with the British heartthrob’s ex Miranda Kerr.
Miranda Kerr. Photo: Brad Barket/Getty Images North America/AFP |
/**
* checkIfAlreadySelected()
* Checks company hasn't already been selected
* @param company
* @return True or false depending on if a company has been found
*/
private boolean checkIfAlreadySelected(Company company)
{
for(Company c : selectedCompanies)
{
if(c.getCompanyCode().equals(company.getCompanyCode()))
{
return true;
}
}
return false;
} |
/**
* Access functionality of the kpathsea library via kpsewhich
* (Easier than implementing a JNI interface, if more clumsy).
* The ProgramRunner interface isn't a perfect match because
* kpathsea doesn't have input and output filetypes etc, but
* this lets us integrate with other parts of TeXlipse with
* minimal effort.
*
* @author Christopher Hoskin
*
*/
public class KpsewhichRunner implements ProgramRunner {
// the currently running program
private ExternalProgram extrun;
public KpsewhichRunner() {
extrun = new ExternalProgram();
}
public String getDescription() {
return "Kpsewhich program";
}
public String getInputFormat() {
// Kpsewhich doesn't have an input format
return null;
}
public String getOutputFormat() {
// Kpsewhich doesn't have an output format
return null;
}
public String getProgramArguments() {
// Not really applicable to us
return "(Not applicable)";
}
/**
* @return the name of the executable program
*/
public String getProgramName() {
String os = System.getProperty("os.name").toLowerCase();
if (os.indexOf("windows") >= 0) {
return getWindowsProgramName();
} else {
return getUnixProgramName();
}
}
/**
* @return the program path and filename from the preferences
*/
public String getProgramPath() {
return TexlipsePlugin.getPreference(getCommandPreferenceName());
}
public void initializeDefaults(IPreferenceStore pref, String path) {
pref.setDefault(getCommandPreferenceName(), path);
//Not sure default argument makes sense for kpsewhich
//pref.setDefault(getArgumentsPreferenceName(), getDefaultArguments());
}
/**
* Check to see if this program is ready for operation.
* @return true if this program exists
*/
public boolean isValid() {
if (getProgramPath() == null) {
return false;
}
File f = new File(getProgramPath());
return f.exists() && f.isFile();
}
public void run(IResource resource) throws CoreException {
// This method isn't really applicable for kpsewhich
}
public void setProgramArguments(String args) {
// This method isn't really applicable for kpsewhich
}
/**
* @param path the program path and filename for the preferences
*/
public void setProgramPath(String path) {
TexlipsePlugin.getDefault().getPreferenceStore().setValue(getCommandPreferenceName(), path);
}
public void stop() {
if (extrun != null) {
extrun.stop();
}
}
/**
* @return the name of the program runner path -preference in the plugin preferences
*/
private String getCommandPreferenceName() {
return getClass() + "_prog";
}
protected String getWindowsProgramName() {
return "kpsewhich.exe";
}
protected String getUnixProgramName() {
return "kpsewhich";
}
/**
*
* @param command The command string to execute
* @param resource The path to run the command in
* @return Output from the command
* @throws CoreException Thrown if running the external command generates an exception
*/
protected String run(String[] command, IResource resource) throws CoreException {
// check if we are using console
String console = null;
if (TexlipsePlugin.getDefault().getPreferenceStore().getBoolean(TexlipseProperties.BUILDER_CONSOLE_OUTPUT)) {
console = getProgramName();
}
extrun.setup(command, resource.getLocation().toFile().getParentFile(), console);
String output = null;
try {
output = extrun.run();
} catch (Exception e) {
throw new CoreException(new Status(IStatus.ERROR, TexlipsePlugin.getPluginId(),
IStatus.ERROR, "Building the project: ", e));
} finally {
extrun.stop();
}
return output;
}
/**
* Get the path to a file
*
* @param resource folder to run kpsewhich in
* @param filename Name of the file to find
* @param progname Name of the calling program (path searched may depend on this)
* @return the path to the file or an empty string if no path was found
*/
public String getFile(IResource resource, String filename, String progname) throws CoreException {
String[] command = {getProgramPath(),"-progname="+progname, filename};
String output = run(command, resource);
String[] outList = output.split("\r\n|\r|\n");
return outList[0];
}
/**
* Gets the paths Kpathsea will search for a particular type of file
* @param resource Directory to run kpsewhich in
* @param ext The extension to search for
* @return An array of Kpath objects, representing the search paths.
* @throws CoreException Thrown if running kpsewhich throws an exception
*/
public Kpath[] getSearchPaths(IResource resource, String ext) throws CoreException {
String[] command = {getProgramPath(), "-show-path", ext};
String output = run(command, resource);
if (output.startsWith("warning: kpsewhich: Ignoring unknown file type")) {
return null;
} else {
String[] outList = output.split(java.io.File.pathSeparator+"|\r\n|\r|\n");
Kpath[] kpaths = new Kpath[outList.length];
for(int i=0; i<outList.length;i++) {
String unpack = outList[i];
kpaths[i] = new Kpath(unpack);
}
return kpaths;
}
}
} |
Optimal Left-to-Right Binary Signed-Digit Recoding
This paper describes new methods for producing optimal binary signed-digit representations. This can be useful in the fast computation of exponentiations. Contrary to existing algorithms, the digits are scanned from left to right (i.e., from the most significant position to the least significant position). This may lead to better performances in both hardware and software. |
var creepName = require('./util.nameBuilder');
interface StructureSpawn{
sCreep(role:String, specialty?:String): void;
}
StructureSpawn.prototype.sCreep = function(role, specialty?){
var body = [];
if(this.room.find(FIND_STRUCTURES, {filter: (s:StructureContainer) => s.structureType === STRUCTURE_CONTAINER}).length > 0 && this.room.find(FIND_MY_CREEPS, {filter: (c) => c.memory.specialty == 'miner'}).length >= 2)
var energyCap:number = this.room.energyCapacityAvailable
else if(this.room.find(FIND_MY_CREEPS, {filter: (c: Creep) => c.memory.specialty == 'miner'}).length > 0)
var energyCap:number = Math.max(this.room.energyCapacityAvailable /2, 300)
else
var energyCap:number = 300;
var numParts: number;
switch (role){
case 'deliveryWorker':
energyCap = Math.min(energyCap, 1200);
numParts = Math.floor(energyCap/150)
for(let i=0;i<numParts;i++)
body.push(CARRY,CARRY,MOVE);
switch(specialty){
case 'satTransporter':
return this.spawnCreep(body, creepName.getName('Lt'), {memory: {role: role, task: 'idle', homeRoom: this.room.name, specialty: specialty}});
}
return this.spawnCreep(body, creepName.getName('d'), {memory: {role: role, task: 'idle', homeRoom: this.room.name}});
case 'genWorker':
body.push(WORK,CARRY,MOVE);
return this.spawnCreep(body, creepName.getName('g'), {memory: {task: 'idle'}});
case 'mobileWorker':
energyCap = Math.min(energyCap, 1200);
numParts = Math.floor(energyCap/300)
for(let i=0;i<numParts;i++){
body.push(MOVE,MOVE,CARRY,WORK);
}
switch(specialty){
case 'harvester':
return this.spawnCreep(body, creepName.getName('h'), {memory: {role: role, specialty: specialty, task: 'idle'}});
case 'builder':
return this.spawnCreep(body, creepName.getName('b'), {memory: {role: role, specialty: specialty, task:'idle'}});
case 'satBuilder':
return this.spawnCreep(body, creepName.getName('Lb'), {memory: {role: role, specialty: specialty, task:'idle', homeRoom: this.room.name}});
case undefined:
return this.spawnCreep(body, creepName.getName('g'), {memory: {role: role, task:'idle'}});
}
break;
case 'reserver':
energyCap = Math.min(energyCap,1300)
numParts = Math.floor(energyCap/650);
for(let i=0; i<numParts; i++){
body.push(MOVE,CLAIM);
}
return this.spawnCreep(body, creepName.getName('R'), {memory: {role: role, specialty: specialty, task:'idle'}});
case 'satMiner':
energyCap = Math.min(energyCap, 950) -50;
numParts = Math.floor(energyCap/150);
for(let i=0; i<numParts; i++){
body.push(MOVE,WORK);
}
body.push(CARRY);
return this.spawnCreep(body, creepName.getName('Lm'), {memory: {role: role, specialty: specialty, task:'idle'}});
case 'scout':
body.push(MOVE)
return this.spawnCreep(body, creepName.getName('s'), {memory: {role: role, home: this.room.name, task: 'idle'}});
case 'statWorker':
body.push(MOVE, MOVE,CARRY);
energyCap = Math.min(energyCap, 550) - 150;
numParts = Math.floor(energyCap/100);
for(let i=0; i<numParts; i++){
body.push(WORK);
}
switch(specialty){
case 'miner':
return this.spawnCreep(body, creepName.getName('m'), {memory: {role: role, specialty: specialty, task: 'idle'}});
case 'upgrader':
return this.spawnCreep(body, creepName.getName('u'), {memory: {role: role, specialty: specialty, task: 'idle'}});
}
break;
case 'pikeman':
body.push(MOVE,MOVE,ATTACK,MOVE,ATTACK,ATTACK);
return this.spawnCreep(body, creepName.getName('Ap'), {memory: {role: 'pikeman', task: 'Melee'}});
case 'calvalry':
energyCap = energyCap -60;
numParts = Math.floor(energyCap/130)
body.push(TOUGH,MOVE);
for(let i=0;i<numParts;i++){
body.push(MOVE);
}
for(let i=0;i<numParts;i++){
body.push(ATTACK);
}
return this.spawnCreep(body, creepName.getName('Cm'), {memory: {role: 'calvalry', specialty: specialty, task: 'idle', homeRoom: this.room.name}});
}
}
Object.defineProperty(StructureSpawn.prototype, 'spawnEnabled', {
configurable: true,
get: function() {
if(_.isUndefined(this.memory.spawnEnabled)) {
this.memory.spawnEnabled = true;
}
return this.memory.spawnEnabled;
},
set: function(value) {
this.memory.spawnEnabled = value;
}
});
|
Localization of Ghrelin-Producing Cells in the Stomach of the Rainbow Trout (Oncorhynchus mykiss)
Abstract Ghrelin, an endogenous ligand for the growth hormone secretagogue receptor (GHS-R), was isolated from the rat stomach and determined to be n-octanoylated 28-amino-acid peptide. In this study, we studied the distribution of ghrelin-producing cells (ghrelin cells) in the gastrointestinal tract of male and female rainbow trout (Oncorhynchus mykiss) by immunohistochemistry using N-terminal region-recognizing antibody and also by in situ hybridization using a trout ghrelin-specific cRNA probe. Ghrelin cells were found in the mucosal layer of the stomach but not in the myenteric plexus, and no ghrelin cells were observed in other regions of the gastrointestinal tract. Ghrelin cells could be classified into two types: closed- and opened-type cells. The density of ghrelin cells increased gradually in the direction from the cardiac to pyloric portions of the stomach in both sexes. The number of ghrelin cells per unit area seemed to be higher in females than in males. In conclusion, trout ghrelin cells exist in the stomach and are classified into two types of cells, closed- and opened-type cells. |
Ice Cube is set to reprise his 21 Jump Street role as police Captain Dickson in the upcoming sequel, 22 Jump Street. The Hollywood Reporter brings word that the musician-turned-actor will join Jonah Hill and Channing Tatum for the June 13, 2014 release.
The original 2012 action comedy, inspired by (and loosely continuing) the hit television series, starred Hill and Tatum as police officers Schmidt and Jenko. Joining law enforcement’s secret Jump Street unit, they made use of their youthful appearances to go undercover in a local high school. Trading in their guns and badges for backpacks, the pair risk their lives to investigate a violent and dangerous drug ring, quickly learning that modern high school is a very different world than the one they recently left.
Ice Cube can next be seen on the big screen in Tim Story’s action comedy Ride Along. He also plays a cop there, opposite Kevin Hart as his character’s sister’s boyfriend.
(Photo Credit: WENN.com) |
def PrettyXMLFormat(node, level=0):
theStr = "\n" + level*" "
if len(node):
if not node.text or not node.text.strip():
node.text = theStr + " "
if not node.tail or not node.tail.strip():
node.tail = theStr
for i,child in enumerate(node):
PrettyXMLFormat(child, level+1)
if not child.tail or not child.tail.strip():
child.tail = theStr
else:
if level and (not node.tail or not node.tail.strip()):
node.tail = theStr |
A Job Scheduling Method Based on Expected Probability of Completion of Voting in Volunteer Computing
This paper addresses the problem of job scheduling in volunteer computing (VC) systems where each computation job is replicated and distributed to multiple participants (workers) to remove incorrect results. In the job scheduling of VC, the number of assigned workers to complete a job is an important factor for the system performance, however, it cannot be fixed because some of the workers may not return results in real VC. We propose a job scheduling method which considers the expected probability of completion (EPC) for each job based on the worker's history information. The key idea of the proposed method is to assign jobs so that EPC is always greater than a specified value (SPC). By setting SPC as a reasonable value, any job in the proposed method can be completed without excess allocations, which leads to the higher performance of VC systems. Simulation results show that the performance of the proposed method is up to 5 times higher than that of the conventional method, while keeping the error rate lower than a required value. |
<reponame>ethercrow/json-syntax<gh_stars>10-100
{-# language BangPatterns #-}
{-# language LambdaCase #-}
import Data.Primitive (ByteArray)
import Data.ByteString (ByteString)
import Data.Bool (bool)
import Control.Exception
import Foreign.C.Types (CChar)
import qualified Json
import qualified Data.Bytes as Bytes
import qualified Data.Bytes.Chunks as Chunks
import qualified System.IO as IO
main :: IO ()
main = do
input <- Chunks.hGetContents IO.stdin
case Json.decode (Chunks.concat input) of
Left err -> fail (show err)
Right v -> print v
|
/**
* <p>Title: Sarf Program</p>
*
* <p>Description: </p>
*
* <p>Copyright: Copyright (c) 2006</p>
*
* <p>Company: ALEXO</p>
*
* @author Haytham Mohtasseb Billah
* @version 1.0
*/
public class SelectionInfo {
private boolean trilateral;
private boolean augmented;
private boolean active;
private final KindOfVerb kov;
private Root root;
private int augmentationFormulaNo;
private String formulaText;
private String verbText;
public SelectionInfo(Root root, boolean trilateral, boolean augmented, KindOfVerb kov) {
this.root = root;
this.trilateral = trilateral;
this.augmented = augmented;
this.kov = kov;
}
public boolean isActive() {
return active;
}
public boolean isTrilateral() {
return trilateral;
}
public boolean isAugmented() {
return augmented;
}
public Root getRoot() {
return root;
}
public int getAugmentationFormulaNo() {
return augmentationFormulaNo;
}
public String getFormulaText() {
return formulaText;
}
public String getVerbText() {
return verbText;
}
public KindOfVerb getKov() {
return kov;
}
public void setTrilateral(boolean trilateral) {
this.trilateral = trilateral;
}
public void setAugmented(boolean augmented) {
this.augmented = augmented;
}
public void setActive(boolean active) {
this.active = active;
}
public void setRoot(Root root) {
this.root = root;
}
public void setAugmentationFormulaNo(int augmentationFormulaNo) {
this.augmentationFormulaNo = augmentationFormulaNo;
}
public void setVerbText(String verbText) {
this.verbText = verbText;
}
public void setFormulaText(String formulaText) {
this.formulaText = formulaText;
}
} |
import { createLogger, format, LoggerOptions, transports } from "winston";
const { combine, timestamp, printf } = format;
const formatter = printf(({ level, message, timestamp, ...args }) => {
const LOG = `${timestamp} | ${level.toUpperCase()} | ${message}`;
const data = Object.keys(args)
.map((key) => `${key}: ${args[key]}`)
.join(" | ");
if (data) return `${LOG} | ${data}`;
return LOG;
});
const options: LoggerOptions = {
level: process.env.NODE_ENV === "production" ? "error" : "debug",
format: combine(timestamp(), formatter),
transports: [
new transports.Console(),
new transports.File({ filename: "logs/error.log", level: "error" }),
new transports.File({ filename: "logs/application.log" }),
],
};
const logger = createLogger(options);
export { logger };
|
<reponame>ALESSANDROLMENEZES/e-comerce
import { Inject } from '@nestjs/common';
import { IUseCase, Result } from 'types-ddd';
import { BasketRepositoryInterface } from '@repo/basket-repository.interface';
import { UpdateBasketDto } from './update-basket.dto';
import {
Currency,
MonetaryValueObject,
BasketInfoValueObject,
BasketDescriptionValueObject
} from '@domain/value-objects';
export class UpdateBasketUseCase
implements IUseCase<UpdateBasketDto, Result<void>>
{
//
constructor(
@Inject('BasketRepository')
private readonly basketRepo: BasketRepositoryInterface
) {}
async execute(dto: UpdateBasketDto): Promise<Result<void>> {
//
const descriptionOrError = BasketDescriptionValueObject.create(
dto.description
);
if (descriptionOrError.isFailure) {
return Result.fail<void>(descriptionOrError.error.toString());
}
const description = descriptionOrError.getResult();
// ---------------------------------------------------------
const infoOrError = dto.info
? BasketInfoValueObject.create(dto.info)
: undefined;
if (infoOrError?.isFailure) {
return Result.fail<void>(infoOrError.error.toString());
}
const info = infoOrError?.getResult();
// ---------------------------------------------------------
const currencyOrError = Currency.create(dto.price);
if (currencyOrError.isFailure) {
return Result.fail<void>(currencyOrError.error.toString());
}
const currency = currencyOrError.getResult();
// ---------------------------------------------------------
const priceOrError = MonetaryValueObject.create(currency);
if (priceOrError.isFailure) {
return Result.fail<void>(priceOrError.error.toString());
}
const price = priceOrError.getResult();
// ---------------------------------------------------------
const keepActive = dto.isActive;
try {
//
const alreadyExistsBasketWithDescription =
await this.basketRepo.exists({
description: dto.description.toLowerCase()
});
if (alreadyExistsBasketWithDescription) {
return Result.fail<void>(
`Already exists a basket with description: ${dto.description}`
);
}
//
const basketExist = await this.basketRepo.findOne({
id: dto.basketId
});
if (!basketExist) {
return Result.fail<void>('Basket does not exists');
}
const basket = basketExist;
basket.changeDescription(description);
basket.changePrice(price);
keepActive ? basket.activate() : basket.deactivate();
basket.changeInfo(info);
await this.basketRepo.save(basket);
return Result.ok<void>();
//
} catch (error) {
//
console.log(error);
return Result.fail<void>(
'Internal Server Error on Update Basket Use Case'
);
}
}
}
|
def Dump(obj, fid, float_digits=-1, **params):
params['float_digits'] = float_digits
json.dump(obj, fid, cls=DecimalEncoder, **params) |
//
// 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 model
import (
"encoding/xml"
"github.com/apache/plc4x/plc4go/internal/plc4go/spi/utils"
"github.com/pkg/errors"
"io"
"reflect"
"strings"
)
// Code generated by build-utils. DO NOT EDIT.
// The data-structure of this message
type AdsData struct {
Child IAdsDataChild
}
// The corresponding interface
type IAdsData interface {
CommandId() CommandId
Response() bool
LengthInBytes() uint16
LengthInBits() uint16
Serialize(io utils.WriteBuffer) error
xml.Marshaler
xml.Unmarshaler
}
type IAdsDataParent interface {
SerializeParent(io utils.WriteBuffer, child IAdsData, serializeChildFunction func() error) error
GetTypeName() string
}
type IAdsDataChild interface {
Serialize(io utils.WriteBuffer) error
InitializeParent(parent *AdsData)
GetTypeName() string
IAdsData
}
func NewAdsData() *AdsData {
return &AdsData{}
}
func CastAdsData(structType interface{}) *AdsData {
castFunc := func(typ interface{}) *AdsData {
if casted, ok := typ.(AdsData); ok {
return &casted
}
if casted, ok := typ.(*AdsData); ok {
return casted
}
return nil
}
return castFunc(structType)
}
func (m *AdsData) GetTypeName() string {
return "AdsData"
}
func (m *AdsData) LengthInBits() uint16 {
lengthInBits := uint16(0)
// Length of sub-type elements will be added by sub-type...
lengthInBits += m.Child.LengthInBits()
return lengthInBits
}
func (m *AdsData) LengthInBytes() uint16 {
return m.LengthInBits() / 8
}
func AdsDataParse(io *utils.ReadBuffer, commandId *CommandId, response bool) (*AdsData, error) {
// Switch Field (Depending on the discriminator values, passes the instantiation to a sub-type)
var _parent *AdsData
var typeSwitchError error
switch {
case *commandId == CommandId_INVALID && response == false: // AdsInvalidRequest
_parent, typeSwitchError = AdsInvalidRequestParse(io)
case *commandId == CommandId_INVALID && response == true: // AdsInvalidResponse
_parent, typeSwitchError = AdsInvalidResponseParse(io)
case *commandId == CommandId_ADS_READ_DEVICE_INFO && response == false: // AdsReadDeviceInfoRequest
_parent, typeSwitchError = AdsReadDeviceInfoRequestParse(io)
case *commandId == CommandId_ADS_READ_DEVICE_INFO && response == true: // AdsReadDeviceInfoResponse
_parent, typeSwitchError = AdsReadDeviceInfoResponseParse(io)
case *commandId == CommandId_ADS_READ && response == false: // AdsReadRequest
_parent, typeSwitchError = AdsReadRequestParse(io)
case *commandId == CommandId_ADS_READ && response == true: // AdsReadResponse
_parent, typeSwitchError = AdsReadResponseParse(io)
case *commandId == CommandId_ADS_WRITE && response == false: // AdsWriteRequest
_parent, typeSwitchError = AdsWriteRequestParse(io)
case *commandId == CommandId_ADS_WRITE && response == true: // AdsWriteResponse
_parent, typeSwitchError = AdsWriteResponseParse(io)
case *commandId == CommandId_ADS_READ_STATE && response == false: // AdsReadStateRequest
_parent, typeSwitchError = AdsReadStateRequestParse(io)
case *commandId == CommandId_ADS_READ_STATE && response == true: // AdsReadStateResponse
_parent, typeSwitchError = AdsReadStateResponseParse(io)
case *commandId == CommandId_ADS_WRITE_CONTROL && response == false: // AdsWriteControlRequest
_parent, typeSwitchError = AdsWriteControlRequestParse(io)
case *commandId == CommandId_ADS_WRITE_CONTROL && response == true: // AdsWriteControlResponse
_parent, typeSwitchError = AdsWriteControlResponseParse(io)
case *commandId == CommandId_ADS_ADD_DEVICE_NOTIFICATION && response == false: // AdsAddDeviceNotificationRequest
_parent, typeSwitchError = AdsAddDeviceNotificationRequestParse(io)
case *commandId == CommandId_ADS_ADD_DEVICE_NOTIFICATION && response == true: // AdsAddDeviceNotificationResponse
_parent, typeSwitchError = AdsAddDeviceNotificationResponseParse(io)
case *commandId == CommandId_ADS_DELETE_DEVICE_NOTIFICATION && response == false: // AdsDeleteDeviceNotificationRequest
_parent, typeSwitchError = AdsDeleteDeviceNotificationRequestParse(io)
case *commandId == CommandId_ADS_DELETE_DEVICE_NOTIFICATION && response == true: // AdsDeleteDeviceNotificationResponse
_parent, typeSwitchError = AdsDeleteDeviceNotificationResponseParse(io)
case *commandId == CommandId_ADS_DEVICE_NOTIFICATION && response == false: // AdsDeviceNotificationRequest
_parent, typeSwitchError = AdsDeviceNotificationRequestParse(io)
case *commandId == CommandId_ADS_DEVICE_NOTIFICATION && response == true: // AdsDeviceNotificationResponse
_parent, typeSwitchError = AdsDeviceNotificationResponseParse(io)
case *commandId == CommandId_ADS_READ_WRITE && response == false: // AdsReadWriteRequest
_parent, typeSwitchError = AdsReadWriteRequestParse(io)
case *commandId == CommandId_ADS_READ_WRITE && response == true: // AdsReadWriteResponse
_parent, typeSwitchError = AdsReadWriteResponseParse(io)
}
if typeSwitchError != nil {
return nil, errors.Wrap(typeSwitchError, "Error parsing sub-type for type-switch.")
}
// Finish initializing
_parent.Child.InitializeParent(_parent)
return _parent, nil
}
func (m *AdsData) Serialize(io utils.WriteBuffer) error {
return m.Child.Serialize(io)
}
func (m *AdsData) SerializeParent(io utils.WriteBuffer, child IAdsData, serializeChildFunction func() error) error {
// Switch field (Depending on the discriminator values, passes the serialization to a sub-type)
_typeSwitchErr := serializeChildFunction()
if _typeSwitchErr != nil {
return errors.Wrap(_typeSwitchErr, "Error serializing sub-type field")
}
return nil
}
func (m *AdsData) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
var token xml.Token
var err error
for {
token, err = d.Token()
if err != nil {
if err == io.EOF {
return nil
}
return err
}
switch token.(type) {
case xml.StartElement:
tok := token.(xml.StartElement)
switch tok.Name.Local {
default:
attr := start.Attr
if attr == nil || len(attr) <= 0 {
// TODO: workaround for bug with nested lists
attr = tok.Attr
}
if attr == nil || len(attr) <= 0 {
panic("Couldn't determine class type for childs of AdsData")
}
switch attr[0].Value {
case "org.apache.plc4x.java.ads.readwrite.AdsInvalidRequest":
var dt *AdsInvalidRequest
if m.Child != nil {
dt = m.Child.(*AdsInvalidRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsInvalidResponse":
var dt *AdsInvalidResponse
if m.Child != nil {
dt = m.Child.(*AdsInvalidResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsReadDeviceInfoRequest":
var dt *AdsReadDeviceInfoRequest
if m.Child != nil {
dt = m.Child.(*AdsReadDeviceInfoRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsReadDeviceInfoResponse":
var dt *AdsReadDeviceInfoResponse
if m.Child != nil {
dt = m.Child.(*AdsReadDeviceInfoResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsReadRequest":
var dt *AdsReadRequest
if m.Child != nil {
dt = m.Child.(*AdsReadRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsReadResponse":
var dt *AdsReadResponse
if m.Child != nil {
dt = m.Child.(*AdsReadResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsWriteRequest":
var dt *AdsWriteRequest
if m.Child != nil {
dt = m.Child.(*AdsWriteRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsWriteResponse":
var dt *AdsWriteResponse
if m.Child != nil {
dt = m.Child.(*AdsWriteResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsReadStateRequest":
var dt *AdsReadStateRequest
if m.Child != nil {
dt = m.Child.(*AdsReadStateRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsReadStateResponse":
var dt *AdsReadStateResponse
if m.Child != nil {
dt = m.Child.(*AdsReadStateResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsWriteControlRequest":
var dt *AdsWriteControlRequest
if m.Child != nil {
dt = m.Child.(*AdsWriteControlRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsWriteControlResponse":
var dt *AdsWriteControlResponse
if m.Child != nil {
dt = m.Child.(*AdsWriteControlResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsAddDeviceNotificationRequest":
var dt *AdsAddDeviceNotificationRequest
if m.Child != nil {
dt = m.Child.(*AdsAddDeviceNotificationRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsAddDeviceNotificationResponse":
var dt *AdsAddDeviceNotificationResponse
if m.Child != nil {
dt = m.Child.(*AdsAddDeviceNotificationResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsDeleteDeviceNotificationRequest":
var dt *AdsDeleteDeviceNotificationRequest
if m.Child != nil {
dt = m.Child.(*AdsDeleteDeviceNotificationRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsDeleteDeviceNotificationResponse":
var dt *AdsDeleteDeviceNotificationResponse
if m.Child != nil {
dt = m.Child.(*AdsDeleteDeviceNotificationResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsDeviceNotificationRequest":
var dt *AdsDeviceNotificationRequest
if m.Child != nil {
dt = m.Child.(*AdsDeviceNotificationRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsDeviceNotificationResponse":
var dt *AdsDeviceNotificationResponse
if m.Child != nil {
dt = m.Child.(*AdsDeviceNotificationResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsReadWriteRequest":
var dt *AdsReadWriteRequest
if m.Child != nil {
dt = m.Child.(*AdsReadWriteRequest)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
case "org.apache.plc4x.java.ads.readwrite.AdsReadWriteResponse":
var dt *AdsReadWriteResponse
if m.Child != nil {
dt = m.Child.(*AdsReadWriteResponse)
}
if err := d.DecodeElement(&dt, &tok); err != nil {
return err
}
if m.Child == nil {
dt.Parent = m
m.Child = dt
}
}
}
}
}
}
func (m *AdsData) MarshalXML(e *xml.Encoder, start xml.StartElement) error {
className := reflect.TypeOf(m.Child).String()
className = "org.apache.plc4x.java.ads.readwrite." + className[strings.LastIndex(className, ".")+1:]
if err := e.EncodeToken(xml.StartElement{Name: start.Name, Attr: []xml.Attr{
{Name: xml.Name{Local: "className"}, Value: className},
}}); err != nil {
return err
}
marshaller, ok := m.Child.(xml.Marshaler)
if !ok {
return errors.Errorf("child is not castable to Marshaler. Actual type %T", m.Child)
}
if err := marshaller.MarshalXML(e, start); err != nil {
return err
}
if err := e.EncodeToken(xml.EndElement{Name: start.Name}); err != nil {
return err
}
return nil
}
func (m AdsData) String() string {
return string(m.Box("AdsData", utils.DefaultWidth*2))
}
func (m AdsData) Box(name string, width int) utils.AsciiBox {
if name == "" {
name = "AdsData"
}
boxes := make([]utils.AsciiBox, 0)
boxes = append(boxes, utils.BoxAnything("", m.Child, width-2))
return utils.BoxBox(name, utils.AlignBoxes(boxes, width-2), 0)
}
|
#pragma once
struct BasicCodecave {
private:
void call_virtual_protect() noexcept;
public:
unsigned char data[64];
BasicCodecave() noexcept;
BasicCodecave(const unsigned char *data, unsigned int length) noexcept;
BasicCodecave(const BasicCodecave &other) noexcept;
};
void write_jmp_call(void *call_instruction, void *before_function, void *after_function, BasicCodecave &codecave) noexcept;
#include "../code_injection/signature.h"
ChimeraSignature &get_signature(const char *name) noexcept;
bool find_required_signatures() noexcept;
bool find_interpolation_signatures() noexcept;
bool find_uncap_cinematic_signatures() noexcept;
bool find_magnetism_signatures() noexcept;
bool find_auto_center_signature() noexcept;
bool find_widescreen_scope_signature() noexcept;
bool find_zoom_blur_signatures() noexcept;
bool find_anisotropic_filtering_signature() noexcept;
bool find_debug_signatures() noexcept;
bool find_loading_screen_signatures() noexcept;
bool find_multitexture_overlay_signature() noexcept;
bool find_set_resolution_signatures() noexcept;
bool find_widescreen_fix_signatures() noexcept;
bool find_gametype_indicator_sig() noexcept;
bool find_devmode_sig() noexcept;
bool find_simple_score_screen_sigs() noexcept;
bool find_split_screen_hud_sigs() noexcept;
bool find_mouse_sigs() noexcept;
bool find_gamepad_vertical_scale_signatures() noexcept;
bool find_keystone_sigs() noexcept;
bool find_hud_kill_feed_sig() noexcept;
bool find_server_message_sig() noexcept;
bool find_fast_startup_sigs() noexcept;
bool find_console_fade_fix_sig() noexcept;
bool find_pc_map_compat_sigs() noexcept;
bool find_disable_buffering_sig() noexcept;
bool find_fov_fix_sigs() noexcept;
bool find_hide_server_ip_sigs() noexcept;
#define I32(x) reinterpret_cast<int32_t>(x)
#define I32PTR(x) reinterpret_cast<int32_t *>(x)
#define I8(x) reinterpret_cast<char>(x)
#define I8PTR(x) reinterpret_cast<char *>(x)
|
/**
* Mapper to convert a generic query compilation into components for a Neo4j Cypher query.
*/
public class QueryToCypherMapper extends AbstractExpressionEvaluator
{
final ExecutionContext ec;
final AbstractClassMetaData candidateCmd;
final Query query;
final QueryCompilation compilation;
/** Input parameter values, keyed by the parameter name. Will be null if compiled pre-execution. */
final Map parameters;
/** Positional parameter that we are up to (-1 implies not being used). */
int positionalParamNumber = -1;
/** State variable for the component being compiled. */
CompilationComponent compileComponent;
String filterText = null;
boolean filterComplete = true;
String resultText = null;
boolean resultComplete = true;
String orderText = null;
boolean orderComplete = true;
boolean precompilable = true;
/** Stack of neo4j expressions, used for forming the Cypher query component(s). */
Deque<Neo4jExpression> stack = new ArrayDeque<Neo4jExpression>();
public QueryToCypherMapper(QueryCompilation compilation, Map parameters, AbstractClassMetaData cmd,
ExecutionContext ec, Query q)
{
this.ec = ec;
this.query = q;
this.compilation = compilation;
this.parameters = parameters;
this.candidateCmd = cmd;
}
/**
* Method to compile the query for use as a Cypher query in the datastore.
* This takes in the datastore compilation and updates its contents with the cypher query info
* @param neo4jCompilation Datastore compilation
*/
public void compile(Neo4jQueryCompilation neo4jCompilation)
{
compileFilter();
compileResult();
compileOrder();
neo4jCompilation.setPrecompilable(precompilable);
// Set which parts of the query were compilable for processing in the datastore
neo4jCompilation.setFilterComplete(filterComplete);
neo4jCompilation.setResultComplete(resultComplete);
neo4jCompilation.setOrderComplete(orderComplete);
Long rangeFrom = null;
Long rangeTo = null;
if (filterComplete)
{
if (orderComplete)
{
rangeFrom = (query.getRangeFromIncl() > 0 ? query.getRangeFromIncl() : null);
rangeTo = (query.getRangeToExcl() != Long.MAX_VALUE ? query.getRangeToExcl() : null);
if (rangeFrom != null || rangeTo != null)
{
neo4jCompilation.setRangeComplete(true);
}
}
}
// Generate the Cypher text (as far as is possible)
String cypherText = Neo4jUtils.getCypherTextForQuery(ec, candidateCmd, compilation.getCandidateAlias(),
query.isSubclasses(), filterText, (resultComplete ? resultText : null), orderText, rangeFrom, rangeTo);
neo4jCompilation.setCypherText(cypherText);
}
/**
* Method to compile the WHERE clause of the query
*/
protected void compileFilter()
{
if (compilation.getExprFilter() != null)
{
compileComponent = CompilationComponent.FILTER;
try
{
compilation.getExprFilter().evaluate(this);
Neo4jExpression neoExpr = stack.pop();
if (!(neoExpr instanceof Neo4jBooleanExpression))
{
NucleusLogger.QUERY.error("Invalid compilation : filter compiled to " + neoExpr);
filterComplete = false;
}
else
{
filterText = ((Neo4jBooleanExpression) neoExpr).getCypherText();
}
}
catch (Exception e)
{
NucleusLogger.GENERAL.info(">> exception in filter", e);
// Impossible to compile all to run in the datastore, so just exit
if (NucleusLogger.QUERY.isDebugEnabled())
{
NucleusLogger.QUERY.debug("Compilation of filter to be evaluated completely in-datastore was impossible : " + e.getMessage());
}
filterComplete = false;
}
compileComponent = null;
}
}
/**
* Method to compile the ORDER clause of the query
*/
protected void compileOrder()
{
if (compilation.getExprOrdering() != null)
{
compileComponent = CompilationComponent.ORDERING;
try
{
StringBuilder orderStr = new StringBuilder();
Expression[] orderingExpr = compilation.getExprOrdering();
for (int i=0;i<orderingExpr.length;i++)
{
OrderExpression orderExpr = (OrderExpression)orderingExpr[i];
orderExpr.evaluate(this);
Neo4jExpression neoExpr = stack.pop();
orderStr.append(neoExpr.getCypherText());
String orderDir = orderExpr.getSortOrder();
if (orderDir.equalsIgnoreCase("descending"))
{
orderStr.append(" DESC");
}
if (i < orderingExpr.length-1)
{
orderStr.append(",");
}
}
orderText = orderStr.toString();
}
catch (Exception e)
{
// Impossible to compile all to run in the datastore, so just exit
if (NucleusLogger.QUERY.isDebugEnabled())
{
NucleusLogger.QUERY.debug("Compilation of ordering to be evaluated completely in-datastore was impossible : " + e.getMessage());
}
orderComplete = false;
}
compileComponent = null;
}
}
/**
* Method to compile the result clause of the query
*/
protected void compileResult()
{
if (compilation.getExprResult() != null)
{
compileComponent = CompilationComponent.RESULT;
// Select any result expressions
resultComplete = true;
StringBuilder str = new StringBuilder();
try
{
Expression[] resultExprs = compilation.getExprResult();
int i = 0;
for (Expression expr : resultExprs)
{
Neo4jExpression neo4jExpr = null;
if (expr instanceof PrimaryExpression)
{
PrimaryExpression primExpr = (PrimaryExpression)expr;
processPrimaryExpression(primExpr);
neo4jExpr = stack.pop();
str.append(neo4jExpr.getCypherText());
}
else if (expr instanceof Literal)
{
processLiteral((Literal)expr);
neo4jExpr = stack.pop();
str.append(neo4jExpr.getCypherText());
}
else if (expr instanceof ParameterExpression)
{
processParameterExpression((ParameterExpression)expr);
neo4jExpr = stack.pop();
str.append(neo4jExpr.getCypherText());
}
else if (expr instanceof InvokeExpression)
{
InvokeExpression invokeExpr = (InvokeExpression)expr;
if (invokeExpr.getOperation().equalsIgnoreCase("MAX") ||
invokeExpr.getOperation().equalsIgnoreCase("MIN") ||
invokeExpr.getOperation().equalsIgnoreCase("SUM") ||
invokeExpr.getOperation().equalsIgnoreCase("AVG") ||
invokeExpr.getOperation().equalsIgnoreCase("COUNT"))
{
// Only support some aggregates
if (invokeExpr.getLeft() == null)
{
List<Expression> argExprs = invokeExpr.getArguments();
if (argExprs == null || argExprs.size() != 1)
{
throw new NucleusUserException("Invalid number of arguments to MAX");
}
Expression argExpr = argExprs.get(0);
if (argExpr instanceof PrimaryExpression)
{
processPrimaryExpression((PrimaryExpression)argExpr);
}
else
{
throw new NucleusUserException("Invocation of static method " +
invokeExpr.getOperation() +" with arg of type " + argExpr.getClass().getName() +
" not supported in-datastore");
}
Neo4jExpression aggrArgExpr = stack.pop();
Neo4jExpression aggExpr = new Neo4jAggregateExpression(invokeExpr.getOperation(), aggrArgExpr);
str.append(aggExpr.getCypherText());
}
}
else
{
NucleusLogger.QUERY.warn("Invocation of static method " + invokeExpr.getOperation() +" not supported in-datastore");
resultComplete = false;
break;
}
}
else
{
NucleusLogger.GENERAL.info("Query result expression " + expr + " not supported via Cypher so will be processed in-memory");
resultComplete = false;
break;
}
if (i < resultExprs.length-1)
{
str.append(",");
}
i++;
}
resultText = str.toString();
}
catch (Exception e)
{
NucleusLogger.GENERAL.info("Query result clause " + StringUtils.objectArrayToString(compilation.getExprResult()) +
" not totally supported via Cypher so will be processed in-memory");
resultComplete = false;
}
// TODO Handle distinct
compileComponent = null;
}
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processAndExpression(org.datanucleus.query.expression.Expression)
*/
@Override
protected Object processAndExpression(Expression expr)
{
Neo4jBooleanExpression right = (Neo4jBooleanExpression) stack.pop();
Neo4jBooleanExpression left = (Neo4jBooleanExpression) stack.pop();
Neo4jBooleanExpression andExpr = new Neo4jBooleanExpression(left, right, Expression.OP_AND);
stack.push(andExpr);
return andExpr;
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processOrExpression(org.datanucleus.query.expression.Expression)
*/
@Override
protected Object processOrExpression(Expression expr)
{
Neo4jBooleanExpression right = (Neo4jBooleanExpression) stack.pop();
Neo4jBooleanExpression left = (Neo4jBooleanExpression) stack.pop();
Neo4jBooleanExpression andExpr = new Neo4jBooleanExpression(left, right, Expression.OP_OR);
stack.push(andExpr);
return andExpr;
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processEqExpression(org.datanucleus.query.expression.Expression)
*/
@Override
protected Object processEqExpression(Expression expr)
{
Object right = stack.pop();
Object left = stack.pop();
if (left instanceof Neo4jLiteral && right instanceof Neo4jFieldExpression)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)right, (Neo4jLiteral)left, Expression.OP_EQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if (left instanceof Neo4jFieldExpression && right instanceof Neo4jLiteral)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)left, (Neo4jLiteral)right, Expression.OP_EQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if (left instanceof Neo4jExpression && right instanceof Neo4jExpression)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jExpression)left, (Neo4jExpression)right, Expression.OP_EQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
// TODO Auto-generated method stub
return super.processEqExpression(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processNoteqExpression(org.datanucleus.query.expression.Expression)
*/
@Override
protected Object processNoteqExpression(Expression expr)
{
Object right = stack.pop();
Object left = stack.pop();
if (left instanceof Neo4jLiteral && right instanceof Neo4jFieldExpression)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)right, (Neo4jLiteral)left, Expression.OP_NOTEQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if (left instanceof Neo4jFieldExpression && right instanceof Neo4jLiteral)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)left, (Neo4jLiteral)right, Expression.OP_NOTEQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if (left instanceof Neo4jExpression && right instanceof Neo4jExpression)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jExpression)left, (Neo4jExpression)right, Expression.OP_NOTEQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
// TODO Auto-generated method stub
return super.processEqExpression(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processGtExpression(org.datanucleus.query.expression.Expression)
*/
@Override
protected Object processGtExpression(Expression expr)
{
Object right = stack.pop();
Object left = stack.pop();
if (left instanceof Neo4jLiteral && right instanceof Neo4jFieldExpression)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)right, (Neo4jLiteral)left, Expression.OP_LTEQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if (left instanceof Neo4jFieldExpression && right instanceof Neo4jLiteral)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)left, (Neo4jLiteral)right, Expression.OP_GT);
stack.push(neo4jExpr);
return neo4jExpr;
}
// TODO Auto-generated method stub
return super.processEqExpression(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processLtExpression(org.datanucleus.query.expression.Expression)
*/
@Override
protected Object processLtExpression(Expression expr)
{
Object right = stack.pop();
Object left = stack.pop();
if (left instanceof Neo4jLiteral && right instanceof Neo4jFieldExpression)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)right, (Neo4jLiteral)left, Expression.OP_GTEQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if (left instanceof Neo4jFieldExpression && right instanceof Neo4jLiteral)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)left, (Neo4jLiteral)right, Expression.OP_LT);
stack.push(neo4jExpr);
return neo4jExpr;
}
// TODO Auto-generated method stub
return super.processEqExpression(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processGteqExpression(org.datanucleus.query.expression.Expression)
*/
@Override
protected Object processGteqExpression(Expression expr)
{
Object right = stack.pop();
Object left = stack.pop();
if (left instanceof Neo4jLiteral && right instanceof Neo4jFieldExpression)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)right, (Neo4jLiteral)left, Expression.OP_LT);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if (left instanceof Neo4jFieldExpression && right instanceof Neo4jLiteral)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)left, (Neo4jLiteral)right, Expression.OP_GTEQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
// TODO Auto-generated method stub
return super.processEqExpression(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processLteqExpression(org.datanucleus.query.expression.Expression)
*/
@Override
protected Object processLteqExpression(Expression expr)
{
Object right = stack.pop();
Object left = stack.pop();
if (left instanceof Neo4jLiteral && right instanceof Neo4jFieldExpression)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)right, (Neo4jLiteral)left, Expression.OP_GT);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if (left instanceof Neo4jFieldExpression && right instanceof Neo4jLiteral)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jFieldExpression)left, (Neo4jLiteral)right, Expression.OP_LTEQ);
stack.push(neo4jExpr);
return neo4jExpr;
}
// TODO Auto-generated method stub
return super.processEqExpression(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processNotExpression(org.datanucleus.query.expression.Expression)
*/
@Override
protected Object processNotExpression(Expression expr)
{
Object theExpr = stack.pop();
if (theExpr instanceof Neo4jBooleanExpression)
{
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression((Neo4jBooleanExpression) theExpr, Expression.OP_NOT);
stack.push(neo4jExpr);
return neo4jExpr;
}
return super.processNotExpression(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processParameterExpression(org.datanucleus.query.expression.ParameterExpression)
*/
@Override
protected Object processParameterExpression(ParameterExpression expr)
{
// Extract the parameter value (if set)
Object paramValue = null;
boolean paramValueSet = false;
if (parameters != null && !parameters.isEmpty())
{
// Check if the parameter has a value
if (parameters.containsKey(expr.getId()))
{
// Named parameter
paramValue = parameters.get(expr.getId());
paramValueSet = true;
}
else if (parameters.containsKey(expr.getId()))
{
// Positional parameter, but already encountered
paramValue = parameters.get(expr.getId());
paramValueSet = true;
}
else
{
// Positional parameter, not yet encountered
int position = positionalParamNumber;
if (positionalParamNumber < 0)
{
position = 0;
}
if (parameters.containsKey(Integer.valueOf(position)))
{
paramValue = parameters.get(Integer.valueOf(position));
paramValueSet = true;
positionalParamNumber = position+1;
}
}
}
// TODO Change this to use Neo4jUtils.getStoredValueForField
if (paramValueSet)
{
if (paramValue instanceof Number)
{
Neo4jLiteral lit = new Neo4jLiteral(paramValue);
stack.push(lit);
precompilable = false;
return lit;
}
else if (paramValue instanceof String)
{
Neo4jLiteral lit = new Neo4jLiteral(paramValue);
stack.push(lit);
precompilable = false;
return lit;
}
else if (paramValue instanceof Character)
{
Neo4jLiteral lit = new Neo4jLiteral(paramValue);
stack.push(lit);
precompilable = false;
return lit;
}
else if (paramValue instanceof Boolean)
{
Neo4jLiteral lit = new Neo4jLiteral(paramValue);
stack.push(lit);
precompilable = false;
return lit;
}
else if (paramValue instanceof java.util.Date)
{
// java.util.Date etc are stored via converter
Object storedVal = paramValue;
Class paramType = paramValue.getClass();
if (paramValue instanceof SCO)
{
paramType = ((SCO)paramValue).getValue().getClass();
}
TypeConverter strConv = ec.getTypeManager().getTypeConverterForType(paramType, String.class);
TypeConverter longConv = ec.getTypeManager().getTypeConverterForType(paramType, Long.class);
if (strConv != null)
{
// store as a String
storedVal = strConv.toDatastoreType(paramValue);
}
else if (longConv != null)
{
// store as a Long
storedVal = longConv.toDatastoreType(paramValue);
}
Neo4jLiteral lit = new Neo4jLiteral(storedVal);
stack.push(lit);
precompilable = false;
return lit;
}
else if (paramValue == null)
{
Neo4jLiteral lit = new Neo4jLiteral(null);
stack.push(lit);
precompilable = false;
return lit;
}
else
{
NucleusLogger.QUERY.info("Dont currently support parameter values of type " + paramValue.getClass().getName());
// TODO Support other parameter value types
}
}
else
{
precompilable = false;
throw new NucleusException("Parameter " + expr + " is not currently set, so cannot complete the compilation");
}
return super.processParameterExpression(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processPrimaryExpression(org.datanucleus.query.expression.PrimaryExpression)
*/
@Override
protected Object processPrimaryExpression(PrimaryExpression expr)
{
Expression left = expr.getLeft();
if (left == null)
{
if (expr.getId().equals(compilation.getCandidateAlias()))
{
// Special case of the candidate
Neo4jFieldExpression fieldExpr = new Neo4jFieldExpression(compilation.getCandidateAlias(), null, null);
stack.push(fieldExpr);
return fieldExpr;
}
Neo4jFieldExpression fieldExpr = getFieldNameForPrimary(expr);
if (fieldExpr == null)
{
if (compileComponent == CompilationComponent.FILTER)
{
filterComplete = false;
}
else if (compileComponent == CompilationComponent.ORDERING)
{
orderComplete = false;
}
else if (compileComponent == CompilationComponent.RESULT)
{
resultComplete = false;
}
NucleusLogger.QUERY.warn(">> Primary " + expr + " is not stored in this Neo4j type, so unexecutable in datastore");
}
else
{
// Assume all fields are prefixed by the candidate alias! TODO When we support fields in related objects then remove this and put in the Neo4jFieldExpression creation
stack.push(fieldExpr);
return fieldExpr;
}
}
return super.processPrimaryExpression(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processLiteral(org.datanucleus.query.expression.Literal)
*/
@Override
protected Object processLiteral(Literal expr)
{
Object litValue = expr.getLiteral();
if (litValue instanceof BigDecimal)
{
// Neo4j can't cope with BigDecimal, so give it a Double
Neo4jLiteral lit = new Neo4jLiteral(((BigDecimal)litValue).doubleValue());
stack.push(lit);
return lit;
}
else if (litValue instanceof Number)
{
Neo4jLiteral lit = new Neo4jLiteral(litValue);
stack.push(lit);
return lit;
}
else if (litValue instanceof String)
{
Neo4jLiteral lit = new Neo4jLiteral(litValue);
stack.push(lit);
return lit;
}
else if (litValue instanceof Boolean)
{
Neo4jLiteral lit = new Neo4jLiteral(litValue);
stack.push(lit);
return lit;
}
else if (litValue == null)
{
Neo4jLiteral lit = new Neo4jLiteral(null);
stack.push(lit);
return lit;
}
return super.processLiteral(expr);
}
/* (non-Javadoc)
* @see org.datanucleus.query.evaluator.AbstractExpressionEvaluator#processInvokeExpression(org.datanucleus.query.expression.InvokeExpression)
*/
@Override
protected Object processInvokeExpression(InvokeExpression expr)
{
// Find object that we invoke on
Expression invokedExpr = expr.getLeft();
String operation = expr.getOperation();
List<Expression> args = expr.getArguments();
boolean supported = true;
Neo4jExpression invokedNeo4jExpr = null;
if (invokedExpr == null)
{
// Static method
}
else if (invokedExpr instanceof PrimaryExpression)
{
processPrimaryExpression((PrimaryExpression) invokedExpr);
invokedNeo4jExpr = stack.pop();
}
else if (invokedExpr instanceof ParameterExpression)
{
processParameterExpression((ParameterExpression) invokedExpr);
invokedNeo4jExpr = stack.pop();
}
else
{
supported = false;
}
List<Neo4jExpression> neo4jExprArgs = null;
if (supported && args != null)
{
neo4jExprArgs = new ArrayList<Neo4jExpression>();
for (Expression argExpr : args)
{
if (argExpr instanceof PrimaryExpression)
{
processPrimaryExpression((PrimaryExpression) argExpr);
neo4jExprArgs.add(stack.pop());
}
else if (argExpr instanceof ParameterExpression)
{
processParameterExpression((ParameterExpression) argExpr);
neo4jExprArgs.add(stack.pop());
}
else if (argExpr instanceof InvokeExpression)
{
processInvokeExpression((InvokeExpression) argExpr);
neo4jExprArgs.add(stack.pop());
}
else if (argExpr instanceof Literal)
{
processLiteral((Literal) argExpr);
neo4jExprArgs.add(stack.pop());
}
else
{
supported = false;
break;
}
}
}
if (supported)
{
if (invokedNeo4jExpr == null)
{
// Static method invocation
if (operation.startsWith("Math."))
{
if (neo4jExprArgs == null || neo4jExprArgs.size() != 1)
{
throw new NucleusException("Method " + operation + " has to have 1 args");
}
Neo4jExpression neo4jArgExpr = neo4jExprArgs.get(0);
if ("Math.cos".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jNumericExpression("cos(" + neo4jArgExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("Math.sin".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jNumericExpression("sin(" + neo4jArgExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("Math.tan".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jNumericExpression("tan(" + neo4jArgExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("Math.acos".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jNumericExpression("acos(" + neo4jArgExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("Math.asin".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jNumericExpression("asin(" + neo4jArgExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("Math.atan".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jNumericExpression("atan(" + neo4jArgExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("Math.toDegrees".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jNumericExpression("degrees(" + neo4jArgExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("Math.toRadians".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jNumericExpression("radians(" + neo4jArgExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
}
}
else if (invokedNeo4jExpr instanceof Neo4jFieldExpression)
{
// Field method invocation
Neo4jFieldExpression invokedFieldExpr = (Neo4jFieldExpression)invokedNeo4jExpr;
if (invokedFieldExpr.getMemberMetaData().getType() == String.class)
{
// String methods
if ("toUpperCase".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jStringExpression("toUpper(" + invokedFieldExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("toLowerCase".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jStringExpression("toLower(" + invokedFieldExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("trimLeft".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jStringExpression("lTrim(" + invokedFieldExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("trimRight".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jStringExpression("rTrim(" + invokedFieldExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("trim".equals(operation))
{
Neo4jExpression neo4jExpr = new Neo4jStringExpression("trim(" + invokedFieldExpr.getCypherText() + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("substring".equals(operation))
{
if (neo4jExprArgs == null || neo4jExprArgs.size() == 0 || neo4jExprArgs.size() > 2)
{
throw new NucleusException("Method String.substring has to have 1 or 2 args");
}
else if (neo4jExprArgs.size() == 1)
{
Neo4jExpression neo4jExpr = new Neo4jStringExpression("substring(" + invokedFieldExpr.getCypherText() + "," + neo4jExprArgs.get(0) + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
else
{
Neo4jExpression neo4jExpr = new Neo4jStringExpression("substring(" + invokedFieldExpr.getCypherText() + "," + neo4jExprArgs.get(0) + "," + neo4jExprArgs.get(1) + ")");
stack.push(neo4jExpr);
return neo4jExpr;
}
}
else if ("matches".equals(operation))
{
if (neo4jExprArgs == null || neo4jExprArgs.size() != 1)
{
throw new NucleusException("Method String.matches has to have 1 arg");
}
String propName = invokedFieldExpr.getFieldName();
String value = neo4jExprArgs.get(0).toString();
String cypherText = propName + " =~ '" + value + "'";
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression(cypherText);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("startsWith".equals(operation))
{
if (neo4jExprArgs == null || neo4jExprArgs.size() != 1)
{
// TODO Support startsWith(String, int)
throw new NucleusException("Method String.startsWith has to have 1 arg; we do not support the method with 2 args currently");
}
String propName = invokedFieldExpr.getFieldName();
String value = neo4jExprArgs.get(0).toString();
String cypherText = propName + " STARTS WITH '" + value + "'";
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression(cypherText);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("endsWith".equals(operation))
{
if (neo4jExprArgs == null || neo4jExprArgs.size() != 1)
{
throw new NucleusException("Method String.endsWith has to have 1 arg");
}
String propName = invokedFieldExpr.getFieldName();
String value = neo4jExprArgs.get(0).toString();
String cypherText = propName + " ENDS WITH '" + value + "'";
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression(cypherText);
stack.push(neo4jExpr);
return neo4jExpr;
}
else if ("contains".equals(operation))
{
if (neo4jExprArgs == null || neo4jExprArgs.isEmpty() || neo4jExprArgs.size() > 2)
{
throw new NucleusException("Method String.contains has to have 1 args");
}
String propName = invokedFieldExpr.getFieldName();
String value = neo4jExprArgs.get(0).toString();
String cypherText = propName + " =~ '(?i).*" + value + ".*'";
Neo4jExpression neo4jExpr = new Neo4jBooleanExpression(cypherText);
stack.push(neo4jExpr);
return neo4jExpr;
}
}
}
}
NucleusLogger.QUERY.debug(">> Dont currently support method invocation in Neo4j datastore queries : expr=" + invokedExpr + " method=" + operation + " args=" + StringUtils.collectionToString(args));
return super.processInvokeExpression(expr);
}
/**
* Convenience method to return the "field name" in node for this primary.
* Allows for simple relation fields.
* @param expr The expression
* @return The Neo4jFieldExpression for this primary (or null if not resolvable in this node)
*/
protected Neo4jFieldExpression getFieldNameForPrimary(PrimaryExpression expr)
{
List<String> tuples = expr.getTuples();
if (tuples == null || tuples.isEmpty())
{
return null;
}
AbstractClassMetaData cmd = candidateCmd;
Table table = ec.getStoreManager().getStoreDataForClass(cmd.getFullClassName()).getTable();
AbstractMemberMetaData embMmd = null;
List<AbstractMemberMetaData> embMmds = new ArrayList<AbstractMemberMetaData>();
boolean firstTuple = true;
Iterator<String> iter = tuples.iterator();
ClassLoaderResolver clr = ec.getClassLoaderResolver();
while (iter.hasNext())
{
String name = iter.next();
if (firstTuple && name.equals(compilation.getCandidateAlias()))
{
cmd = candidateCmd;
}
else
{
AbstractMemberMetaData mmd = cmd.getMetaDataForMember(name);
if (mmd == null)
{
NucleusLogger.QUERY.warn("Attempt to locate PrimaryExpression " + expr + " gave no result! Maybe an unsupported feature?");
return null;
}
// TODO When we support fields in related objects then set the alias to the related object as appropriate
String cmptAlias = compilation.getCandidateAlias();
RelationType relationType = mmd.getRelationType(ec.getClassLoaderResolver());
if (relationType == RelationType.NONE)
{
if (iter.hasNext())
{
throw new NucleusUserException("Query has reference to " + StringUtils.collectionToString(tuples) + " yet " + name + " is a non-relation field!");
}
if (embMmd != null)
{
// Get property name for field of embedded object
embMmds.add(mmd);
MemberColumnMapping mapping = table.getMemberColumnMappingForEmbeddedMember(embMmds);
return new Neo4jFieldExpression(cmptAlias + "." + table.getMemberColumnMappingForEmbeddedMember(embMmds).getColumn(0).getName(), mmd, mapping);
}
MemberColumnMapping mapping = table.getMemberColumnMappingForMember(mmd);
return new Neo4jFieldExpression(cmptAlias + "." + table.getMemberColumnMappingForMember(mmd).getColumn(0).getName(), mmd, mapping);
}
else if (RelationType.isRelationSingleValued(relationType))
{
boolean embedded = MetaDataUtils.getInstance().isMemberEmbedded(ec.getMetaDataManager(), clr, mmd, relationType, embMmds.isEmpty() ? null : embMmds.get(embMmds.size()-1));
if (embedded)
{
if (RelationType.isRelationSingleValued(relationType))
{
cmd = ec.getMetaDataManager().getMetaDataForClass(mmd.getType(), ec.getClassLoaderResolver());
if (embMmd != null)
{
embMmd = embMmd.getEmbeddedMetaData().getMemberMetaData()[mmd.getAbsoluteFieldNumber()];
}
else
{
embMmd = mmd;
}
embMmds.add(embMmd);
}
else if (RelationType.isRelationMultiValued(relationType))
{
throw new NucleusUserException("Do not support the querying of embedded collection/map/array fields : " + mmd.getFullFieldName());
}
}
else
{
// Not embedded
embMmds.clear();
if (relationType == RelationType.MANY_TO_ONE_UNI || relationType == RelationType.MANY_TO_ONE_BI)
{
if (!iter.hasNext())
{
MemberColumnMapping mapping = table.getMemberColumnMappingForMember(mmd);
return new Neo4jFieldExpression(cmptAlias + "." + name, mmd, mapping);
}
// Need join to another object, not currently supported
throw new NucleusUserException("Do not support query joining to related object at " + mmd.getFullFieldName() + " in " + StringUtils.collectionToString(tuples));
}
if (compileComponent == CompilationComponent.FILTER)
{
filterComplete = false;
}
NucleusLogger.QUERY.debug("Query has reference to " + StringUtils.collectionToString(tuples) + " and " + mmd.getFullFieldName() +
" is not persisted into this object, so unexecutable in the datastore");
return null;
}
}
else if (RelationType.isRelationMultiValued(relationType))
{
throw new NucleusUserException("Dont currently support querying of multi-valued fields at " + mmd.getFullFieldName());
}
firstTuple = false;
}
}
return null;
}
} |
const stdin = require('fs').readFileSync('/dev/stdin', 'utf8')
const _n = stdin.split('\n')[0]
const n = Number(_n)
const a1 = stdin
.split('\n')[1]
.split(' ')
.map(Number)
const a2 = stdin
.split('\n')[2]
.split(' ')
.map(Number)
const a1Total = i => {
let sum = 0
for (let j = 0; j <= i; j++) {
sum += a1[j]
}
return sum
}
const a2Total = i => {
let sum = 0
for (let j = i; j < a2.length; j++) {
sum += a2[j]
}
return sum
}
const res = _ => {
let max = 0
for (let i = 0; i < n; i++) {
const sum = a1Total(i) + a2Total(i)
max = sum > max ? sum : max
}
return max
}
console.log(res())
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
int tc;
cin>>tc;
while(tc--)
{
int n,k;
cin>>n>>k;
string A;
cin>>A;int ch=1;int c0=0,c1=0;
for(int i=0;i<k;i++)
{ int temp=-1;
for(int j=i;j<n;j+=k)
{
if(A[j]!='?')
{
if(temp!=-1 && A[j]-'0' !=temp){ch=0;break;}
temp=A[j]-'0';
}
}
if(temp==1){c1++;}
if(temp==0){c0++;}
if(2*c0>k || 2*c1>k){ch=0;break;}
}
if(ch){cout<<"YES"<<endl;}
else{cout<<"NO"<<endl;}
}
return 0;
} |
NUMERICAL AND EXPERIMENTAL INVESTIGATION OF HEAT TRANSFER DURING COMPOSITE FUSED FILAMENT FABRICATION
Additive manufacturing of fiber-reinforced composite materials enables production of parts with high specific stiffness and strength. Several manufacturers have released their versions of composite 3D printers with the most popular being Markforged® which relies on fused filament fabrication (FFF) process. This paper focuses on numerical and experimental investigation of heat transfer in composite specimens produced via the FFF manufacturing process. The experimental setup combines the Markforged® Mark Two™ composite 3D printer and the FLIR thermal camera. The camera is used to collect full field temperature history of a cylindrical composite specimen 12.7 𝑚𝑚 × 25.4 𝑚𝑚 (𝑑𝑖𝑎𝑚𝑒𝑡𝑒𝑟 × ℎ𝑒𝑖𝑔ℎ𝑡) manufactured using composite filament Onyx™ consisting of nylon matrix and chopped carbon fibers. The thermal data is used to validate three-dimensional finite element simulations of transient heat transfer during the filament deposition process. Two approaches are used for the numerical simulation: “element-by-element” in which elements are activated in sequence following a realistic deposition path, and “layer-by-layer” in which all elements of a layer are activated simultaneously and then allowed to cool. The latter approach is more computationally efficient. Micromechanical homogenization is used to estimate the effective conductivity values of the fiber-reinforced Onyx™ filament. Full-field temperature distribution and path plots are generated via both numerical approaches and from experimental data. The element-by-element approach appears to be capable of predicting the experimentally observed temperature distribution below the most recently deposited layer. |
// renderRecording uses Asciicast2gif's Docker image to convert an
// asciicast to the gif format. This function does not pull the
// Docker image, so it needs the client and context passed as arguments.
// Asciicast2gif is used with the "-S1" flag to reduce the gif's
// resolution.
//
// This function returns the path towards the rendered recoring. If
// no render is produced, an empty string is returned.
func renderRecording(asciicastPath string, cli *client.Client, ctx context.Context) string {
stat, err := os.Stat(asciicastPath)
if err != nil {
log.Fatal(err)
}
cropRec(asciicastPath)
fileName := strings.TrimSuffix(stat.Name(), filepath.Ext(stat.Name()))
scenePath, err := getScenePath(asciicastPath)
if err != nil {
log.Printf("Could not render file: %s\n%s", asciicastPath, err)
return ""
}
outputPath := filepath.Join(".", renderPath, fileName + ".gif")
castFromMount := filepath.Join(".", recordingsPath, fileName + ".cast")
gifsDir := filepath.Join(scenePath, renderPath)
if _, err := os.Stat(gifsDir); os.IsNotExist(err) {
os.Mkdir(gifsDir, 0777)
}
inout := make(chan []byte)
resp, err := cli.ContainerCreate(ctx, &container.Config{
Cmd: []string{"-S1", castFromMount, outputPath},
Image: "asciinema/asciicast2gif",
}, &container.HostConfig{
Mounts: []mount.Mount{
{
Type: mount.TypeBind,
Source: scenePath,
Target: "/data",
},
},
}, nil, nil, "")
if err != nil {
panic(err)
}
if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
panic(err)
}
waiter, err := cli.ContainerAttach(ctx, resp.ID, types.ContainerAttachOptions{
Stderr: true,
Stdout: true,
Stdin: true,
Stream: true,
})
go io.Copy(os.Stdout, waiter.Reader)
go io.Copy(os.Stderr, waiter.Reader)
if err != nil {
panic(err)
}
go func() {
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
inout <- []byte(scanner.Text())
}
}()
go func(w io.WriteCloser) {
for {
data, ok := <-inout
if !ok {
fmt.Println("!ok")
w.Close()
return
}
w.Write(append(data, '\n'))
}
}(waiter.Conn)
statusCh, errCh := cli.ContainerWait(ctx, resp.ID, container.WaitConditionNextExit)
select {
case err := <-errCh:
if err != nil {
panic(err)
}
case status := <-statusCh:
fmt.Printf("status.StatusCode: %#+v\n", status.StatusCode)
}
out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
if err != nil {
panic(err)
}
stdcopy.StdCopy(os.Stdout, os.Stderr, out)
return filepath.Join(scenePath, outputPath)
} |
<gh_stars>0
package ar.com.kfgodel.function.bytes;
/**
* Date: 29/07/17 - 19:57
*/
public interface ByteToStringFunction extends ByteToObjectFunction<String> {
}
|
def __readpotHDF(self, hdffile, atomType=None):
info = hdffile.get('general')
numPOT = info.attrs['numPOT'][0]
if 'bravaisMatrix' in info:
self.bravaisMat['pot'] = np.array(info.get('bravaisMatrix'))
if numPOT == 0:
raise IOError(f'No potentials found in {hdffile}')
potential_groups = {key for key in hdffile if 'pot-' in key}
if len(potential_groups) != 1 and atomType is None:
raise ValueError('Multiple possibilities for calculated potentials. '
f'Select the desired atomType: {potential_groups}')
if atomType is not None:
pot_group = f'pot-{atomType}'
else:
pot_group = potential_groups.pop()
if pot_group in hdffile:
_pot = hdffile.get(pot_group)
self.vlm['RMT'] = _pot.attrs['RMT'][0]
for key in _pot.keys():
if key == 'rmesh':
_rmesh = _pot.get(key)
self.vlm['rmesh'] = np.array(_rmesh)
else:
_vlm = _pot.get(key)
l = _vlm.attrs['l'][0]
m = _vlm.attrs['m'][0]
_data = _vlm.get('vlm')
_data = np.array(_data[:, :, 0] + 1j * _data[:, :, 1])
if abs(_data).max() >= self.pot_cutoff:
self.vlm[(l, m)] = _data
else:
raise IOError(f'No potential for atomType {atomType} found in {hdffile}')
if not self.quiet:
print(f'readPOTHDF: Generated the following information: {self.vlm.keys()}') |
package rogue
import "fmt"
func (n *Obj) ageCap() int64 {
// XXX what is a sane age?
return 100000
}
func (n *Obj) hungerCap() int {
return 100 + (n.Level * 5)
}
func (n *Obj) thirstCap() int {
return 100 + (n.Level * 5)
}
func (n *Obj) coldnessCap() int {
return 100 + (n.Level * 5)
}
func (n *Obj) tirednessCap() int {
return 10000 + (n.Level * 100)
}
func (n *Obj) isHungry() bool {
if n.Hunger >= n.hungerCap() {
return true
}
return false
}
func (n *Obj) isThirsty() bool {
if n.Thirst >= n.thirstCap() {
return true
}
return false
}
func (n *Obj) diesOfHungerCap() int {
return n.hungerCap() + 1000
}
func (n *Obj) diesOfThirstCap() int {
return n.thirstCap() + 1000
}
func (n *Obj) isCold() bool {
if n.Coldness >= n.coldnessCap() {
return true
}
return false
}
func (n *Obj) isTired() bool {
if n.Tiredness >= n.tirednessCap() {
return true
}
return false
}
func (n *Obj) isSleeping() bool {
if n.CurrentAction != nil && n.CurrentAction.Name == "sleep" {
return true
}
return false
}
func (n *Obj) isAboveMaxAge() bool {
if n.Age.Current() >= n.ageCap() {
return true
}
return false
}
// used by eg. fireplace. if it is activated = it is burning
func (n *Obj) isActivated() bool {
return n.Activated
}
// Activate ...
func (n *Obj) Activate() {
if n.Activated == true {
panic(fmt.Errorf("obj %s is already activated", n.Name))
}
n.Activated = true
}
|
0170 Identifying Skill Level Differences In Simulated Laparoscopic Scenarios Under High And Low Attentional Demands
Background/context The acquisition of expertise requires that individuals develop complex, integrated systems of representations that facilitate the execution, monitoring, planning and analyses of performance.1 In order to determine what constitutes expertise in surgery it is important to examine the underlying processes utilised by experts. Simulation technologies enable medical educators to examine these processes and determine key performance metrics that differentiate expert and less-expert surgeons.2 Once identified, educators can design and implement specific training environments and interventions that enable the underlying processes and mechanisms to be developed via engagement in deliberate practice activities. Methodology A sample of medical students and postgraduate students matched on demographic information, will perform a series of simulated laparoscopic procedures on a CAE Healthcare LapVR system. Eye movements, performance outcome, tool efficiency/kinematics, as well as heart rate will be recorded in low (primary task only) and high (primary and secondary task) attention scenarios as well as simple and complex procedures. Results/outcomes We will present pilot data looking at a case study comparison of a surgeon against a non-medical participant. Based on previous research,4 we expect the surgeon to perform better, have more efficient eye (fewer fixations of longer duration) and tool movements, and be less affected by an increase in attentional and complexity demands, compared to the non-medical participant. Breakdown in primary and secondary task performance is expected to occur in the complex high-attention condition. Potential Impact By identifying the critical characteristics that are associated with expertise, training interventions can be designed and implemented to enhance the specific skills and necessary adaptations that are essential to expertise in medicine subsequently improving the quality of patient treatment and reducing the costs associated with healthcare. References Causer J, Williams AM (2012). Professional expertise in medicine. In P. Lanzer (Ed.), Catheter-based Cardiovascular Interventions - Knowledge-based Approach (pp. 97–112). NY: Springer Causer J, Barach P, Williams AM. Expertise in medicine: using the expert performance approach to improve simulation training. Medical Education 2014;48(2):115–123 Causer J, et al. Performing Under Pressure: Quiet Eye Training Improves Surgical Knot-tying Performance. Surgery 2014 Zevin B, Aggarwal R, Grantcharov TP. Surgical Simulation in 2013: why is it still not the standard in surgical training? J Am Coll Surg 2014;218(2):294–301 |
package history
import (
"errors"
"testing"
"time"
)
func TestValidatorCreate(t *testing.T) {
now := time.Now()
testCases := []struct {
tname string
repositoryEntries []*Entry
entry *Entry
wantErr error
}{
// nominal cases
{
tname: "new entry",
entry: &Entry{
Date: now,
SubmissionID: 856,
},
},
{
tname: "new duplicate entry",
repositoryEntries: []*Entry{
{
ID: 1,
Date: now,
SubmissionID: 856,
},
},
entry: &Entry{
Date: now,
SubmissionID: 856,
},
},
// error cases
{
tname: "submission ID is negative",
entry: &Entry{ID: -67},
wantErr: ErrSubmissionIDNegativeOrZero,
},
{
tname: "submission ID equals zero",
entry: &Entry{ID: 0},
wantErr: ErrSubmissionIDNegativeOrZero,
},
}
for _, tc := range testCases {
t.Run(tc.tname, func(t *testing.T) {
nEntries := len(tc.repositoryEntries)
repository := &repositoryInMemory{
entries: tc.repositoryEntries,
}
validator := newValidator(repository)
err := validator.Create(tc.entry)
if tc.wantErr != nil {
if err == nil {
t.Error("expected an error but got none")
} else if !errors.Is(err, tc.wantErr) {
t.Errorf("want error %q, got %q", tc.wantErr, err)
}
return
}
if err != nil {
t.Errorf("expected no error, got %q", err)
return
}
wantNEntries := nEntries + 1
if len(repository.entries) != wantNEntries {
t.Errorf("want %d entries, got %d", wantNEntries, len(repository.entries))
return
}
entry, err := repository.Current()
if err != nil {
t.Errorf("failed to retrieve entry: %q", err)
return
}
if entry.SubmissionID != tc.entry.SubmissionID {
t.Errorf("want submission ID %d, got %d", tc.entry.SubmissionID, entry.SubmissionID)
}
})
}
}
|
def recv_compressed(self):
try:
return self._packet_queue.popleft()
except IndexError:
pass
header = bytearray(b'')
packets = []
try:
abyte = self.sock.recv(1)
while abyte and len(header) < 7:
header += abyte
abyte = self.sock.recv(1)
while header:
if len(header) < 7:
raise errors.InterfaceError(errno=2013)
zip_payload_length = struct_unpack("<I",
header[0:3] + b'\x00')[0]
payload_length = struct_unpack("<I", header[4:7] + b'\x00')[0]
zip_payload = init_bytearray(abyte)
while len(zip_payload) < zip_payload_length:
chunk = self.sock.recv(zip_payload_length
- len(zip_payload))
if len(chunk) == 0:
raise errors.InterfaceError(errno=2013)
zip_payload = zip_payload + chunk
if payload_length == 0:
self._split_zipped_payload(zip_payload)
return self._packet_queue.popleft()
packets.append(header + zip_payload)
if payload_length != 16384:
break
header = init_bytearray(b'')
abyte = self.sock.recv(1)
while abyte and len(header) < 7:
header += abyte
abyte = self.sock.recv(1)
except IOError as err:
raise errors.OperationalError(
errno=2055, values=(self.get_address(), _strioerror(err)))
tmp = init_bytearray(b'')
for packet in packets:
payload_length = struct_unpack("<I", header[4:7] + b'\x00')[0]
if payload_length == 0:
tmp.append(packet[7:])
else:
if PY2:
tmp += zlib.decompress(
buffer(packet[7:]))
else:
tmp += zlib.decompress(packet[7:])
self._split_zipped_payload(tmp)
del tmp
try:
return self._packet_queue.popleft()
except IndexError:
pass |
Eastern Anatolia Observatory (DAG): the status in 2022, towards the first light
East Anatolian Observatory’s DAG telescope, with its 4m diameter primary mirror and VIS/IR observation capability, Eastern Anatolian Observatory’s 4m diameter class DAG telescope, with VIS/IR observation capability, will be located on the Konaklı-Karaya summit at an altitude of 3170 m, near the city of Erzurum, Turkey. DAG contains both active optics (aO) and adaptive optics (AO) systems. With the enclosure assembly nearly done, and the dummy mirror integration including the M1 cell integration performed at the end of 2021; DAG telescope's AIV is planned to take place by the end of May/2022 and the Provisional Acceptance by November/2022. DAG is equipped with an in-flange derotator – KORAY (K-mirror Optical RelAY) that will direct the light to the seeing limited Nasmyth platform containing TROIA (TuRkish adaptive Optics system for Infrared Astronomy). The scientific instruments that DAG will receive in 2022, are but not limited to, a stellar coronagraph and a 30" NIR diffraction limited camera. In his paper, a global status update and expected optical performance characteristics will be presented. |
def Exit(self):
if self.Alive():
if sys.platform == "win32":
import win32api
win32api.TerminateProcess(int(self.pd._handle), -1)
else:
from os import kill
kill(self.pd.pid, signal.SIGINT)
if self.pd:
self.pd.wait() |
// Copyright © 2012 <NAME>, <NAME>
// This is under the 2 clause BSD license.
// See the included LICENSE.TXT file for more details.
#pragma once
#include <boost/noncopyable.hpp>
#include <string>
#include <memory>
#include <vector>
#include <windows.h>
#include "Win32Exception.hpp"
#include "Library.hpp"
namespace Instalog { namespace SystemFacades {
/// @brief Event log entry interface
struct EventLogEntry
{
/// @summary The date and time that the event was logged
FILETIME date;
/// @brief Different log event severities
typedef enum _EVT_LEVEL {
EvtLevelCritical = 1,
EvtLevelError = 2,
EvtLevelWarning = 3,
EvtLevelInformation = 4
} EVT_LEVELS;
/// @summary The severity according to EVT_LEVELS
WORD level;
/// @summary The event id
DWORD eventId;
/// @brief Default constructor.
EventLogEntry();
/// @brief Move constructor.
///
/// @param [in,out] e The EventLogEntry to process.
EventLogEntry(EventLogEntry && e);
/// @brief Destructor.
virtual ~EventLogEntry();
/// @brief Gets the source name of the creator of the log entry
///
/// @return The source.
virtual std::wstring GetSource() = 0;
/// @brief Gets the description of the event
///
/// @return The description.
virtual std::wstring GetDescription() = 0;
};
class OldEventLogEntry : public EventLogEntry
{
DWORD eventIdWithExtras;
std::wstring source;
std::vector<std::wstring> strings;
std::wstring dataString;
public:
/// @brief Constructor from an event record structure
///
/// @param pRecord The record.
OldEventLogEntry(PEVENTLOGRECORD pRecord);
/// @brief Move constructor.
///
/// @param [in,out] e The OldEventLogEntry to process.
OldEventLogEntry(OldEventLogEntry && e);
/// @brief Gets the source name of the creator of the log entry
///
/// @return The source.
virtual std::wstring GetSource();
/// @brief Gets the description of the event
///
/// @return The description.
virtual std::wstring GetDescription();
};
class XmlEventLogEntry : boost::noncopyable, public EventLogEntry
{
HANDLE eventHandle;
std::wstring providerName;
/// @brief Formats messages according to the provided flag
///
/// @param messageFlag The message flag.
///
/// @return The formatted message or "" if the message didn't exist
std::wstring FormatEventMessage(DWORD messageFlag);
public:
/// @brief Constructor for an event from a handle to the event
///
/// @param handle Handle to the event
XmlEventLogEntry(HANDLE handle);
/// @brief Move constructor.
///
/// @param [in,out] x The XmlEventLogEntry to process.
XmlEventLogEntry(XmlEventLogEntry && x);
/// @brief Move assignment operator.
///
/// @param [in,out] x The XmlEventLogEntry to process.
///
/// @return A shallow copy of this instance.
XmlEventLogEntry& operator=(XmlEventLogEntry && x);
/// @brief Destructor, frees the handle
~XmlEventLogEntry();
/// @brief Gets the source name of the creator of the log entry
///
/// @return The source.
virtual std::wstring GetSource();
/// @brief Gets the description of the event
///
/// @return The description.
virtual std::wstring GetDescription();
};
/// @brief Event log interface
struct EventLog : boost::noncopyable
{
/// @brief Destructor.
virtual ~EventLog();
/// @brief Reads the applicable events
///
/// @return The events.
virtual std::vector<std::unique_ptr<EventLogEntry>> ReadEvents() = 0;
};
/// @brief Wrapper around the old Win32 event log
class OldEventLog : public EventLog
{
HANDLE handle;
public:
/// @brief Constructor.
///
/// @param sourceName (optional) name of the log source.
OldEventLog(std::wstring sourceName = L"System");
/// @brief Destructor, frees the handle
~OldEventLog();
/// @brief Reads the applicable events
///
/// @return The events.
std::vector<std::unique_ptr<EventLogEntry>> ReadEvents();
};
/// @brief Wrapper around the new (Vista and later) XML Win32 event log
class XmlEventLog : public EventLog
{
HANDLE queryHandle;
public:
/// @brief Constructor.
///
/// @param logPath (optional) full pathname of the log file.
/// @param query (optional) the query.
///
/// @throws FileNotFoundException on incompatible machines
XmlEventLog(wchar_t* logPath = L"System", wchar_t* query = L"Event/System");
/// @brief Destructor, frees the handle
~XmlEventLog();
/// @brief Reads the applicable events
///
/// @return The events.
std::vector<std::unique_ptr<EventLogEntry>> ReadEvents();
};
}} |
The first day of jury selection in the second Oregon standoff trial ended Tuesday with 41 prospective jurors still in the pool and the judge not granting much leeway to either defense lawyers or prosecutors in their requests to bounce people for perceived biases.
The outcome of the first trial against seven co-defendants wasn't mentioned in court all day, nor was the name of the occupation leader, Ammon Bundy, who was acquitted last fall.
"There was a trial last fall. They returned a verdict. There was a lot of publicity,'' U.S. District Judge Anna J. Brown told the morning panel of prospective jurors summoned to court. "Did any of you come to any opinion?''
One hand shot up.
"Well just from the publicity, available information, it seemed that the jury got it right,'' said a man only referred to in court as prospective Juror No. 11. "I don't second guess the jury instructions or legal issues.''
"Does the fact that you know how another jury decided against seven other people involved in the occupation affect your ability to try this case fairly?'' the judge continued.
"No, it does not,'' he said.
The judge stressed that this trial involving four defendants has "to rise and fall'' based on the evidence presented, not on what happened last fall.
The four on trial are charged with federal conspiracy to impede federal workers from doing their work at the Malheur National Wildlife Refuge through intimidation, threat or force in the 41-day refuge occupation. Some face other weapons and depredation of property charges. The judge will issue verdicts on other misdemeanor charges, including trespassing.
Another woman, a member of the Audubon Society, told the court she was "surprised at the outcome'' of the initial trial. "It's not what I had expected,'' she said.
"Can you set that aside?'' the judge asked. "Could you try these four defendants based on what happens here?''
"Yes,'' the woman replied. "I would like to be a juror.''
Defense lawyers sought to dismiss two people for cause, based on their answers to a lengthy jury questionnaire.
Defense lawyer Jesse Merrithew urged the court to dismiss a woman who wrote that "armed occupation, preventing people from doing their job, it sounds extreme to me.'' During questioning, the woman said she didn't agree with "extreme measures to get your point across.''
Assistant U.S. Attorney Ethan Knight countered that the woman, in court, told the judge she could be fair and impartial.
The judge kept her on.
Merrithew also asked the court to toss out a man who wrote on the questionnaire, "I think there's better ways to achieve what you're trying to achieve than trying to start an armed rebellion.'' Merrithew argued that the defense team would face an "uphill battle'' trying to change the man's mind.
Knight countered that the man told the court that he recognized his initial opinion about the refuge occupation was informed by "word of mouth'' and that he would fairly evaluate the facts presented in this case.
Knight suggested removal of a potential juror who said the government hasn't managed public land very well. The man, Knight argued, professed animosity toward the U.S. Bureau of Land Management.
The defense countered that there's a big difference between disagreeing with a federal policy and expressing an opinion about the defendants in a criminal case.
The judge kept the man in play.
"Each expressed opinions but articulated a willingness to decide the case fairly,'' the judge found.
A Burns High School graduate alerted the court that she knew a handful of the witnesses, including former Harney County commission chairman Steve Grasty and others, but said she wasn't aware of the outcome of the first trial. She said she had worked one summer for the U.S. Forest Service in Burns and had a positive experience, but hasn't had ties to the city for about 11 years.
The judge asked her how she felt about having to judge the credibility of people from her hometown who would be called as witnesses.
"I would like to say that I could,'' she replied.
Her one concern was that some of the witnesses likely would recognize her. "It is a big case and it is a small town,'' the woman told the court.
Brown, who has worked to insulate potential jurors in the case by referring to them only by number, decided to dismiss her. "I think she's in an impossible situation,'' the judge said. "Because of who she is, she's known and that's just not right.''
Prosecutors asked the court to dismiss another woman who spoke of some anxiety if she served on the jury, suggesting she be released for hardship. The woman also had written in her jury questionnaire that she thought the government response during the refuge occupation was "heavy handed.''
Asked in court what she meant by that, the woman responded, "The fatality involved,'' referring to the fatal police shooting of occupation spokesman Robert "LaVoy'' Finicum on Jan. 26 on his way to attend a community meeting in John Day. He sped away from a police stop, crashed into a snowbank to avoid a police roadblock and was shot after he emerged from his truck. Police said he had reached into his jacket at least two times to grab his loaded 9mm pistol, which officers found on him later.
Merrithew argued that the woman who spoke of some anxiety really was expressing a lack of confidence and pointed out that she had told the judge in court that she had no problem following her directions.
The judge kept her in the pool.
The defense tried to throw out another juror who retired three years ago from the Forest Service, where he had worked 20 years. He began in fire suppression, then worked as a purchasing agent, buying everything from supplies for firefighters to airplane retardant and pens and pencils for the agency, he said.
Knight said there was no basis to dismiss the retired worker, noting he said in court that he could keep an open mind. "The U.S. Forest Service is not a named victim in the case,'' Knight added.
The judge kept the man.
Merrithew also asked the court to dismiss a man who described himself as an "interested observer" of the Oregon standoff from its start and wrote in his questionnaire, "It seemed like laws were broken'' and that keeping employees from going to their workplace seemed wrong.
The judge asked the man whether he could evaluate the facts in this trial fairly, for example if he's told that refuge employees weren't blocked from coming to work. "I would certainly reconsider that,'' he said.
"Reconsidering suggests he's not coming in applying presumption of innocence,'' Merrithew argued.
The judge wasn't convinced. He may not have used the best words, but Brown said she didn't think the man's remarks displayed any clear bias that would disqualify him.
A final group of 25 prospective jurors will be questioned Wednesday morning, and then prosecutors and defense attorneys will have what's called peremptory challenges, meaning they can ask to dismiss certain people for no reason at all.
The defense has 15 such challenges and the prosecutors have nine.
The judge expects 12 jurors and four alternates to be selected by Wednesday afternoon for what's anticipated to be a four-week trial.
Opening statements are set to begin at 10 a.m. next Tuesday.
-- Maxine Bernstein
[email protected]
503-221-8212
@maxoregonian |
The role of the bursa of Fabricius in the immune response to vaccinal antigens and the development of immune tolerance in chicks (Gallus domesticus) vaccinated at a very young age
&NA; Vaccination is recognized to be the most cost‐effective means of preventing, controlling, and even eradicating infectious diseases. Conventional poultry are vaccinated through various routes including eye/nose drops, drinking water, vent brush, or injection. Efficient vaccination is an essential part of any good poultry management. The bursa of Fabricius is intimately connected to the cloaca and the intestinal system. It is well‐known as a primary lymphoid organ in the chicken and a major channel through which environmental antigens stimulate the immune system. In this study we tested whether direct instillation of various viral vaccines and antigens into the cloaca (per bursam), could stimulate higher antibody titers and generate improved protection. Despite the very rapid absorption of the vaccines or antigens from the cloaca to the lumen of the Bursa of Fabricius, per bursam inoculation failed to generate a satisfactory immune response. In contrast conventional administration of live or inactivated commercial vaccines led to an acceptable level of seroconversion and protection against challenge. An interesting finding in this study was the fact that administration of a single priming dose of antigenic material at age 1 or 5 days, did not improve the response to a second administration at 14 days of age as expected. Instead, in most cases there was a reduced serum antibody response suggesting the induction of tolerance. This was true for all routes of administration (intramuscular, per ocular and per bursam) and for all formulations of vaccine. The current study reveals: 1) no advantage for direct application of live or inactivated vaccines or antigens into the bursa of Fabricius compared to common routes of vaccination, 2) that apparent desensitization or tolerance effects have important implications for poultry management, since in many countries, vaccination of day old chicks is compulsory or a well‐accepted part of flock vaccination. According to our results, early vaccination can in fact reduce or inhibit a secondary immune response to subsequent vaccination and increase susceptibility to disease agents. |
// SyncedNotificationAppInfoTemp is a class that contains the information
// necessary to produce a welcome notification and the app badges for all synced
// notification.
// TODO(dewittj): Convert this into a sync protobuf-backed data structure.
class SyncedNotificationAppInfoTemp {
public:
explicit SyncedNotificationAppInfoTemp(const std::string& app_id,
const base::string16& service_name);
~SyncedNotificationAppInfoTemp();
const std::string& app_id() const { return app_id_; }
const base::string16& service_name() const { return service_name_; }
const base::string16& title() const { return title_; }
void set_icon(const gfx::Image& icon) { icon_ = icon; }
const gfx::Image& icon() const { return icon_; }
void set_small_icon(const gfx::Image& small_icon) {
small_icon_ = small_icon;
}
const gfx::Image& small_icon() const { return small_icon_; }
const message_center::NotifierId GetNotifierId() const;
private:
std::string app_id_;
base::string16 service_name_;
gfx::Image icon_;
gfx::Image small_icon_;
base::string16 title_;
base::string16 message_;
} |
// makeFileList creates a list of files to be packed into tpk package.
// gotizen do not use any hand-crafted build configuration files like Makfile,
// CMakeList.txt or similar, so only source of information about package files
// is tizen-manifest.xml
func makeFileList(manifest *TizenManifest) (files []PackageFile, err error) {
list, err := makeFileListFromAppsList(manifest.UIAppEntries)
if err != nil {
return nil, err
}
files = append(files, list...)
list, err = makeFileListFromAppsList(manifest.ServiceAppEntries)
if err != nil {
return nil, err
}
files = append(files, list...)
files = append(files, manifest)
authorSignature, err := createSignature(AuthorSignature, files)
if err != nil {
return nil, err
}
files = append(files, authorSignature)
distributorSignature, err := createSignature(DistributorSignature, files)
if err != nil {
return nil, err
}
files = append(files, distributorSignature)
return files, nil
} |
<reponame>BryanCruz/haskell-stuff
{-# LANGUAGE OverloadedStrings #-}
module Main where
import System.Environment
import Formatting
import Formatting.Clock
import System.Clock
import Data.List.Split (chunksOf)
import Control.DeepSeq
import KMeansPar
main :: IO ()
main = do
[fname, sk, sit, schunks] <- getArgs
fileTrain <- readFile fname
let k = read sk :: Int
it = read sit :: Int
nchunks = read schunks :: Int
train = parseFile fileTrain
chunks = force $ chunksOf nchunks train
clusters = take k train
start <- getTime Monotonic
let clusters' = kmeans it chunks clusters
print clusters'
stop <- getTime Monotonic
fprint (timeSpecs % "\n") start stop
return ()
|
package room
import (
"context"
"fmt"
"time"
"github.com/pkg/errors"
"go-common/app/interface/live/app-interface/conf"
cDao "go-common/app/interface/live/app-interface/dao"
roomV1 "go-common/app/service/live/room/api/liverpc/v1"
"go-common/library/log"
rpcCtx "go-common/library/net/rpc/liverpc/context"
)
// 获取首页推荐强推列表
func (d *Dao) GetStrongRecList(ctx context.Context, recPage int64) (strongRecRoomListResp *roomV1.RoomRecommendClientRecStrongResp, err error) {
strongRecRoomListResp = &roomV1.RoomRecommendClientRecStrongResp{}
clientRecStrongTimeout := time.Duration(conf.GetTimeout("clientRecStrong", 100)) * time.Millisecond
strongRecRoomList, err := cDao.RoomApi.V1RoomRecommend.ClientRecStrong(rpcCtx.WithTimeout(ctx, clientRecStrongTimeout), &roomV1.RoomRecommendClientRecStrongReq{
RecPage: recPage,
})
if err != nil {
log.Error("[GetStrongRecList]room.v1.clientStrongRec rpc error:%+v", err)
err = errors.New(fmt.Sprintf("room.v1.clientStrongRec rpc error:%+v", err))
return
}
if strongRecRoomList.Code != 0 {
log.Error("[GetStrongRecList]room.v1.getPendantByIds response code:%d,msg:%s", strongRecRoomList.Code, strongRecRoomList.Msg)
err = errors.New(fmt.Sprintf("room.v1.getPendantByIds response error, code:%d, msg:%s", strongRecRoomList.Code, strongRecRoomList.Msg))
return
}
if strongRecRoomList.Data == nil || strongRecRoomList.Data.Result == nil {
log.Error("[GetStrongRecList]room.v1.getPendantByIds empty")
err = errors.New("[getSkyHorseRoomList]room.v1.getPendantByIds empty")
return
}
strongRecRoomListResp = strongRecRoomList
return
}
|
def sync_iter(func: Callable[P, Iterable[T]]) -> Callable[P, 'SyncIter[T]']:
@wraps(func)
def wrapper(*args: P.args, **kwargs: P.kwargs) -> 'SyncIter[T]':
return SyncIter(func(*args, **kwargs))
return wrapper |
/* Free BLOC from the chain of blocs, relocating any blocs above it.
This may return space to the system. */
static void
free_bloc (bloc_ptr bloc)
{
heap_ptr heap = bloc->heap;
heap_ptr h;
if (r_alloc_freeze_level)
{
bloc->variable = NULL;
return;
}
resize_bloc (bloc, 0);
if (bloc == first_bloc && bloc == last_bloc)
{
first_bloc = last_bloc = NIL_BLOC;
}
else if (bloc == last_bloc)
{
last_bloc = bloc->prev;
last_bloc->next = NIL_BLOC;
}
else if (bloc == first_bloc)
{
first_bloc = bloc->next;
first_bloc->prev = NIL_BLOC;
}
else
{
bloc->next->prev = bloc->prev;
bloc->prev->next = bloc->next;
}
for (h = first_heap; h != NIL_HEAP; h = h->next)
if (heap == h)
break;
if (h)
{
if (heap->first_bloc == bloc)
{
if (bloc->next != 0 && bloc->next->heap == heap)
heap->first_bloc = bloc->next;
else
heap->first_bloc = heap->last_bloc = NIL_BLOC;
}
if (heap->last_bloc == bloc)
{
if (bloc->prev != 0 && bloc->prev->heap == heap)
heap->last_bloc = bloc->prev;
else
heap->first_bloc = heap->last_bloc = NIL_BLOC;
}
}
relinquish ();
free (bloc);
} |
/**
* Given a string in the form NN% return the corresponding double.
*
* No Ruby usage (internal function)
*
* @param str the string
* @return a double
*/
double
rm_str_to_pct(VALUE str)
{
long pct;
char *pct_str, *end;
str = rb_rescue(rb_str_to_str, str, rescue_not_str, str);
pct_str = StringValueCStr(str);
errno = 0;
pct = strtol(pct_str, &end, 10);
if (errno == ERANGE)
{
rb_raise(rb_eRangeError, "`%s' out of range", pct_str);
}
if (*end != '%')
{
rb_raise(rb_eArgError, "expected percentage, got `%s'", pct_str);
}
if (pct < 0L)
{
rb_raise(rb_eArgError, "percentages may not be negative (got `%s')", pct_str);
}
return pct / 100.0;
} |
Inhibition of a protease associated with tumour cells and the probable mechanism of regulation of this interaction in vivo.
The regulation of activity of a protease on the surface of human colonic tumour cells implanted in nude mice has been studied. A synthetic fluorescent probe was used to locate cells possessing active guanidinobenzoatase in frozen sections of tumour bearing tissues. These studies demonstrated the presence of intracellular protein inhibitors of guanidinobenzoatase which could be extracted in isotonic saline and transferred to the outer surface of the tumour cells. This study showed that the inhibition of guanidinobenzoatase was pH dependent and that the tumour cell may regulate the activity of its surface guanidinobenzoatase by exporting lactic acid. |
<reponame>sashka/signedvalue<filename>signedvalue_test.go
package signedvalue
import (
"strings"
"testing"
)
// Test field decoder.
func TestConsumeField(t *testing.T) {
tests := []struct {
field string
value string
next int
err error
}{
{field: "0:|", value: "", next: 3, err: nil},
{field: "1:1|", value: "1", next: 4, err: nil},
// empty field
{field: "", value: "", next: -1, err: ErrMalformedField},
// no field separator
{field: "1:1", value: "", next: -1, err: ErrMalformedField},
// length mismatch
{field: "0:11|", value: "", next: -1, err: ErrMalformedField},
{field: "8:|", value: "", next: -1, err: ErrMalformedField},
{field: "4:Hello|", value: "", next: -1, err: ErrMalformedField},
// prefixed length
{field: "-0:|", value: "", next: -1, err: ErrMalformedField},
{field: "+0:|", value: "", next: -1, err: ErrMalformedField},
{field: "+1:1|", value: "", next: -1, err: ErrMalformedField},
{field: "01:1|", value: "", next: -1, err: ErrMalformedField},
{field: "001:1|", value: "", next: -1, err: ErrMalformedField},
// malformed fields
{field: "|", value: "", next: -1, err: ErrMalformedField},
{field: ":|", value: "", next: -1, err: ErrMalformedField},
{field: "|1:", value: "", next: -1, err: ErrMalformedField},
{field: "|1:1", value: "", next: -1, err: ErrMalformedField},
{field: "sdf8|", value: "", next: -1, err: ErrMalformedField},
{field: ":adf|", value: "", next: -1, err: ErrMalformedField},
{field: "1:|||||||||", value: "", next: -1, err: ErrMalformedField},
{field: "[:||||:]", value: "", next: -1, err: ErrMalformedField},
{field: "4:1|23|1:1", value: "", next: -1, err: ErrMalformedField},
}
for _, tt := range tests {
// The first attempt to decode a field.
got, next, err := consumeField(tt.field, 0)
if got != tt.value || next != tt.next || err != tt.err {
t.Errorf(`consumeField("%v", %v): want: ("%v", "%v", %v), got ("%v", "%v", "%v")`,
tt.field, 0, tt.value, tt.next, tt.err, got, next, err)
}
// The second attempt to decode the next field.
// This attempt is specifically designed for malformed fields with many pipes.
// consumeField should always return an error.
if err == nil {
got2, next2, err2 := consumeField(tt.field, next)
if err2 != ErrMalformedField {
t.Errorf(`consumeField("%v", %d): want ("%v", "%v", "%v"), got: ("%v", "%v", "%v")`,
tt.field, next, "", -1, ErrMalformedField, got2, next2, err2)
}
}
}
// Try to read from after the end of the string.
// consumeField should always return an error.
for _, tt := range tests {
offset := len(tt.field) + 1
got, next, err := consumeField(tt.field, offset)
if err != ErrMalformedField {
t.Errorf(`consumeField("%v", %v): want: ("%v", "%v", "%v"), got ("%v", "%v", "%v")`,
tt.field, offset, tt.value, tt.next, ErrMalformedField, got, next, err)
}
}
}
func TestConsumeIntField(t *testing.T) {
tests := []struct {
field string
value int
next int
err error
}{
{field: "1:1|", value: 1, next: 4, err: nil},
// empty value
{field: "0:|", value: 0, next: -1, err: ErrMalformedField},
// float
{field: "4:10.1|", value: 0, next: -1, err: ErrMalformedField},
}
for _, tt := range tests {
got, next, err := consumeIntField(tt.field, 0)
if got != tt.value || next != tt.next || err != tt.err {
t.Errorf(`consumeIntField("%v", 0): want: ("%v", "%v", "%v"), got ("%v", "%v", "%v")`,
tt.field, tt.value, tt.next, tt.err, got, next, err)
}
}
}
// The following tests are mostly adopted from Tornado's SignedValueTest.
const secret = "It's a secret to everybody"
const present = 1300000000
const past = present - 86400*31
const future = present + 86400*31
var secrets = map[int]string{
0: "ajklasdf0ojaisdf",
1: "aslkjasaolwkjsdf",
}
func TestKnownValues(t *testing.T) {
wantSigned := "2|1:0|10:1300000000|3:key|8:dmFsdWU=|3d4e60b996ff9c5d5788e333a0cba6f238a22c6c0f94788870e1a9ecd482e152"
wantDecoded := "value"
signed := create(secret, 0, "key", wantDecoded, present)
if signed != wantSigned {
t.Fatalf(`create: want "%v", got "%v"`, wantSigned, signed)
}
decoded, err := decode(secret, "key", signed, present, 0)
if err != nil || decoded != wantDecoded {
t.Fatalf(`decode: want ("%v", "%v"), got ("%v", "%v")`, wantDecoded, nil, decoded, err)
}
}
func TestNameSwap(t *testing.T) {
wantDecoded := ""
signed := create(secret, 0, "key2", "value", present)
decoded, err := decode(secret, "key1", signed, present, 0)
if err != ErrInvalidName || decoded != wantDecoded {
t.Fatalf(`decode: want ("%v", "%v"), got ("%v", "%v")`, wantDecoded, ErrInvalidName, decoded, err)
}
}
func TestExpired(t *testing.T) {
value := "value"
ttl := 30 * 86400
// Sign the value in the past.
signed := create(secret, 0, "key1", value, past)
// Decode in the past. Should never fail.
decoded, err := decode(secret, "key1", signed, past, ttl)
if err != nil || decoded != value {
t.Fatalf(`decode: want ("%v", "%v"), got ("%v", "%v")`, value, nil, decoded, err)
}
// Decode in present time. Should fail.
decoded, err = decode(secret, "key1", signed, present, ttl)
if err != ErrSignatureExpired || decoded != "" {
t.Fatalf(`decode: want ("%v", "%v"), got ("%v", "%v")`, "", ErrSignatureExpired, decoded, err)
}
}
func TestFuture(t *testing.T) {
value := "value"
ttl := 30 * 86400
// Sign the value in the future.
signed := create(secret, 0, "key1", value, future)
// Decode in the future. Should never fail.
decoded, err := decode(secret, "key1", signed, future, ttl)
if err != nil || decoded != value {
t.Fatalf(`decode: want ("%v", "%v"), got ("%v", "%v")`, value, nil, decoded, err)
}
// Decode in present time. Should fail.
decoded, err = decode(secret, "key1", signed, present, ttl)
if err != ErrSignatureInFuture || decoded != "" {
t.Fatalf(`decode: want ("%v", "%v"), got ("%v", "%v")`, "", ErrSignatureInFuture, decoded, err)
}
}
func TestPayloadTampering(t *testing.T) {
// These are variants of the one in TestKnownValues.
sig := "3d4e60b996ff9c5d5788e333a0cba6f238a22c6c0f94788870e1a9ecd482e152"
tests := []struct {
prefix string
value string
err error
}{
{prefix: "2|1:0|10:1300000000|3:key|8:dmFsdWU=|", value: "value", err: nil},
// change key version
{prefix: "2|1:1|10:1300000000|3:key|8:dmFsdWU=|", value: "", err: ErrInvalidKey},
// zero length key version
{prefix: "2|0:|10:1300000000|3:key|8:dmFsdWU=|", value: "", err: ErrMalformedField},
// malformed
{prefix: "2|1:0|:1300000000|3:key|8:dmFsdWU=|", value: "", err: ErrMalformedField},
// length mismatch (field too short)
{prefix: "2|1:0|10:130000000|3:key|8:dmFsdWU=|", value: "", err: ErrMalformedField},
// length mismatch (field too long)
{prefix: "2|1:0|10:1300000000|3:keey|8:dmFsdWU=|", value: "", err: ErrMalformedField},
}
for _, tt := range tests {
got, err := decode(secret, "key", tt.prefix+sig, present, 0)
if got != tt.value || err != tt.err {
t.Errorf(`decode("%v"): want: ("%v", "%v"), got ("%v", "%v")`, tt.prefix+sig, tt.value, tt.err, got, err)
}
}
}
func TestSignatureTampering(t *testing.T) {
prefix := "2|1:0|10:1300000000|3:key|8:dmFsdWU=|"
tests := []struct {
sig string
value string
err error
}{
{sig: "3d4e60b996ff9c5d5788e333a0cba6f238a22c6c0f94788870e1a9ecd482e152", value: "value", err: nil},
// all zeros
{sig: strings.Repeat("0", 32), value: "", err: ErrInvalidSignature},
// no signature
{sig: "", value: "", err: ErrInvalidSignature},
// change one character
{sig: "4d4e60b996ff9c5d5788e333a0cba6f238a22c6c0f94788870e1a9ecd482e152", value: "", err: ErrInvalidSignature},
// change another character
{sig: "3d4e60b996ff9c5d5788e333a0cba6f238a22c6c0f94788870e1a9ecd482e153", value: "", err: ErrInvalidSignature},
// truncate
{sig: "3d4e60b996ff9c5d5788e333a0cba6f238a22c6c0f94788870e1a9ecd482e15", value: "", err: ErrInvalidSignature},
// lengthen
{sig: "3d4e60b996ff9c5d5788e333a0cba6f238a22c6c0f94788870e1a9ecd482e1538", value: "", err: ErrInvalidSignature},
}
for _, tt := range tests {
got, err := decode(secret, "key", prefix+tt.sig, present, 0)
if got != tt.value || err != tt.err {
t.Errorf(`decode("%v"): want: ("%v", "%v"), got ("%v", "%v")`, prefix+tt.sig, tt.value, tt.err, got, err)
}
}
}
func TestNonASCII(t *testing.T) {
name := "hello"
value := "こんにちは"
signed := create(secret, 0, name, value, present)
decoded, err := decode(secret, name, signed, present, 0)
if err != nil || decoded != value {
t.Fatalf(`decode: want ("%v", "%v"), got ("%v", "%v")`, value, err, decoded, err)
}
}
func TestFormatVersion(t *testing.T) {
tests := []struct {
signed string
value string
err error
}{
// valid v2
{signed: "2|1:0|10:1300000000|3:key|8:dmFsdWU=|3d4e60b996ff9c5d5788e333a0cba6f238a22c6c0f94788870e1a9ecd482e152", value: "value", err: nil},
// valid v1
{signed: "dmFsdWU=|1300000000|31c934969f53e48164c50768b40cbd7e2daaaa4f", value: "", err: ErrMalformedField},
// invalid v1 starting with "2"
{signed: "2mFsdWU=|1300000000|31c934969f53e48164c50768b40cbd7e2daaaa4f", value: "", err: ErrMalformedField},
// malformed value
{signed: "2|1300000000|31c934969f53e48164c50768b40cbd7e2daaaa4f", value: "", err: ErrMalformedField},
}
for _, tt := range tests {
got, err := decode(secret, "key", tt.signed, present, 0)
if got != tt.value || err != tt.err {
t.Errorf(`decode("%v"): want: ("%v", "%v"), got ("%v", "%v")`, tt.signed, tt.value, tt.err, got, err)
}
}
}
func TestKeyVersioningReadWriteNonDefaultKey(t *testing.T) {
name := "key"
value := "\xe9"
signed, err := CreateWithKeyVersioning(secrets, 1, name, value)
if err != nil {
t.Fatalf(`CreateWithKeyVersioning: want (..., "%v"), got ("%v", "%v")`, nil, signed, err)
}
decoded, err := DecodeWithKeyVersioning(secrets, name, signed, 0)
if err != nil || decoded != value {
t.Fatalf(`DecodeWithKeyVersioning: want ("%v", "%v"), got ("%v", "%v")`, value, nil, decoded, err)
}
}
func TestKeyVersioningInvalidKey(t *testing.T) {
name := "key"
value := "\xe9"
signed, err := CreateWithKeyVersioning(secrets, 0, name, value)
if err != nil {
t.Fatalf(`CreateWithKeyVersioning: want (..., "%v"), got ("%v", "%v")`, nil, signed, err)
}
// Remove 0th secret key from the global map.
delete(secrets, 0)
decoded, err := DecodeWithKeyVersioning(secrets, name, signed, 0)
if err != ErrInvalidKey || decoded != "" {
t.Fatalf(`DecodeWithKeyVersioning: want ("%v", "%v"), got ("%v", "%v")`, "", ErrInvalidKey, decoded, err)
}
}
func TestPublicMethods(t *testing.T) {
name := "name"
value := "value"
// Unversioned secret key
signed := Create(secret, name, value)
decoded, err := Decode(secret, name, signed, 0)
if err != nil || decoded != value {
t.Fatalf(`Create: want ("%v", "%v"), got ("%v", "%v")`, value, nil, decoded, err)
}
// Empty string
decoded, err = Decode(secret, "key", "", 0)
if err != ErrMalformedField || decoded != "" {
t.Fatalf(`Decode: want ("%v", "%v"), got ("%v", "%v")`, value, nil, decoded, err)
}
// Versioned secret key
signed, err = CreateWithKeyVersioning(secrets, 1, name, value)
if err != nil {
t.Fatalf(`CreateWithKeyVersioning: want (..., "%v"), got ("%v", "%v")`, nil, signed, err)
}
decoded, err = DecodeWithKeyVersioning(secrets, name, signed, 0)
if err != nil || decoded != value {
t.Fatalf(`DecodeWithKeyVersioning: want ("%v", "%v"), got ("%v", "%v")`, value, nil, decoded, err)
}
}
// Benchmarking
var result string
func BenchmarkNoKeyVersioningCreate(b *testing.B) {
var signed string
for n := 0; n < b.N; n++ {
signed = Create(secret, "key", "value")
}
// Always store the result to a package level variable
// so the compiler cannot eliminate the Benchmark itself.
result = signed
}
func BenchmarkNoKeyVersioningDecode(b *testing.B) {
signed := Create(secret, "key", "value")
var decoded string
for n := 0; n < b.N; n++ {
decoded, _ = Decode(signed, "key", signed, 10)
}
// Always store the result to a package level variable
// so the compiler cannot eliminate the Benchmark itself.
result = decoded
}
|
// TODO: improve this once std::from_chars is available everywhere
optional<double> strToDouble(string_view str, size_t* pos) {
std::string copy(str);
const char* start = copy.c_str();
char* end;
errno = 0;
double val = strtod(start, &end);
if (start == end || errno == ERANGE)
return std::nullopt;
if (pos)
*pos = size_t(end - start);
return val;
} |
<reponame>evg656e/broadcast-example<gh_stars>0
import signal, { Signal } from './signal';
import WebSocket from './websocket';
console.log('defining Client');
/*!
\class Client
*/
export default class Client {
url: string;
ready: boolean;
closed: boolean;
messageReceived: Signal;
readyChanged: Signal;
ws: undefined | WebSocket;
timerId: undefined | number;
constructor(url) {
console.log('Client()', url);
this.url = url;
this.closed = true;
this.ready = false;
this.messageReceived = signal();
this.readyChanged = signal();
this.connect();
}
connect() {
console.log('Client.connect()', this.url);
this.closed = false;
if (this.ws === undefined) {
this.ws = new WebSocket(this.url);
this.ws.onmessage = this.handleMessage.bind(this);
this.ws.onopen = this.handleOpen.bind(this);
this.ws.onclose = this.handleClose.bind(this);
this.ws.onerror = this.handleError.bind(this);
}
}
diconnect() {
this.closed = true;
if (this.ws !== undefined)
this.ws.close();
if (this.timerId !== undefined) {
clearTimeout(this.timerId);
delete this.timerId;
}
}
reconnect() {
this.timerId = setTimeout(this.connect.bind(this), Client.RECONNECT_INTERVAL);
}
handleMessage(e) {
this.messageReceived(e.data);
}
handleOpen(e) {
console.log('Client.handleOpen()', e);
if (!this.ready) {
this.ready = true;
this.readyChanged(this.ready);
}
}
handleClose(e) {
console.log('Client.handleClose()', e);
if (this.ready) {
this.ready = false;
this.readyChanged(this.ready);
}
if (this.ws != null)
delete this.ws;
if (!this.closed)
this.reconnect();
}
handleError(e) {
console.error('Client.onError()', e);
}
send(text) {
this.ws.send(text);
}
static readonly RECONNECT_INTERVAL = 3000;
}
|
#include <kipr/botball.h>
int main()
{
printf("going straight\n");
motor(0,70);//motor 0 running 70%
motor(2,70);//motor 3 running 70%
msleep(5000);//motor 0 and 3 running 7 seconds
printf("turn left\n");
motor(0,50);//motor 0 running 50%
motor(2,0);//motor 2 running 0%
msleep(2000);//motor 0 and 3 running 2 seconds
printf( "going straight\n");
motor(0,50);//motor 0 running 50%
motor(2,50);//motor 3 running 50%
msleep(900);//motor 0 and 3 running 2 seconds
motor (0,30);
motor (2,0);
msleep (2500);
motor (0,30);
motor (2,30);
msleep (1900);
return 0;
}
|
/**
* Create new Object and return this new Object if success. Run only on
* tables with auto_increment id column.
*
* @param obj
* @return
*/
@Override
public BestScoreBean create(BestScoreBean obj)
{
log.debug("Start method...");
BestScoreBean objectToReturn = null;
try
{
PreparedStatement prepared = DAOConnection.getInstance().prepareStatement(
" INSERT INTO best_scores (player_name, game_date, game_category, game_level, game_score) "
+ " VALUES(?, ?, ?, ?, ?) ", Statement.RETURN_GENERATED_KEYS);
prepared.setString(1, obj.getPlayerName());
prepared.setObject(2, obj.getGameDate());
prepared.setInt(3, obj.getGameCategory());
prepared.setInt(4, obj.getGameLevel());
prepared.setInt(5, obj.getGameScore());
int affectedRows = prepared.executeUpdate();
if (affectedRows != 0)
{
ResultSet generatedKeys = prepared.getGeneratedKeys();
if (generatedKeys.next())
{
log.debug("Inserted id : " + generatedKeys.getLong(1));
objectToReturn = this.find(generatedKeys.getLong(1));
}
}
} catch (SQLException e)
{
log.error("Error creating new best_score : " + e);
}
log.debug("End method.");
return objectToReturn;
} |
<filename>include/cache/CacheInfo.h
/**
* @file CacheInfo.h
* @brief The header file of CacheInfo.
*
* This file defines struct CacheInfo and comparision function object
* of CacheInfo to implement different replacement algorithm.
*/
#ifndef CACHEINFO_H
#define CACHEINFO_H
namespace izenelib
{
namespace cache
{
/**
* \brief It stores the necessary info for Caching Algorithm.
* Other properties can be added if necessary. And differnt comparision
* function object of CacheInfo are used to implement different replacement a
* algorthm.
*
*/
template <class KeyType>
struct CacheInfo
{
KeyType key;
size_t docSize;
bool isHit; // for SLRU
unsigned int LastAccessTime;
unsigned int FirstAccessTime;
unsigned int TimeToLive; //reserved for further use.
unsigned int iCount;
template<class Archive>
void serialize(Archive & ar,
const unsigned int version)
{
ar & key;
ar & docSize;
ar & isHit;
ar & LastAccessTime;
ar & FirstAccessTime;
ar & TimeToLive;
ar & iCount;
}
};
template <class KeyType>
struct keyCmp
{
bool operator() (const CacheInfo<KeyType> &lhs, const CacheInfo<KeyType> &rhs) const
{
return lhs.key < rhs.key;
}
};
/*
*
* for lru caching algorithm.
*/
template <class KeyType>
struct lruCmp
{
bool operator() (const CacheInfo<KeyType> &lhs, const CacheInfo<KeyType> &rhs) const
{
return lhs.LastAccessTime < rhs.LastAccessTime
|| (lhs.LastAccessTime == rhs.LastAccessTime && lhs.iCount < rhs.iCount)
|| (lhs.LastAccessTime == rhs.LastAccessTime && lhs.iCount == rhs.iCount && lhs.key < rhs.key);
}
};
/*
*
* for lru caching algorithm.
*/
template <class KeyType>
struct lruCmp1
{
bool operator() (const CacheInfo<KeyType> &lhs, const CacheInfo<KeyType> &rhs) const
{
return lhs.LastAccessTime < rhs.LastAccessTime
|| (lhs.LastAccessTime == rhs.LastAccessTime && lhs.key < rhs.key);
}
};
/*
*
* for lfu caching algorithm.
*/
template <class KeyType>
struct lfuCmp
{
bool operator() (const CacheInfo<KeyType> &lhs, const CacheInfo<KeyType> &rhs) const
{
return lhs.iCount < rhs.iCount
|| (lhs.iCount == rhs.iCount && lhs.LastAccessTime < rhs.LastAccessTime)
|| (lhs.iCount == rhs.iCount && lhs.LastAccessTime == rhs.LastAccessTime && lhs.key < rhs.key);
}
};
/*
*
* for slru caching algorithm.
* As for slru, it is assumed that the item hits have higher priority than the items not hits.
*/
template <class KeyType>
struct slruCmp
{
//The item hits has higher priority than the item not hits.
bool operator() (const CacheInfo<KeyType> &lhs, const CacheInfo<KeyType> &rhs) const
{
return lhs.isHit < rhs.isHit
|| (lhs.isHit == rhs.isHit && lhs.LastAccessTime < rhs.LastAccessTime)
|| (lhs.isHit == rhs.isHit && lhs.LastAccessTime == rhs.LastAccessTime && lhs.iCount < rhs.iCount)
|| (lhs.isHit == rhs.isHit && lhs.LastAccessTime == rhs.LastAccessTime && lhs.iCount == rhs.iCount && lhs.key < rhs.key);
}
};
}
}
#endif //CacheInfo_H
|
<filename>tic-tac-toe-client/src/app/image-stack/ImageStack.tsx<gh_stars>0
import React, { FC } from 'react';
import styles from './ImageStack.module.scss';
export const ImageStack: FC<{
imageSources: ReadonlyArray<string | undefined>;
}> = ({ imageSources }) => (
<div className={`${styles.top} position-absolute h-100 w-100`}>
{imageSources
.filter(v => !!v)
.map((imageSource, index) => {
const strikeKey = `d${index}`;
return (
<img
key={strikeKey}
className={`${styles.top} d-block position-absolute h-100 w-100`}
src={imageSource}
alt="Game element"
/>
);
})}
</div>
);
|
Review on Nelliyathi kasayam in the management of Diabetes Mellitus (Neerizhivu)
Globally diabetes is a one of the major health challenges disease. This disease direct impact the socio economical level in person and country. Diabetes Mellitus is caused by lack of insulin activity. In type 2 diabetes there is resistance to the action of relative insulin it cause insulin deficiency. Ancient Siddha text Sarabenthira Vaithiya Muraigal has mentioned that Neerizhivu and their management under the Neerizhivu Sigitchai.’’Neerizhivu can be correlated with the Diabetic mellitus. Nelliyathi kasayam is mentioned for the treatment of Neerizhivu (diabetic). Nelliyathi kasayam is a poly herbal formula which include the following herbs such as Phyllanthus emblica, Strychnos potatorum, Tereminalia bellirica, Cissampelos pareira, Cyperus rotundus. The objective of this study (review) was to assess the efficacy and safety of Nelliyathi kasayam management of diabetes. A review of research work had been done in web search (Pub med Google Scholar, Medline and Science Direct) journals and herbs related books. Each herb in the drug has antidiabetic effect. Following are the common Mechanism of action when the herbs are do the anti-diabetic pharmacological action such as reduced insulin resistance in tissues, stimulates insulin secretion, regenerated β-cells, hypoglycemic effect inhibit the intestinal absorption( inhibitory effects alpha-glucosidase and alpha -amylase activities) and antioxidant action, For this pharmacological action the most of the ingredients of this drug contain the bioactive constituents of polyphenols, flavonoids alkaloids, terpenoids, , saponins glycosides, and tannins. Therapeutic activity of this drug had been alterate the pathological changes of the diabetes mellitus and improvement of illness. This study had been given scientific explanation for ancient drug of Nelliyathi kasayam use of diabetic. It can be concluded that Nelliyathi kasayam can be used as a siddha drug in treatment of diabetes mellitus. Further scientific evidence base on clinical studies are recommended with appropriate study design, adequate sample size, and statistical evidence to prove its therapeutic action. |
Curcumin as a therapeutic agent in leukemia
Leukemia comprises a group of hematological malignancies responsible for 8% of all cancers and is the most common cancer in children. Despite significant improvements in leukemia treatment, the efficacy of conventional chemotherapeutic agents is low and the disease carries a poor prognosis with frequent relapses and high mortality. Curcumin is a yellow polyphenol compound with diverse pharmacological actions including anticancer, antioxidant, antidiabetic, anti‐inflammatory, immunomodulatory, hepatoprotective, lipid‐regulating, antidepressant, and antiarthritic. Many cellular and experimental studies have reported the benefits of curcumin in treating leukemia. Curcumin's anticancer effects are exerted via various mechanisms. Here, we review the effects of curcumin on various types of leukemia whilst considering its mechanisms of action. |
/*
************************************************
username : smmehrab
fullname : <NAME>
email : <EMAIL>
institute : university of dhaka, bangladesh
session : 2017-2018
************************************************
*/
#include<stdio.h>
int main()
{
int n,m,i,j,c=0;
char temp;
scanf("%d %d\n",&n,&m);
i=0;
while(i<n)
{
j=0;
while(j<m)
{
if(j==m-1 && i==n-1){scanf("%c",&temp);}
else if(j==m-1){scanf("%c\n",&temp);}
else{scanf("%c ", &temp);}
if((temp=='C')||(temp=='M')||(temp== 'Y')){c++;j++;}
else {j++;}
}
i++;
}
if(c!=0){printf("#Color\n");}
else{printf("#Black&White\n");}
return 0;
}
|
<filename>kMeansClustering.py
import numpy as np
import os
import matplotlib.pyplot as plt
def compute_euclidean_distance(point, centroid):
return np.sqrt(np.sum(((point - centroid)**2)))
def assign_label_cluster(distance, data_point, centroids):
index_of_minimum = min(distance, key=distance.get)#find closest centroid
return [index_of_minimum, data_point, centroids[index_of_minimum]]
def compute_new_centroids(data_points, centroids):
return np.array(data_points + centroids)/2
def iterate_k_means(data_points, centroids, total_iteration):
label = []
cluster_label = []
total_points = len(data_points)
k = len(centroids)
f = open("/Users/leslie/Downloads/Simple-k-Means-Clustering-Python-master/centroids.csv", 'w+')
centroids_list = []
for iteration in range(0, total_iteration):
for index_point in range(0, total_points):
distance = {}
for index_centroid in range(0, k):
distance[index_centroid] = compute_euclidean_distance(data_points[index_point], centroids[index_centroid])
label = assign_label_cluster(distance, data_points[index_point], centroids)
centroids[label[0]] = compute_new_centroids(label[1], centroids[label[0]]) #label[1]:datapoint
print(centroids[label[0]])
if iteration == (total_iteration - 1):
cluster_label.append(label)
return [cluster_label, centroids,centroids_list]
def print_label_data(result):
print("Result of k-Means Clustering: \n")
for data in result[0]:
print("data point: {}".format(data[1]))
print("cluster number: {} \n".format(data[0]))
print("Last centroids position: \n {}".format(result[1]))
def create_centroids():
centroids = []
centroids.append([5.0, 0.0])
centroids.append([45.0, 70.0])
centroids.append([50.0, 90.0])
return np.array(centroids)
if __name__ == "__main__":
filename = os.path.dirname(__file__) + "/data.csv"
data_points = np.genfromtxt(filename, delimiter=",")
centroids = create_centroids()
total_iteration = 1
[cluster_label, new_centroids,centroids_list] = iterate_k_means(data_points, centroids, total_iteration)
print()
print_label_data([cluster_label, new_centroids])
print()
fig = plt.figure()
ax1 = fig.add_subplot(111)
for i in range(0,90):
ax1.scatter(data_points[i,0],data_points[i,1],c = 'r',marker = 'o')
for i in range(0,3):
ax1.scatter(new_centroids[i,0],new_centroids[i,1],c = 'b',marker = 'v')
# =============================================================================
# ax2 = fig.add_subplot(111)
# for data in cluster_label:
# if data[0]==0:
# ax2.scatter(data[1,0],data[1,1],c='r')
# if data[0]==1:
# ax2.scatter(data[1,0],data[1,1],c='b')
# if data[0]==2:
# ax2.scatter(data[1,0],data[1,1],c='g')
#
# =============================================================================
plt.xlim((5,120))
plt.ylim((5,150))
plt.show()
# =============================================================================
# rows_1 = np.random.randint(15,30, size=(25,2))
# rows_2 = np.random.randint(40,70, size=(25,2))
# rows_3 = np.random.randint(90,110, size=(25,2))
#
#
# data_points = np.row_stack((data_points,rows_1))
# data_points = np.row_stack((data_points,rows_2))
# data_points = np.row_stack((data_points,rows_3))
#
#
# np.savetxt('new.csv', data_points, delimiter = ',')
# =============================================================================
|
SDF‐based tracking control for state‐constrained nonholonomic systems with disturbances via relay switching control: Theory and experiment
This article investigates the tracking control problem for a kind of chained‐form nonholonomic systems in the presence of unknown time‐varying disturbances and full‐state constraints. First, a finite‐time tracking controller is constructed to drive the action of relay switching, which converts the whole control system into two design stages. In order to handle with the predefined asymmetric state constraints, the original tracking error system is turned into an unconstrained system on the basis of state‐dependent function (SDF) function transformations. In this framework, an adaptive tracking control strategy is proposed by means of backstepping and dynamic surface control. Correspondingly, another tracking control law is also constructed to assure the stability of the tracking error system before the action of switching. The theoretical analysis of stability indicates that the proposed tracking control scheme can guarantee that the output state tracking errors converge to zero and the desired state constraints are not violated. At the same time, all the closed‐loop system signals maintain bounded in entire control process. Finally, the validity of the presented tracking control algorithm is demonstrated by simulation and experiment results. |
/*---------------------------------------------------------------------------------------------
* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
* See LICENSE.md in the project root for license terms and full copyright notice.
*--------------------------------------------------------------------------------------------*/
import cx from 'classnames';
import React from 'react';
import { Tooltip } from '../Tooltip';
import { StylingProps } from '../utils';
import { WizardType } from './Wizard';
export type StepProps = {
/**
* The title/label of the step.
*/
title: string;
/**
* the index of this step, 0-based.
*/
index: number;
/**
* the Wizard's current step number, 0-based.
*/
currentStepNumber: number;
/**
* number of total steps in the wizard.
*/
totalSteps: number;
/**
* Wizard type.
*/
type: WizardType;
/**
* Click handler on completed step.
*/
onClick?: (clickedIndex: number) => void;
/**
* A tooltip giving detailed description to this step.
*/
description?: string;
} & StylingProps;
export const Step = (props: StepProps) => {
const {
title,
index,
currentStepNumber,
totalSteps,
type,
onClick,
description,
className,
style,
...rest
} = props;
const isPast = type !== 'workflow' && currentStepNumber > index;
const isActive = type !== 'workflow' && currentStepNumber === index;
const isClickable = type !== 'workflow' && isPast && !!onClick;
const onCompletedClick = () => {
if (isClickable) {
onClick?.(index);
}
};
const onKeyDown = (e: React.KeyboardEvent) => {
if (!isClickable) {
return;
}
if (e.key === 'Enter' || e.key === 'Space' || e.key === ' ') {
onCompletedClick();
}
};
const stepShape = (
<li
className={cx(
'iui-wizard-step',
{
'iui-current': isActive,
'iui-clickable': isClickable,
},
className,
)}
style={{
width: type === 'default' ? `${100 / totalSteps}%` : undefined,
...style,
}}
onClick={onCompletedClick}
onKeyDown={onKeyDown}
aria-current={isActive ? 'step' : undefined}
tabIndex={isClickable ? 0 : undefined}
{...rest}
>
<div className='iui-wizard-track-content'>
<span className='iui-wizard-circle'>
{type === 'workflow' ? title : index + 1}
</span>
</div>
{type === 'default' && (
<span className='iui-wizard-step-name'>{title}</span>
)}
</li>
);
return description ? (
<Tooltip content={description}>{stepShape}</Tooltip>
) : (
stepShape
);
};
|
<filename>sahara/plugins/mapr/util/config_file_utils.py
# Copyright (c) 2014, MapR Technologies
#
# 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.
import six
import sahara.plugins.mapr.util.func_utils as fu
import sahara.utils.files as f
import sahara.utils.xmlutils as x
def load_properties_file(path):
predicate = fu.and_predicate(lambda i: len(i) != 0,
lambda i: not i.isspace(),
lambda i: not i.startswith('#'))
mapper = fu.chain_function(lambda i: tuple(i.split('=')),
lambda i: (i[0].strip(), i[1].strip()))
lines = f.get_file_text(path).splitlines()
return dict(map(mapper, filter(predicate, lines)))
def load_xml_file(path):
kv_mapper = lambda i: (x._get_text_from_node(i, 'name'),
x._adjust_field(x._get_text_from_node(i, 'value')))
strip_mapper = lambda i: (i[0].strip(), i[1].strip())
props = x.load_xml_document(path).getElementsByTagName('property')
return dict(map(strip_mapper, map(kv_mapper, props)))
def load_raw_file(path):
return {'content': f.get_file_text(path)}
def to_properties_file_content(data):
mapper = lambda i: '%s=%s\n' % i
reducer = lambda p, c: p + c
return reduce(reducer, map(mapper, six.iteritems(data)), '')
def to_xml_file_content(data):
return x.create_hadoop_xml(data)
def to_topology_file_content(data):
mapper = lambda i: '%s %s\n' % i
reducer = lambda p, c: p + c
return reduce(reducer, map(mapper, six.iteritems(data)))
def to_raw_file_content(data, cfu=True, conv=str):
return data['content'] if cfu else conv(data)
def load_file(path, file_type):
if file_type == 'properties':
return load_properties_file(path)
elif file_type == 'xml':
return load_xml_file(path)
elif file_type == 'raw':
return load_raw_file(path)
def to_file_content(data, file_type, *args, **kargs):
if file_type == 'properties':
return to_properties_file_content(data, *args, **kargs)
elif file_type == 'xml':
return to_xml_file_content(data, *args, **kargs)
elif file_type == 'topology':
return to_topology_file_content(data, *args, **kargs)
elif file_type == 'raw':
return to_raw_file_content(data, *args, **kargs)
|
n = int(input())
lim = n
i = 1
a = 1
b = n
while lim > i:
if n % i == 0:
if a + b > n % i + i:
a = i
b = n / i
lim = n // i
i += 1
sub = a + b - 2
'''
if a == 1:
print("こっちに")
sub += 1
if b == 1:
print("きてる")
sub += 1
'''
print(int(sub))
|
Delhi's anti-graft bureau head MK Meena on Tuesday accused the AAP government of trying to abuse the process of law.
Making the submission before the Delhi High Court, Meena's counsel questioned Delhi government's power to set up an inquiry commission to probe a scam without seeking the Centre's approval.
"It is total abuse of the process of law as the power lies with the Central Government. I will demonstrate," the counsel told Justice VP Vaish.
Alleging that the Arvind Kejriwal government had a grudge against Meena and wanted him out, he also claimed that the anti corruption bureau (ACB) chief was acting in accordance with law and there has been no willful disobedience.
The ACB chief's counsel also sought six weeks to respond to a show cause notice issued to Meena seeking explanation why contempt proceedings should not be initiated against him on AAP government's claim that he had violated the court's order by removing an SHO of the anti-graft body.
Though the AAP government opposed Meena's plea for time saying it was a "delaying tactic", the court granted time to Meena to file his response within four weeks and listed the matter for hearing on October 8.
During the hearing on Tuesday, senior advocate Dayan Krishnan, appearing for Delhi government, alleged that Meena was "not working in accordance with law" and not allowing anyone else to work.
The city government has been claiming that it has the power to set up a probe commission for which the approval of the Lieutenant Governor was not required.
The court had also issued show cause notice to inspector Brij Mohan, who was appointed as the new SHO of ACB by Meena, for allegedly not lodging FIRs on complaints received by the anti-graft body between June 8 and 17.
First Published: Aug 25, 2015 19:44 IST |
/**
* Data container to access metadata and binary data of a note attachment
*
* @author Karsten Lehmann
*/
public class JNAAttachment implements Attachment {
private String m_fileName;
private Compression m_compression;
private short m_fileFlags;
private long m_fileSize;
private DominoDateTime m_fileCreated;
private DominoDateTime m_fileModified;
private JNADocument m_parentDoc;
private NotesBlockIdStruct m_itemBlockId;
private int m_rrv;
JNAAttachment(String fileName, Compression compression, short fileFlags, long fileSize,
DominoDateTime fileCreated, DominoDateTime fileModified, JNADocument parentNote,
NotesBlockIdStruct itemBlockId, int rrv) {
m_fileName = StringUtil.toString(fileName);
m_compression = Objects.requireNonNull(compression, "compression cannot be null");
m_fileFlags = fileFlags;
m_fileSize = fileSize;
m_fileCreated = Objects.requireNonNull(fileCreated, "fileCreated cannot be null");
m_fileModified = Objects.requireNonNull(fileModified, "fileModified cannot be null");
m_parentDoc = Objects.requireNonNull(parentNote, "parentNode cannot be null");
m_itemBlockId = Objects.requireNonNull(itemBlockId, "itemBlockId cannot be null");
m_rrv = rrv;
}
/**
* Returns the RRV ID that identifies the object in the database
*
* @return RRV
*/
public int getRRV() {
return m_rrv;
}
@Override
public String getFileName() {
return m_fileName;
}
@Override
public Compression getCompression() {
return m_compression;
}
/**
* Returns file flags, e.g. {@link NotesConstants#FILEFLAG_SIGN}
*
* @return flags
*/
public short getFileFlags() {
return m_fileFlags;
}
@Override
public long getFileSize() {
return m_fileSize;
}
@Override
public DominoDateTime getFileCreated() {
return m_fileCreated;
}
@Override
public DominoDateTime getFileModified() {
return m_fileModified;
}
@Override
public void readData(IDataCallback callback, int offset) {
readData(callback, offset, 1000000);
}
private void readData(IDataCallback callback, int offset, int bufferSize) {
JNADocumentAllocations docAllocations = (JNADocumentAllocations) m_parentDoc.getAdapter(APIObjectAllocations.class);
docAllocations.checkDisposed();
JNADatabaseAllocations dbAllocations = (JNADatabaseAllocations) m_parentDoc.getParent().getAdapter(APIObjectAllocations.class);
dbAllocations.checkDisposed();
if (getCompression() != Compression.NONE) {
throw new UnsupportedOperationException("This operation is only supported on attachments without compression.");
}
if (bufferSize<=0) {
throw new IllegalArgumentException("Buffer size must be a positive number");
}
AtomicLong currOffset = new AtomicLong(offset);
AtomicBoolean aborted = new AtomicBoolean();
while (!aborted.get()) {
long bytesToRead;
if ((currOffset.get()+bufferSize) < m_fileSize) {
bytesToRead = bufferSize;
}
else {
bytesToRead = m_fileSize - currOffset.get();
}
if (bytesToRead<=0) {
//we're done
break;
}
DHANDLE.ByReference rethBuffer = DHANDLE.newInstanceByReference();
short result = LockUtil.lockHandle(dbAllocations.getDBHandle(), (dbHandleByVal) -> {
return NotesCAPI.get().NSFDbReadObject(dbHandleByVal, m_rrv, (int) (currOffset.get() & 0xffffffff),
(int) (bytesToRead & 0xffffffff), rethBuffer);
});
NotesErrorUtils.checkResult(result);
LockUtil.lockHandle(rethBuffer, (hBufferByVal) -> {
Pointer ptr = Mem.OSLockObject(hBufferByVal);
try {
byte[] buffer = ptr.getByteArray(0, (int) bytesToRead);
IDataCallback.Action action = callback.read(buffer);
if (action==IDataCallback.Action.Stop) {
aborted.set(true);
}
return 0;
}
finally {
Mem.OSUnlockObject(hBufferByVal);
Mem.OSMemFree(hBufferByVal);
}
});
currOffset.addAndGet(bytesToRead);
}
}
@Override
public void readData(final IDataCallback callback) {
JNADocumentAllocations docAllocations = (JNADocumentAllocations) m_parentDoc.getAdapter(APIObjectAllocations.class);
docAllocations.checkDisposed();
JNADatabaseAllocations dbAllocations = (JNADatabaseAllocations) m_parentDoc.getParent().getAdapter(APIObjectAllocations.class);
dbAllocations.checkDisposed();
final NotesBlockIdStruct.ByValue itemBlockIdByVal = NotesBlockIdStruct.ByValue.newInstance();
itemBlockIdByVal.pool = m_itemBlockId.pool;
itemBlockIdByVal.block = m_itemBlockId.block;
final int extractFlags = 0;
final int hDecryptionCipher = 0;
final NotesCallbacks.NoteExtractCallback extractCallback;
final Throwable[] extractError = new Throwable[1];
if (PlatformUtils.isWin32()) {
extractCallback = (data, length, param) -> {
if (length==0) {
return 0;
}
try {
byte[] dataArr = data.getByteArray(0, length);
IDataCallback.Action action = callback.read(dataArr);
if (action==IDataCallback.Action.Continue) {
return 0;
}
else {
return INotesErrorConstants.ERR_NSF_INTERRUPT;
}
}
catch (Throwable t) {
extractError[0] = t;
return INotesErrorConstants.ERR_NSF_INTERRUPT;
}
};
}
else {
extractCallback = (data, length, param) -> {
if (length==0) {
return 0;
}
try {
byte[] dataArr = data.getByteArray(0, length);
IDataCallback.Action action = callback.read(dataArr);
if (action==IDataCallback.Action.Continue) {
return 0;
}
else {
return INotesErrorConstants.ERR_NSF_INTERRUPT;
}
}
catch (Throwable t) {
extractError[0] = t;
return INotesErrorConstants.ERR_NSF_INTERRUPT;
}
};
}
short result;
try {
result = AccessController.doPrivileged((PrivilegedExceptionAction<Short>) () -> LockUtil.lockHandle(docAllocations.getNoteHandle(), (noteHandleByVal) -> {
return NotesCAPI.get().NSFNoteCipherExtractWithCallback(noteHandleByVal,
itemBlockIdByVal, extractFlags, hDecryptionCipher,
extractCallback, null, 0, null);
}));
} catch (PrivilegedActionException e) {
if (e.getCause() instanceof RuntimeException) {
throw (RuntimeException) e.getCause();
} else {
throw new DominoException("Error extracting attachment", e);
}
}
if (extractError[0] != null) {
throw new DominoException("Extraction interrupted", extractError[0]);
}
if (result != INotesErrorConstants.ERR_NSF_INTERRUPT) {
NotesErrorUtils.checkResult(result);
}
}
@Override
public void deleteFromDocument() {
JNADocumentAllocations docAllocations = (JNADocumentAllocations) ((JNADocument)getParent()).getAdapter(APIObjectAllocations.class);
docAllocations.checkDisposed();
NotesBlockIdStruct.ByValue itemBlockIdByVal = NotesBlockIdStruct.ByValue.newInstance();
itemBlockIdByVal.pool = m_itemBlockId.pool;
itemBlockIdByVal.block = m_itemBlockId.block;
short result = LockUtil.lockHandle(docAllocations.getNoteHandle(), (handleByVal) -> {
return NotesCAPI.get().NSFNoteDetachFile(handleByVal, itemBlockIdByVal);
});
NotesErrorUtils.checkResult(result);
}
@Override
public Document getParent() {
return m_parentDoc;
}
@Override
public void extract(Path targetFilePath) throws IOException {
Files.deleteIfExists(targetFilePath);
IOException[] ex = new IOException[1];
try (OutputStream out = new BufferedOutputStream(Files.newOutputStream(targetFilePath, StandardOpenOption.CREATE_NEW))) {
readData((data) -> {
try {
out.write(data);
return Action.Continue;
} catch (Exception e) {
ex[0] = new IOException(MessageFormat.format("Error writing attachment {0} to {1}", getFileName(), targetFilePath), e);
return Action.Stop;
}
});
if (ex[0] != null) {
throw ex[0];
}
}
}
@Override
public InputStream getInputStream() throws IOException {
Path tmpFile = Files.createTempFile("jnxtmp_", ".tmp"); //$NON-NLS-1$ //$NON-NLS-2$
extract(tmpFile);
return new BufferedInputStream(new TempFileInputStream(tmpFile));
}
/**
* InputStream of a temporary file that automatically delete the
* file when the data is read.
*/
private class TempFileInputStream extends InputStream {
private Path tmpFile;
private InputStream inputStream;
public TempFileInputStream(Path tmpFile) throws IOException {
this.tmpFile = tmpFile;
this.inputStream = Files.newInputStream(tmpFile);
}
@Override
public int available() throws IOException {
return this.inputStream.available();
}
@Override
public synchronized void mark(int readlimit) {
this.inputStream.mark(readlimit);
}
@Override
public boolean markSupported() {
return this.inputStream.markSupported();
}
@Override
public int read(byte[] b) throws IOException {
return this.inputStream.read(b);
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
return this.inputStream.read(b, off, len);
}
@Override
public synchronized void reset() throws IOException {
this.inputStream.reset();
}
@Override
public long skip(long n) throws IOException {
return this.inputStream.skip(n);
}
@Override
public void close() throws IOException {
this.inputStream.close();
Files.deleteIfExists(this.tmpFile);
}
@Override
protected void finalize() throws Throwable {
this.inputStream.close();
Files.deleteIfExists(this.tmpFile);
}
@Override
public int read() throws IOException {
return this.inputStream.read();
}
}
} |
Advertisements of badminton equipment in Medan press, as early as 1932. Brown argues that key to the introduction of badminton to Indonesia lies in Medan, where badminton players from Pinang (e.g. Yan Eng Hoo) frequently visited for exhibition games. Before independence, Chinese is the largest ethnic group in Medan
In early 1930s, the two top badminton organizations in Jakarta ( Batavia Badminton Bond and Bataviasche Badminton League ) are both led by ethnic Chinese players.
and ) are both led by ethnic Chinese players. The winners + runners-up of a competition done in Semarang in December 1939 have ethnic Chinese names
Badminton wasn't mentioned in Sport in Indie, published in late 1930s(which listed 20 sports associations in Java, including tennis) - evidence that badminton is unlikely played by a lot of Dutch people.
published in late 1930s(which listed 20 sports associations in Java, including tennis) - evidence that badminton is unlikely played by a lot of Dutch people. The formation of the first united body to govern badminton as a sport, PERBAD (now All-Indonesian Badminton Federation, PBSI), included many ethnic Chinese in the leadership. Until 1961, the headquarters of PBSI was located at the same place as the headquarters of Sin Ming Hui, an ethnic Chinese social association.
From the beginning, badminton in Indonesia was characterized by a tradition of nondiscrimination. So you can understand why badminton here is so strong. The tradition of nondiscrimination and having particular goals to be reached are specific examples of how you can reach high levels of performance, and are reasons for the continued significance of our game.
Tan Joe Hok, 1959 All-England champion. Ferry Sonneville (Eurasian-descent Indonesian) was runner-up
3/5 of the members of Indonesia's winning Thomas Cup 1958 team (the country's first Thomas Cup win), are Chinese Indonesians. Only Eddy Yusuf was indigenous.
Men singles Rudy Hartono and Liem Swie King, both ethnic Chinese, dominated the game from 1968 to 1982 - all 15 All-England finals between 1968 to 1982 have either of them on it.
130 million Indonesians have a burning desire to see Rudy Hartono win the All-England championship 8 times. This burning desire is something which simply cannot be denied. ~ Suharso Suhandinata
provided scholarship
dormitories for non-local budding badminton players
regularly sponsored the international Indonesia Open, Djarum SuperLiga (the national lague)
pushed for badminton outreach to all parts of the country
have Rudy Hartono and Liem Swie King, who catapulted Indonesia to total badminton domination during the era of a government that discriminates against Chinese Indonesians, nor
would we have such whole-hearted support of families like Suhandinata and Hartono, whose two badminton clubs probably supplied as many as half of Indonesia's world champions in the past 5 decades.
Colin Brown from Curtin University, through this paper (), argues that a big factor in why Indonesia is so good at badminton is badminton's(most notably ethnic Chinese) throughout its history in the country. This leads into a larger pool of potential athletes (a big percentage of successful Indonesian badminton athletes are minorities) and active involvement from wealthy Chinese business families that further promote the sport.In comparison, football in Indonesia was politicized since early in its development, which prevented it to have the inclusivity and all the benefits that come from that.There was continuous tension between indigenous people and ethnic Chinese in Indonesia, dating back to the nationalist movement (pre-independence) era. Case in point: in 1918, Sarekat Islam (the first organized nationalist movement) orchestrated mass violence to ethnic Chinese in Kudus (see:). This difficult ethnic relationship continues long after independence in 1945. In 1959, the Presidential Regulation 10 banned retail services by non-indigenous people in rural areas. More anti-Chinese regulations were passed since then. In short: Chinese Indonesians were never fully assimilated / treated as Indonesians until, arguably, the past decade.It is thus remarkable that Chinese Indonesians managed to have such a major involvement with badminton from the early days. In the words of Ferry Sonneville, one of the first internationally successful Indonesian badminton player:Brown argued that part of this remarkable involvement of Chinese Indonesians in the early days of badminton is because badminton (compared to other popular sports, like soccer) wasn't as closely correlated to nationalism and its movement. Badminton wasn't a European game and the Dutch had never played a significant role in it, so beating the Dutch will have zero symbolic importance. In comparison, football was used politically by the nationalism movement to attract support for that nationalist cause ("" -). The lack of politicization of badminton leads into its more inclusive nature towards non-indigenous people.Another important step is the success of Soedirman (indigenous, first president of All-Indonesian Badminton Federation, PBSI) to form an inclusive PBSI.After the independence in 1945, President Soekarno formed PORI (Indonesian Sports Union), led by Soedirman, which were almost exclusively indigenous. So was its badminton division. Soedirman managed to merge this badminton division with PERBAD, a prominent, but predominantly Chinese, badminton organization. This must have been difficult, given the anti-Chinese sentiment among the nationalist government at the time, but was essential in assimilating ethnic Chinese badminton enthusiast. This step must have been crucial in continuing their involvement in Indonesian badminton to this day.Early successful Indonesian badminton players were predominantly Chinese:(Pictured: Rudy Hartono)These successes, especially Rudy Hartono's and Liem Swie King's, must have been a big milestone in the growing popularity of badminton in Indonesia. This was the first time Indonesia dominatedsport internationally in such a clear manner, and brought national pride like never before. The country's enthusiasm in the sport at this point was notable:As laws against ethnic Chinese became crazier under the Suharto administration, these early successes by ethnic Chinese are crucial in making things slightly easier for ethnic Chinese badminton players in Indonesia.Take Ivana Lie, one of the best female singles players in the 1980s, who couldn't travel overseas because it took 4 years for her to get an identity card and passport. Even this, she said, was only possible because she could speak directly to the President. Such an access would probably be close to impossible for Chinese descent athletes in a sport without badminton's history of success. This paves the way for the likes of Olympic gold medalists Susi Susanti, Alan Budikusuma, Candra Wijaya and Tony Gunawan.Compare this to how Suharto's discriminatory regime led to continued underrepresentation of ethnic Chinese players in Indonesia's soccer team (), despite a healthy (and successful) representation beforehand. The inclusivity in PBSI's early leadership and early public wins by ethnic Chinese players relatively shielded badminton players from the impact of this tough regime.Another direct impact of badminton's inclusivity of minority ethnic groups in Indonesia is the heavy, enthusiastic involvement of Chinese wealthy businessmen. Two of the best badminton clubs in Indonesia,and, were led by Hartono family and Suhandinata family, both ethnic Chinese families (Hartono family owned the hugely successful Djarum, successfulcigarette company, which grew into a huge business empire)These families genuinely love badminton as a sport, and have immense impact to Indonesian badminton by funding and advancing training facilities and methodologies in the country. Djarum:Case in point: world championwas discovered when playing at a badminton court opened by Budi Hartono (Djarum CEO) in 1969 for Djarum employees to play recreationally in. King's success inspired Hartono to open Djarum Kudus, the badminton club.Their contribution to the sport has been obviously more than for economical reasons. When one of the most powerful businessmen in your country is as passionate about a sport as Victor Hartono is (read), you know you have a strong supporter that would push for initiatives to actually happen.This is not to take away anything from indigenous /athletes that have also been very successful on the world stage. The point is: if the early days of badminton wasn't as inclusive and if Soedirman didn't manage to form an inclusive PBSI, we probably would not:Without those two things, even if Indonesia would probably still have been good at badminton, it's unlikely to reach the level of success and popularity that it currently enjoys today. |
/*********************************************************************/
/**
**
** E2E_CONTEXT_LogUspMsgIfSessionContext
**
** Logs a USP protobuf message structure in Protobuf debug format if
** this message is to encapsulate in a SessionContext record type.
**
** This function is used to print the USP Message before queuing it in
** the MTP, if E2E Session is used.
** - If printed after MSG_HANDLER_QueueUspRecord(), the USP Message logs
** are mixed along USP Records and difficult to read.
** - Because the USP Message is segmented into multiple USP Records,
** it cannot be logged by the MSG_HANDLER_LogMessageToSend() callback
** without reimplementing a second reassembly mechanism (i.e. memory consumption).
** - Another option would be to print all USP Messages before queuing
** in the MTP, instead of unpacking the serialized payload in MSG_HANDLER_LogMessageToSend().
** This will however change the order of logged Records/Message.
**
** \param usp - protobuf struct of the USP Message
** \param usi - Information about the USP Message to send
**
** \return None
**
**************************************************************************/
void E2E_CONTEXT_LogUspMsgIfSessionContext(Usp__Msg *usp, usp_send_item_t *usi)
{
if (E2E_CONTEXT_IsToSendThroughSessionContext(usi->curr_e2e_session))
{
char buf[MAX_ISO8601_LEN];
USP_PROTOCOL("\n");
USP_LOG_Info("%s built at time %s",
MSG_HANDLER_UspMsgTypeToString(usp->header->msg_type),
iso8601_cur_time(buf, sizeof(buf)));
PROTO_TRACE_ProtobufMessage(&usp->base);
}
} |
With all the news coming out about the Boston Red Sox signing both Hanley Ramirez and Pablo Sandoval (though the Sandoval deal hasn’t been finalized), their roster is getting jam packed, especially considering Ramirez would likely play in left field.
Having an overload of MLB caliber outfielders, the Red Sox are going to have to start dealing them for other pieces. Chace this morning proposed the Yoenis Cespedes/Hisashi Iwakuma swap. This seems like the most desirable outfielder the Sox have in the Mariners’ opinion.
But what about former St. Louis Cardinal Allen Craig?
Craig turns 31 in July and is signed for the next three years for $25.5 million with a $13 million team option (with a $1 million buyout).
His career line is .282/.337/.445 and he can play the corner outfield, first base, and DH. Yes, he is injury prone– with knee/foot problems and surgeries– but most of his injuries came when playing in the outfield. The Mariners could use his right-handed bat in the middle of the lineup, as he has a career .349/.415/.556 line with runners in scoring position.
Allen Craig’s positional versatility could be majorly valuable for the Mariners. With their recent extension for third baseman Kyle Seager, the Mariners need that big right-handed bopper– or two– to put in the lineup.
Perhaps the Mariners could work out a deal where they get BOTH Allen Craig and Yoenis Cespedes from the Red Sox, further opening up the Fenway outfield for new addition Hanley Ramirez. With such a trade, the Mariners would get two proven right-handed power bats that could play in the outfield and also DH.
What sort of package would such a trade require, though?
I think a trade that included Hisashi Iwakuma, Taijuan Walker, and a third prospect would get such a deal done. By making that move, the Mariners would invariably need to sign a mid-rotation pitcher, and there are enough of those on the market at or around $10 million a season.
If the Mariners want to pull the trigger on Nelson Cruz, though, they’d only need to trade for Allen Craig on his own. For him alone, I think the Mariners would have to send Taijuan Walker and another mid-level prospect. This would still give the Mariners two right-handed bats for the lineup while keep their second ace in Iwakuma.
With a Nelson Cruz signing and an Allen Craig trade, the Mariners lineup would look like:
Austin Jackson 8
Dustin Ackley 7
Robinson Cano 4
Nelson Cruz 9/DH
Kyle Seager 5 (with that new contract extension!)
Allen Craig DH/9
Logan Morrison 3
Mike Zunino 2
Brad Miller 6
Such a lineup would be both balanced a potent, as guys like Logan Morrison, Brad Miller and Mike Zunino are still young and able to improve significantly offensively.
What do you think about trading for Allen Craig? Would he be a feasible and valuable addition to the 2015 Mariners team? |
It has been a decade since Liliane last saw her little girl. She fled Africa in fear for her life, leaving behind everything she knew and loved in the hope of a fresh start in Japan.
Today, she scrapes a living from dead-end jobs, and what Japanese she knows has been snatched from television shows. There is little government help for people like her: free language courses are limited, social housing is hard to find, discrimination is rife.
Yet Liliane is regarded as one of the lucky ones — she was granted refugee status in Japan, a country which refuses more than 99 percent of cases.
“It has not been easy,” she tells AFP, speaking under a pseudonym.
She adds: “Here they do not pay for your studies, they do not help you to get bank loans, or give you social housing… we are left to ourselves, we have to fight alone.”
Anti-refugee sentiment is rising in Europe and the United States but in Japan those seeking haven from tyranny and war have long faced daunting legal and social gauntlets.
One of the world’s wealthiest countries, Japan accepted just 28 refugees in 2016 — one more than the previous year — out of the 8,193 applications reviewed by the Immigration Bureau.
{snip}
Assisted by the UN, Liliane was able to claim asylum on arrival in Japan stating that her life was in danger due to tribal conflict back home. It took two years for officials to accept her as a refugee, a period during which she received assistance from the Catholic Church and charities.
But she feels the status brought few benefits. She is no closer to reuniting with her child — now a teenager, her daughter has repeatedly been denied a permit to even visit.
For Liliane, further education and a stable life, seem out of reach.
She explains: “Japan is a very difficult country for foreigners. The language is really a handicap for us. You need to do absolutely everything to try to speak in Japanese but you don’t know where to find free lessons.”
“Sometimes I think refugee status has no meaning,” she sighs.
{snip}
Critics also say current government policy ignores the country’s need for immigrants as the population shrinks.
“Japan has kept a mindset of closing doors to foreigners as it is an island nation that until recently had ample population,” said Hidenori Sakanaka, a former Justice Ministry official who heads a pro-immigration think tank.
The population is set to decline to 87 million by 2060 from 127 million today.
He added that Japan must “accept more migrants, which would make society more open to multiple cultures and… to accepting more refugees”.
{snip}
Original Article
Share This |
<gh_stars>0
import { AmortizationPeriod } from './amortization';
import { MonthsPerYear } from './constants';
export type AmortizationPeriodWithMI = AmortizationPeriod & {
mortgageInsurance: number;
};
export interface ComputeMIInputs {
propertyValue: number;
mortgageInsurance: number;
upFrontMip?: number;
}
export type ComputeMI = (
inputs: ComputeMIInputs,
amortization: AmortizationPeriod[]
) => AmortizationPeriodWithMI[];
/**
* Enhances an amortization schedule with PMI payments
*/
export function computePMI(
inputs: ComputeMIInputs,
amortization: AmortizationPeriod[]
): AmortizationPeriodWithMI[] {
return amortization.map((amortizationPeriod) => {
// only include pmi if the starting balance is more than 78% of the loan
// lenders are required to remove the pmi after you have 22% equity.
return {
...amortizationPeriod,
mortgageInsurance:
(amortizationPeriod.balanceAtEndOfMonth + amortizationPeriod.principal) /
inputs.propertyValue >
0.78
? inputs.mortgageInsurance
: 0
};
});
}
/**
* Enhances an amortization schedule with FHA MIP payments
*/
export function computeFHAMIP(
inputs: ComputeMIInputs,
amortization: AmortizationPeriod[]
): AmortizationPeriodWithMI[] {
const loanValue =
amortization[0].balanceAtEndOfMonth + amortization[0].principal - (inputs.upFrontMip || 0);
return loanValue / inputs.propertyValue > 0.9
? amortization.map((period) => ({
...period,
// more than 90% LTV you pay the mortgage insurance
// every month
mortgageInsurance: inputs.mortgageInsurance
}))
: amortization.map((period, index) => ({
...period,
// Must pay mortgage insurance for 11 years.
mortgageInsurance: index + 1 > MonthsPerYear * 11 ? 0 : inputs.mortgageInsurance
}));
}
|
package com.eatthepath.idobfuscator;
public class XorLongTransformerTest extends LongTransformerTest {
@Override
public LongTransformer[] getTransformers() {
final long[] masks = new long[] { 0, 1, -7, 77, Long.MAX_VALUE, Long.MIN_VALUE };
final LongTransformer[] transformers = new LongTransformer[masks.length];
for (int i = 0; i < masks.length; i++) {
transformers[i] = new XorLongTransformer(masks[i]);
}
return transformers;
}
}
|
def base64_to_tif(base64img, output_file_path=""):
decoded_tif = base64.b64decode(base64img)
tif_bytes = io.BytesIO(decoded_tif)
image = Image.open(tif_bytes)
if output_file_path != "":
image.save(output_file_path, format='TIFF')
return decoded_tif |
<reponame>Sirherobrine23/Dir819gpl_code
/*
File: enroll-scep.h
Description:
Cisco Simple Certificate Enrollment Protocol (SCEP)
exported (and private) symbols and definitions.
Copyright:
Copyright (c) 2002, 2003 SFNT Finland Oy.
All rights reserved
*/
#include "sshincludes.h"
/* Function prototypes for client side. */
SshPkiStatus ssh_pki_scep_session_start(SshPkiSession session);
SshPkiStatus ssh_pki_scep_session_confirm(SshPkiSession session);
Boolean ssh_pki_scep_session_linearize(SshPkiSession session);
Boolean ssh_pki_scep_session_delinarize(SshPkiSession session);
void ssh_pki_scep_session_finish(SshPkiSession session);
/* eof */
|
It was quiet in the dank basement in northwest Caracas, where dozens of young men and women sat on the floor and assembled their weapons. They poured asphalt, gasoline and paint into beer and pop bottles, tying knots in strips of fabric to fashion wicks.
Molotov cocktails are cheap and easy to make. Whether they're doing the job is at the core of a bitter debate in Venezuela. After months of relentless demonstrations against President Nicolas Maduro, many militants are frustrated. The crew in the basement talked about it in hushed voices — they didn't want anyone in the middle-class neighborhood to find them out. It was clear, though, that many had reached their limit.
The security forces they're up against, the riot-helmeted troops shooting tear-gas canisters and water cannon and bullets? "They all deserve to die," one of the bomb makers said flatly, dripping petrol into a jar.
The call to arms coming from some in the resistance may be the initial stirrings of the kind of urban guerrilla movement the country hasn't seen in half a century. It's too early to tell if they'll actually follow through on their threats, but the bold talk is a troubling sign for mainstream opposition leaders who have issued instructions — pleas, recently — for peaceful rallies and marches.
Those calls increasingly fall on deaf ears. Masked activists hurl their homemade bombs, rocks, jars filled with feces, anything they can get their hands on. They've stormed office buildings, shattered store windows and blocked roads.
"We do not know exactly how to control them, and we are scared that they can get out of hand and damage our fight," said National Assembly Deputy Angel Alvarado, a longtime foe of Maduro and his predecessor and mentor, Hugo Chavez. "These radical boys are a danger."
A young man on a street corner in Caracas, his face covered by a white bandanna, dismissed that as the obsolete opinion of the old guard. His view? "We are tired of being killed," he said as crowds surged around him, agitators suited up in hardhats and bicycle helmets and swimming goggles and gas masks, some carrying shields made of old skateboards as protection.
"We are willing to go out with guns, to face them as equals," he said, declining to give his name, describing himself only as an anti-Maduro fighter from a middle-class family. "The protest must evolve."
More than 100 people have died since daily demonstrations began in April. Hundreds of thousands sometimes pour into the streets in Caracas and other cities, railing against what they consider an authoritarian regime. Disgust with Maduro has swept into every class, uniting rich and poor as his leftist government plunged Venezuela into an unprecedented economic collapse. In a country with the world's largest crude-oil reserves, there are critical shortages of food, medicine and cash.
The opposition momentum has been building since Maduro unveiled plans to rewrite the country's constitution, calling a special National Constituent Assembly election for July 30. The president said in a statement that those who want to disrupt the vote or not participate are "hurting the right for peace, because what we are deciding here next week is between peace or war, violence or the constituent assembly."
Outraged Venezuelans brought the capital to a virtual standstill last week with marches. More than 7.5 million cast votes in an unofficial plebiscite against the president and his assembly plan, denounced as a ploy to consolidate power. The U.S. is weighing sanctions. Maduro in a television appearance on Sunday was unyielding. "The imperial right wing believes it can give orders to Venezuela," he said. "The only ones who give orders here are the people."
Maduro's defiant intransigence in the face of widespread opposition is proof, according to the radicals, that they need to move on from Molotov cocktails, from torching the occasional government vehicle or setting trash bins on fire.
The view from the more conservative in the anti-Maduro coalition is that they have already gone too far. "There is an element of anarchy," said Ramon Muchacho, mayor of the Chacao district of Caracas, which is ground zero for protests in the capital. "And there are groups of people who take advantage of the situation.''
Like the looters who wear masks when they ransack shops. They're criminals exploiting the chaos on the streets, said Fernando Fernandez, who owns a liquor store in Caracas. A dozen of them broke in on a recent Friday and made away with a trove of booze. "This is the first time anything like this has ever happened," he said. "They weren't the resistance, they were thugs."
That's one of the many dangers cited in arguments against stepping up the fury in the oust-Maduro campaign: that violence condoned in the name of righteous political opposition is difficult to direct.
It may also be just what pro-Maduro forces want, "so they can justify more attacks and deaths," said Rafaella Requesens, 25, a leader in the Venezuelan Student Movement. "I call on all these kids who want to escalate the protest and turn it into a violent one to think twice. We cannot play their game."
The young man in the white bandanna in Caracas said the time for restraint has passed: The fatalities are mounting, averaging one a day since the protests began, and Maduro is still president.
"If they shoot us with firearms? We have to shoot them, too."
Bloomberg's Andrew Rosati contributed. |
<filename>pkg/seek/rlimit.go
package seek
import "syscall"
func getRlimit(percent uint) uint64 {
var rlimit syscall.Rlimit
err := syscall.Getrlimit(syscall.RLIMIT_NOFILE, &rlimit)
if err != nil {
return 768
}
return uint64(float64(rlimit.Cur) * float64(percent) / 100)
}
|
// Copyright 2021 VMware, Inc.
// SPDX-License-Identifier: Apache License 2.0
package models
// This file is auto-generated.
// VirtualserviceFaults virtualservice faults
// swagger:model VirtualserviceFaults
type VirtualserviceFaults struct {
// Enable debug faults. Field introduced in 20.1.6.
DebugFaults *bool `json:"debug_faults,omitempty"`
// Enable pool server faults. Field introduced in 20.1.6.
PoolServerFaults *bool `json:"pool_server_faults,omitempty"`
// Enable VS scaleout and scalein faults. Field introduced in 20.1.6.
ScaleoutFaults *bool `json:"scaleout_faults,omitempty"`
// Enable shared vip faults. Field introduced in 20.1.6.
SharedVipFaults *bool `json:"shared_vip_faults,omitempty"`
// Enable SSL certificate expiry faults. Field introduced in 20.1.6.
SslCertExpiryFaults *bool `json:"ssl_cert_expiry_faults,omitempty"`
// Enable SSL certificate status faults. Field introduced in 20.1.6.
SslCertStatusFaults *bool `json:"ssl_cert_status_faults,omitempty"`
}
|
// Copyright 1998-2019 Epic Games, Inc. All Rights Reserved.
/*===========================================================================
Generated code exported from UnrealHeaderTool.
DO NOT modify this manually! Edit the corresponding .h files instead!
===========================================================================*/
#include "UObject/GeneratedCppIncludes.h"
#include "VRExpansionPlugin/Public/Grippables/GrippableSkeletalMeshActor.h"
#ifdef _MSC_VER
#pragma warning (push)
#pragma warning (disable : 4883)
#endif
PRAGMA_DISABLE_DEPRECATION_WARNINGS
void EmptyLinkFunctionForGeneratedCodeGrippableSkeletalMeshActor() {}
// Cross Module References
VREXPANSIONPLUGIN_API UClass* Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_NoRegister();
VREXPANSIONPLUGIN_API UClass* Z_Construct_UClass_UOptionalRepSkeletalMeshComponent();
ENGINE_API UClass* Z_Construct_UClass_USkeletalMeshComponent();
UPackage* Z_Construct_UPackage__Script_VRExpansionPlugin();
VREXPANSIONPLUGIN_API UClass* Z_Construct_UClass_AGrippableSkeletalMeshActor_NoRegister();
VREXPANSIONPLUGIN_API UClass* Z_Construct_UClass_AGrippableSkeletalMeshActor();
ENGINE_API UClass* Z_Construct_UClass_ASkeletalMeshActor();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings();
VREXPANSIONPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FBPAdvGripSettings();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_CeaseReplicationBlocking();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange();
VREXPANSIONPLUGIN_API UClass* Z_Construct_UClass_UGripMotionControllerComponent_NoRegister();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FTransform();
COREUOBJECT_API UScriptStruct* Z_Construct_UScriptStruct_FVector();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts();
VREXPANSIONPLUGIN_API UClass* Z_Construct_UClass_UVRGripScriptBase_NoRegister();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType();
VREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_VRExpansionPlugin_EGripCollisionType();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting();
VREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_VRExpansionPlugin_EGripLateUpdateSettings();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType();
VREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_VRExpansionPlugin_EGripMovementReplicationSettings();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld();
VREXPANSIONPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FBPGripPair();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip();
VREXPANSIONPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FBPActorGripInformation();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndSecondaryUsed();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndUsed();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput();
ENGINE_API UEnum* Z_Construct_UEnum_Engine_EInputEvent();
INPUTCORE_API UScriptStruct* Z_Construct_UScriptStruct_FKey();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip();
ENGINE_API UClass* Z_Construct_UClass_USceneComponent_NoRegister();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryUsed();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnUsed();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing();
VREXPANSIONPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FTransform_NetQuantize();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType();
VREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_VRExpansionPlugin_ESecondaryGripType();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication();
VREXPANSIONPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FRepMovementVR();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior();
VREXPANSIONPLUGIN_API UEnum* Z_Construct_UEnum_VRExpansionPlugin_EGripInterfaceTeleportBehavior();
VREXPANSIONPLUGIN_API UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip();
VREXPANSIONPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FBPInterfaceProperties();
GAMEPLAYTAGS_API UScriptStruct* Z_Construct_UScriptStruct_FGameplayTagContainer();
VREXPANSIONPLUGIN_API UScriptStruct* Z_Construct_UScriptStruct_FVRClientAuthReplicationData();
VREXPANSIONPLUGIN_API UClass* Z_Construct_UClass_UVRGripInterface_NoRegister();
GAMEPLAYTAGS_API UClass* Z_Construct_UClass_UGameplayTagAssetInterface_NoRegister();
// End Cross Module References
void UOptionalRepSkeletalMeshComponent::StaticRegisterNativesUOptionalRepSkeletalMeshComponent()
{
}
UClass* Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_NoRegister()
{
return UOptionalRepSkeletalMeshComponent::StaticClass();
}
struct Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics
{
static UObject* (*const DependentSingletons[])();
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bReplicateMovement_MetaData[];
#endif
static void NewProp_bReplicateMovement_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bReplicateMovement;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
static const UE4CodeGen_Private::FClassParams ClassParams;
};
UObject* (*const Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::DependentSingletons[])() = {
(UObject* (*)())Z_Construct_UClass_USkeletalMeshComponent,
(UObject* (*)())Z_Construct_UPackage__Script_VRExpansionPlugin,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::Class_MetaDataParams[] = {
{ "BlueprintSpawnableComponent", "" },
{ "BlueprintType", "true" },
{ "ClassGroupNames", "VRExpansionPlugin" },
{ "Comment", "/**\n* A component specifically for being able to turn off movement replication in the component at will\n* Has the upside of also being a blueprintable base since UE4 doesn't allow that with std ones\n*/" },
{ "HideCategories", "Object Object Mobility Trigger" },
{ "IncludePath", "Grippables/GrippableSkeletalMeshActor.h" },
{ "IsBlueprintBase", "true" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ObjectInitializerConstructorDeclared", "" },
{ "ToolTip", "A component specifically for being able to turn off movement replication in the component at will\nHas the upside of also being a blueprintable base since UE4 doesn't allow that with std ones" },
};
#endif
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::NewProp_bReplicateMovement_MetaData[] = {
{ "Category", "Component Replication" },
{ "Comment", "// Overrides the default of : true and allows for controlling it like in an actor, should be default of off normally with grippable components\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Overrides the default of : true and allows for controlling it like in an actor, should be default of off normally with grippable components" },
};
#endif
void Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::NewProp_bReplicateMovement_SetBit(void* Obj)
{
((UOptionalRepSkeletalMeshComponent*)Obj)->bReplicateMovement = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::NewProp_bReplicateMovement = { "bReplicateMovement", nullptr, (EPropertyFlags)0x0010000000000025, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(UOptionalRepSkeletalMeshComponent), &Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::NewProp_bReplicateMovement_SetBit, METADATA_PARAMS(Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::NewProp_bReplicateMovement_MetaData, ARRAY_COUNT(Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::NewProp_bReplicateMovement_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::NewProp_bReplicateMovement,
};
const FCppClassTypeInfoStatic Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::StaticCppClassTypeInfo = {
TCppClassTypeTraits<UOptionalRepSkeletalMeshComponent>::IsAbstract,
};
const UE4CodeGen_Private::FClassParams Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::ClassParams = {
&UOptionalRepSkeletalMeshComponent::StaticClass,
"Engine",
&StaticCppClassTypeInfo,
DependentSingletons,
nullptr,
Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::PropPointers,
nullptr,
ARRAY_COUNT(DependentSingletons),
0,
ARRAY_COUNT(Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::PropPointers),
0,
0x00B010A4u,
METADATA_PARAMS(Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::Class_MetaDataParams, ARRAY_COUNT(Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::Class_MetaDataParams))
};
UClass* Z_Construct_UClass_UOptionalRepSkeletalMeshComponent()
{
static UClass* OuterClass = nullptr;
if (!OuterClass)
{
UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_UOptionalRepSkeletalMeshComponent_Statics::ClassParams);
}
return OuterClass;
}
IMPLEMENT_CLASS(UOptionalRepSkeletalMeshComponent, 1074976268);
template<> VREXPANSIONPLUGIN_API UClass* StaticClass<UOptionalRepSkeletalMeshComponent>()
{
return UOptionalRepSkeletalMeshComponent::StaticClass();
}
static FCompiledInDefer Z_CompiledInDefer_UClass_UOptionalRepSkeletalMeshComponent(Z_Construct_UClass_UOptionalRepSkeletalMeshComponent, &UOptionalRepSkeletalMeshComponent::StaticClass, TEXT("/Script/VRExpansionPlugin"), TEXT("UOptionalRepSkeletalMeshComponent"), false, nullptr, nullptr, nullptr);
DEFINE_VTABLE_PTR_HELPER_CTOR(UOptionalRepSkeletalMeshComponent);
static FName NAME_AGrippableSkeletalMeshActor_AdvancedGripSettings = FName(TEXT("AdvancedGripSettings"));
FBPAdvGripSettings AGrippableSkeletalMeshActor::AdvancedGripSettings()
{
GrippableSkeletalMeshActor_eventAdvancedGripSettings_Parms Parms;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_AdvancedGripSettings),&Parms);
return Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_AllowsMultipleGrips = FName(TEXT("AllowsMultipleGrips"));
bool AGrippableSkeletalMeshActor::AllowsMultipleGrips()
{
GrippableSkeletalMeshActor_eventAllowsMultipleGrips_Parms Parms;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_AllowsMultipleGrips),&Parms);
return !!Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_ClosestGripSlotInRange = FName(TEXT("ClosestGripSlotInRange"));
void AGrippableSkeletalMeshActor::ClosestGripSlotInRange(FVector WorldLocation, bool bSecondarySlot, bool& bHadSlotInRange, FTransform& SlotWorldTransform, UGripMotionControllerComponent* CallingController, FName OverridePrefix)
{
GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms Parms;
Parms.WorldLocation=WorldLocation;
Parms.bSecondarySlot=bSecondarySlot ? true : false;
Parms.bHadSlotInRange=bHadSlotInRange ? true : false;
Parms.SlotWorldTransform=SlotWorldTransform;
Parms.CallingController=CallingController;
Parms.OverridePrefix=OverridePrefix;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_ClosestGripSlotInRange),&Parms);
bHadSlotInRange=Parms.bHadSlotInRange;
SlotWorldTransform=Parms.SlotWorldTransform;
}
static FName NAME_AGrippableSkeletalMeshActor_DenyGripping = FName(TEXT("DenyGripping"));
bool AGrippableSkeletalMeshActor::DenyGripping()
{
GrippableSkeletalMeshActor_eventDenyGripping_Parms Parms;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_DenyGripping),&Parms);
return !!Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_GetGripScripts = FName(TEXT("GetGripScripts"));
bool AGrippableSkeletalMeshActor::GetGripScripts(TArray<UVRGripScriptBase*>& ArrayReference)
{
GrippableSkeletalMeshActor_eventGetGripScripts_Parms Parms;
Parms.ArrayReference=ArrayReference;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_GetGripScripts),&Parms);
ArrayReference=Parms.ArrayReference;
return !!Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping = FName(TEXT("GetGripStiffnessAndDamping"));
void AGrippableSkeletalMeshActor::GetGripStiffnessAndDamping(float& GripStiffnessOut, float& GripDampingOut)
{
GrippableSkeletalMeshActor_eventGetGripStiffnessAndDamping_Parms Parms;
Parms.GripStiffnessOut=GripStiffnessOut;
Parms.GripDampingOut=GripDampingOut;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping),&Parms);
GripStiffnessOut=Parms.GripStiffnessOut;
GripDampingOut=Parms.GripDampingOut;
}
static FName NAME_AGrippableSkeletalMeshActor_GetPrimaryGripType = FName(TEXT("GetPrimaryGripType"));
EGripCollisionType AGrippableSkeletalMeshActor::GetPrimaryGripType(bool bIsSlot)
{
GrippableSkeletalMeshActor_eventGetPrimaryGripType_Parms Parms;
Parms.bIsSlot=bIsSlot ? true : false;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_GetPrimaryGripType),&Parms);
return Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_GripBreakDistance = FName(TEXT("GripBreakDistance"));
float AGrippableSkeletalMeshActor::GripBreakDistance()
{
GrippableSkeletalMeshActor_eventGripBreakDistance_Parms Parms;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_GripBreakDistance),&Parms);
return Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_GripLateUpdateSetting = FName(TEXT("GripLateUpdateSetting"));
EGripLateUpdateSettings AGrippableSkeletalMeshActor::GripLateUpdateSetting()
{
GrippableSkeletalMeshActor_eventGripLateUpdateSetting_Parms Parms;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_GripLateUpdateSetting),&Parms);
return Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_GripMovementReplicationType = FName(TEXT("GripMovementReplicationType"));
EGripMovementReplicationSettings AGrippableSkeletalMeshActor::GripMovementReplicationType()
{
GrippableSkeletalMeshActor_eventGripMovementReplicationType_Parms Parms;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_GripMovementReplicationType),&Parms);
return Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_IsHeld = FName(TEXT("IsHeld"));
void AGrippableSkeletalMeshActor::IsHeld(TArray<FBPGripPair>& HoldingControllers, bool& bIsHeld)
{
GrippableSkeletalMeshActor_eventIsHeld_Parms Parms;
Parms.HoldingControllers=HoldingControllers;
Parms.bIsHeld=bIsHeld ? true : false;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_IsHeld),&Parms);
HoldingControllers=Parms.HoldingControllers;
bIsHeld=Parms.bIsHeld;
}
static FName NAME_AGrippableSkeletalMeshActor_OnChildGrip = FName(TEXT("OnChildGrip"));
void AGrippableSkeletalMeshActor::OnChildGrip(UGripMotionControllerComponent* GrippingController, FBPActorGripInformation const& GripInformation)
{
GrippableSkeletalMeshActor_eventOnChildGrip_Parms Parms;
Parms.GrippingController=GrippingController;
Parms.GripInformation=GripInformation;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnChildGrip),&Parms);
}
static FName NAME_AGrippableSkeletalMeshActor_OnChildGripRelease = FName(TEXT("OnChildGripRelease"));
void AGrippableSkeletalMeshActor::OnChildGripRelease(UGripMotionControllerComponent* ReleasingController, FBPActorGripInformation const& GripInformation, bool bWasSocketed)
{
GrippableSkeletalMeshActor_eventOnChildGripRelease_Parms Parms;
Parms.ReleasingController=ReleasingController;
Parms.GripInformation=GripInformation;
Parms.bWasSocketed=bWasSocketed ? true : false;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnChildGripRelease),&Parms);
}
static FName NAME_AGrippableSkeletalMeshActor_OnEndSecondaryUsed = FName(TEXT("OnEndSecondaryUsed"));
void AGrippableSkeletalMeshActor::OnEndSecondaryUsed()
{
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnEndSecondaryUsed),NULL);
}
static FName NAME_AGrippableSkeletalMeshActor_OnEndUsed = FName(TEXT("OnEndUsed"));
void AGrippableSkeletalMeshActor::OnEndUsed()
{
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnEndUsed),NULL);
}
static FName NAME_AGrippableSkeletalMeshActor_OnGrip = FName(TEXT("OnGrip"));
void AGrippableSkeletalMeshActor::OnGrip(UGripMotionControllerComponent* GrippingController, FBPActorGripInformation const& GripInformation)
{
GrippableSkeletalMeshActor_eventOnGrip_Parms Parms;
Parms.GrippingController=GrippingController;
Parms.GripInformation=GripInformation;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnGrip),&Parms);
}
static FName NAME_AGrippableSkeletalMeshActor_OnGripRelease = FName(TEXT("OnGripRelease"));
void AGrippableSkeletalMeshActor::OnGripRelease(UGripMotionControllerComponent* ReleasingController, FBPActorGripInformation const& GripInformation, bool bWasSocketed)
{
GrippableSkeletalMeshActor_eventOnGripRelease_Parms Parms;
Parms.ReleasingController=ReleasingController;
Parms.GripInformation=GripInformation;
Parms.bWasSocketed=bWasSocketed ? true : false;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnGripRelease),&Parms);
}
static FName NAME_AGrippableSkeletalMeshActor_OnInput = FName(TEXT("OnInput"));
void AGrippableSkeletalMeshActor::OnInput(FKey Key, EInputEvent KeyEvent)
{
GrippableSkeletalMeshActor_eventOnInput_Parms Parms;
Parms.Key=Key;
Parms.KeyEvent=KeyEvent;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnInput),&Parms);
}
static FName NAME_AGrippableSkeletalMeshActor_OnSecondaryGrip = FName(TEXT("OnSecondaryGrip"));
void AGrippableSkeletalMeshActor::OnSecondaryGrip(USceneComponent* SecondaryGripComponent, FBPActorGripInformation const& GripInformation)
{
GrippableSkeletalMeshActor_eventOnSecondaryGrip_Parms Parms;
Parms.SecondaryGripComponent=SecondaryGripComponent;
Parms.GripInformation=GripInformation;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnSecondaryGrip),&Parms);
}
static FName NAME_AGrippableSkeletalMeshActor_OnSecondaryGripRelease = FName(TEXT("OnSecondaryGripRelease"));
void AGrippableSkeletalMeshActor::OnSecondaryGripRelease(USceneComponent* ReleasingSecondaryGripComponent, FBPActorGripInformation const& GripInformation)
{
GrippableSkeletalMeshActor_eventOnSecondaryGripRelease_Parms Parms;
Parms.ReleasingSecondaryGripComponent=ReleasingSecondaryGripComponent;
Parms.GripInformation=GripInformation;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnSecondaryGripRelease),&Parms);
}
static FName NAME_AGrippableSkeletalMeshActor_OnSecondaryUsed = FName(TEXT("OnSecondaryUsed"));
void AGrippableSkeletalMeshActor::OnSecondaryUsed()
{
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnSecondaryUsed),NULL);
}
static FName NAME_AGrippableSkeletalMeshActor_OnUsed = FName(TEXT("OnUsed"));
void AGrippableSkeletalMeshActor::OnUsed()
{
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_OnUsed),NULL);
}
static FName NAME_AGrippableSkeletalMeshActor_RequestsSocketing = FName(TEXT("RequestsSocketing"));
bool AGrippableSkeletalMeshActor::RequestsSocketing(USceneComponent*& ParentToSocketTo, FName& OptionalSocketName, FTransform_NetQuantize& RelativeTransform)
{
GrippableSkeletalMeshActor_eventRequestsSocketing_Parms Parms;
Parms.ParentToSocketTo=ParentToSocketTo;
Parms.OptionalSocketName=OptionalSocketName;
Parms.RelativeTransform=RelativeTransform;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_RequestsSocketing),&Parms);
ParentToSocketTo=Parms.ParentToSocketTo;
OptionalSocketName=Parms.OptionalSocketName;
RelativeTransform=Parms.RelativeTransform;
return !!Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_SecondaryGripType = FName(TEXT("SecondaryGripType"));
ESecondaryGripType AGrippableSkeletalMeshActor::SecondaryGripType()
{
GrippableSkeletalMeshActor_eventSecondaryGripType_Parms Parms;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_SecondaryGripType),&Parms);
return Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication = FName(TEXT("Server_GetClientAuthReplication"));
void AGrippableSkeletalMeshActor::Server_GetClientAuthReplication(FRepMovementVR const& newMovement)
{
GrippableSkeletalMeshActor_eventServer_GetClientAuthReplication_Parms Parms;
Parms.newMovement=newMovement;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication),&Parms);
}
static FName NAME_AGrippableSkeletalMeshActor_SetHeld = FName(TEXT("SetHeld"));
void AGrippableSkeletalMeshActor::SetHeld(UGripMotionControllerComponent* HoldingController, uint8 GripID, bool bIsHeld)
{
GrippableSkeletalMeshActor_eventSetHeld_Parms Parms;
Parms.HoldingController=HoldingController;
Parms.GripID=GripID;
Parms.bIsHeld=bIsHeld ? true : false;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_SetHeld),&Parms);
}
static FName NAME_AGrippableSkeletalMeshActor_SimulateOnDrop = FName(TEXT("SimulateOnDrop"));
bool AGrippableSkeletalMeshActor::SimulateOnDrop()
{
GrippableSkeletalMeshActor_eventSimulateOnDrop_Parms Parms;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_SimulateOnDrop),&Parms);
return !!Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_TeleportBehavior = FName(TEXT("TeleportBehavior"));
EGripInterfaceTeleportBehavior AGrippableSkeletalMeshActor::TeleportBehavior()
{
GrippableSkeletalMeshActor_eventTeleportBehavior_Parms Parms;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_TeleportBehavior),&Parms);
return Parms.ReturnValue;
}
static FName NAME_AGrippableSkeletalMeshActor_TickGrip = FName(TEXT("TickGrip"));
void AGrippableSkeletalMeshActor::TickGrip(UGripMotionControllerComponent* GrippingController, FBPActorGripInformation const& GripInformation, float DeltaTime)
{
GrippableSkeletalMeshActor_eventTickGrip_Parms Parms;
Parms.GrippingController=GrippingController;
Parms.GripInformation=GripInformation;
Parms.DeltaTime=DeltaTime;
ProcessEvent(FindFunctionChecked(NAME_AGrippableSkeletalMeshActor_TickGrip),&Parms);
}
void AGrippableSkeletalMeshActor::StaticRegisterNativesAGrippableSkeletalMeshActor()
{
UClass* Class = AGrippableSkeletalMeshActor::StaticClass();
static const FNameNativePtrPair Funcs[] = {
{ "AddToClientReplicationBucket", &AGrippableSkeletalMeshActor::execAddToClientReplicationBucket },
{ "AdvancedGripSettings", &AGrippableSkeletalMeshActor::execAdvancedGripSettings },
{ "AllowsMultipleGrips", &AGrippableSkeletalMeshActor::execAllowsMultipleGrips },
{ "CeaseReplicationBlocking", &AGrippableSkeletalMeshActor::execCeaseReplicationBlocking },
{ "ClosestGripSlotInRange", &AGrippableSkeletalMeshActor::execClosestGripSlotInRange },
{ "DenyGripping", &AGrippableSkeletalMeshActor::execDenyGripping },
{ "GetGripScripts", &AGrippableSkeletalMeshActor::execGetGripScripts },
{ "GetGripStiffnessAndDamping", &AGrippableSkeletalMeshActor::execGetGripStiffnessAndDamping },
{ "GetPrimaryGripType", &AGrippableSkeletalMeshActor::execGetPrimaryGripType },
{ "GripBreakDistance", &AGrippableSkeletalMeshActor::execGripBreakDistance },
{ "GripLateUpdateSetting", &AGrippableSkeletalMeshActor::execGripLateUpdateSetting },
{ "GripMovementReplicationType", &AGrippableSkeletalMeshActor::execGripMovementReplicationType },
{ "IsHeld", &AGrippableSkeletalMeshActor::execIsHeld },
{ "OnChildGrip", &AGrippableSkeletalMeshActor::execOnChildGrip },
{ "OnChildGripRelease", &AGrippableSkeletalMeshActor::execOnChildGripRelease },
{ "OnEndSecondaryUsed", &AGrippableSkeletalMeshActor::execOnEndSecondaryUsed },
{ "OnEndUsed", &AGrippableSkeletalMeshActor::execOnEndUsed },
{ "OnGrip", &AGrippableSkeletalMeshActor::execOnGrip },
{ "OnGripRelease", &AGrippableSkeletalMeshActor::execOnGripRelease },
{ "OnInput", &AGrippableSkeletalMeshActor::execOnInput },
{ "OnSecondaryGrip", &AGrippableSkeletalMeshActor::execOnSecondaryGrip },
{ "OnSecondaryGripRelease", &AGrippableSkeletalMeshActor::execOnSecondaryGripRelease },
{ "OnSecondaryUsed", &AGrippableSkeletalMeshActor::execOnSecondaryUsed },
{ "OnUsed", &AGrippableSkeletalMeshActor::execOnUsed },
{ "PollReplicationEvent", &AGrippableSkeletalMeshActor::execPollReplicationEvent },
{ "RemoveFromClientReplicationBucket", &AGrippableSkeletalMeshActor::execRemoveFromClientReplicationBucket },
{ "RequestsSocketing", &AGrippableSkeletalMeshActor::execRequestsSocketing },
{ "SecondaryGripType", &AGrippableSkeletalMeshActor::execSecondaryGripType },
{ "Server_GetClientAuthReplication", &AGrippableSkeletalMeshActor::execServer_GetClientAuthReplication },
{ "SetDenyGripping", &AGrippableSkeletalMeshActor::execSetDenyGripping },
{ "SetHeld", &AGrippableSkeletalMeshActor::execSetHeld },
{ "SimulateOnDrop", &AGrippableSkeletalMeshActor::execSimulateOnDrop },
{ "TeleportBehavior", &AGrippableSkeletalMeshActor::execTeleportBehavior },
{ "TickGrip", &AGrippableSkeletalMeshActor::execTickGrip },
};
FNativeFunctionRegistrar::RegisterFunctions(Class, Funcs, ARRAY_COUNT(Funcs));
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics
{
struct GrippableSkeletalMeshActor_eventAddToClientReplicationBucket_Parms
{
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventAddToClientReplicationBucket_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventAddToClientReplicationBucket_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::Function_MetaDataParams[] = {
{ "Category", "Networking" },
{ "Comment", "// Add this to client side physics replication (until coming to rest or timeout period is hit)\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Add this to client side physics replication (until coming to rest or timeout period is hit)" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "AddToClientReplicationBucket", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventAddToClientReplicationBucket_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics
{
static const UE4CodeGen_Private::FStructPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventAdvancedGripSettings_Parms, ReturnValue), Z_Construct_UScriptStruct_FBPAdvGripSettings, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Get the advanced physics settings for this grip\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Get the advanced physics settings for this grip" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "AdvancedGripSettings", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventAdvancedGripSettings_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics
{
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventAllowsMultipleGrips_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventAllowsMultipleGrips_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Check if an object allows multiple grips at one time\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Check if an object allows multiple grips at one time" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "AllowsMultipleGrips", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventAllowsMultipleGrips_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_CeaseReplicationBlocking_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_CeaseReplicationBlocking_Statics::Function_MetaDataParams[] = {
{ "Category", "Networking" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_CeaseReplicationBlocking_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "CeaseReplicationBlocking", nullptr, nullptr, 0, nullptr, 0, RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_CeaseReplicationBlocking_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_CeaseReplicationBlocking_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_CeaseReplicationBlocking()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_CeaseReplicationBlocking_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics
{
static const UE4CodeGen_Private::FNamePropertyParams NewProp_OverridePrefix;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_CallingController_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_CallingController;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_SlotWorldTransform;
static void NewProp_bHadSlotInRange_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bHadSlotInRange;
static void NewProp_bSecondarySlot_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bSecondarySlot;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_WorldLocation;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FNamePropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_OverridePrefix = { "OverridePrefix", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms, OverridePrefix), METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_CallingController_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_CallingController = { "CallingController", nullptr, (EPropertyFlags)0x0010000000080080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms, CallingController), Z_Construct_UClass_UGripMotionControllerComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_CallingController_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_CallingController_MetaData)) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_SlotWorldTransform = { "SlotWorldTransform", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms, SlotWorldTransform), Z_Construct_UScriptStruct_FTransform, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_bHadSlotInRange_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms*)Obj)->bHadSlotInRange = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_bHadSlotInRange = { "bHadSlotInRange", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_bHadSlotInRange_SetBit, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_bSecondarySlot_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms*)Obj)->bSecondarySlot = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_bSecondarySlot = { "bSecondarySlot", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_bSecondarySlot_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_WorldLocation = { "WorldLocation", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms, WorldLocation), Z_Construct_UScriptStruct_FVector, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_OverridePrefix,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_CallingController,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_SlotWorldTransform,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_bHadSlotInRange,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_bSecondarySlot,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::NewProp_WorldLocation,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Get closest primary slot in range\n" },
{ "CPP_Default_CallingController", "None" },
{ "CPP_Default_OverridePrefix", "None" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Get closest primary slot in range" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "ClosestGripSlotInRange", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventClosestGripSlotInRange_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0CC20C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics
{
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventDenyGripping_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventDenyGripping_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Set up as deny instead of allow so that default allows for gripping\n" },
{ "DisplayName", "IsDenyingGrips" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Set up as deny instead of allow so that default allows for gripping" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "DenyGripping", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventDenyGripping_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics
{
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ArrayReference_MetaData[];
#endif
static const UE4CodeGen_Private::FArrayPropertyParams NewProp_ArrayReference;
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_ArrayReference_Inner;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventGetGripScripts_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventGetGripScripts_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ArrayReference_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ArrayReference = { "ArrayReference", nullptr, (EPropertyFlags)0x0010008000000180, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventGetGripScripts_Parms, ArrayReference), METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ArrayReference_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ArrayReference_MetaData)) };
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ArrayReference_Inner = { "ArrayReference", nullptr, (EPropertyFlags)0x0000000000080000, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_UVRGripScriptBase_NoRegister, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ArrayReference,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::NewProp_ArrayReference_Inner,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Get grip scripts\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Get grip scripts" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "GetGripScripts", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventGetGripScripts_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics
{
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_GripDampingOut;
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_GripStiffnessOut;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::NewProp_GripDampingOut = { "GripDampingOut", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventGetGripStiffnessAndDamping_Parms, GripDampingOut), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::NewProp_GripStiffnessOut = { "GripStiffnessOut", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventGetGripStiffnessAndDamping_Parms, GripStiffnessOut), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::NewProp_GripDampingOut,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::NewProp_GripStiffnessOut,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// What grip stiffness and damping to use if using a physics constraint\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "What grip stiffness and damping to use if using a physics constraint" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "GetGripStiffnessAndDamping", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventGetGripStiffnessAndDamping_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics
{
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static void NewProp_bIsSlot_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bIsSlot;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventGetPrimaryGripType_Parms, ReturnValue), Z_Construct_UEnum_VRExpansionPlugin_EGripCollisionType, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::NewProp_bIsSlot_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventGetPrimaryGripType_Parms*)Obj)->bIsSlot = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::NewProp_bIsSlot = { "bIsSlot", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventGetPrimaryGripType_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::NewProp_bIsSlot_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::NewProp_ReturnValue_Underlying,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::NewProp_bIsSlot,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Grip type to use\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Grip type to use" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "GetPrimaryGripType", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventGetPrimaryGripType_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics
{
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventGripBreakDistance_Parms, ReturnValue), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// What distance to break a grip at (only relevent with physics enabled grips\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "What distance to break a grip at (only relevent with physics enabled grips" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "GripBreakDistance", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventGripBreakDistance_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics
{
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventGripLateUpdateSetting_Parms, ReturnValue), Z_Construct_UEnum_VRExpansionPlugin_EGripLateUpdateSettings, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::NewProp_ReturnValue_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Define the late update setting\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Define the late update setting" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "GripLateUpdateSetting", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventGripLateUpdateSetting_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics
{
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventGripMovementReplicationType_Parms, ReturnValue), Z_Construct_UEnum_VRExpansionPlugin_EGripMovementReplicationSettings, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::NewProp_ReturnValue_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Define which movement repliation setting to use\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Define which movement repliation setting to use" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "GripMovementReplicationType", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventGripMovementReplicationType_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics
{
static void NewProp_bIsHeld_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bIsHeld;
static const UE4CodeGen_Private::FArrayPropertyParams NewProp_HoldingControllers;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_HoldingControllers_Inner;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::NewProp_bIsHeld_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventIsHeld_Parms*)Obj)->bIsHeld = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::NewProp_bIsHeld = { "bIsHeld", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventIsHeld_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::NewProp_bIsHeld_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::NewProp_HoldingControllers = { "HoldingControllers", nullptr, (EPropertyFlags)0x0010008000000180, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventIsHeld_Parms, HoldingControllers), METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::NewProp_HoldingControllers_Inner = { "HoldingControllers", nullptr, (EPropertyFlags)0x0000008000000000, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UScriptStruct_FBPGripPair, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::NewProp_bIsHeld,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::NewProp_HoldingControllers,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::NewProp_HoldingControllers_Inner,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Returns if the object is held and if so, which controllers are holding it\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Returns if the object is held and if so, which controllers are holding it" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "IsHeld", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventIsHeld_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GripInformation_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_GripInformation;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GrippingController_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_GrippingController;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GripInformation_MetaData[] = {
{ "NativeConst", "" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GripInformation = { "GripInformation", nullptr, (EPropertyFlags)0x0010008008000182, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnChildGrip_Parms, GripInformation), Z_Construct_UScriptStruct_FBPActorGripInformation, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GripInformation_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GripInformation_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GrippingController_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GrippingController = { "GrippingController", nullptr, (EPropertyFlags)0x0010000000080080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnChildGrip_Parms, GrippingController), Z_Construct_UClass_UGripMotionControllerComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GrippingController_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GrippingController_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GripInformation,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::NewProp_GrippingController,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Event triggered on the interfaced object when child component is gripped\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Event triggered on the interfaced object when child component is gripped" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnChildGrip", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventOnChildGrip_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics
{
static void NewProp_bWasSocketed_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bWasSocketed;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GripInformation_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_GripInformation;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReleasingController_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_ReleasingController;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_bWasSocketed_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventOnChildGripRelease_Parms*)Obj)->bWasSocketed = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_bWasSocketed = { "bWasSocketed", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventOnChildGripRelease_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_bWasSocketed_SetBit, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_GripInformation_MetaData[] = {
{ "NativeConst", "" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_GripInformation = { "GripInformation", nullptr, (EPropertyFlags)0x0010008008000182, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnChildGripRelease_Parms, GripInformation), Z_Construct_UScriptStruct_FBPActorGripInformation, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_GripInformation_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_GripInformation_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_ReleasingController_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_ReleasingController = { "ReleasingController", nullptr, (EPropertyFlags)0x0010000000080080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnChildGripRelease_Parms, ReleasingController), Z_Construct_UClass_UGripMotionControllerComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_ReleasingController_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_ReleasingController_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_bWasSocketed,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_GripInformation,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::NewProp_ReleasingController,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Event triggered on the interfaced object when child component is released\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Event triggered on the interfaced object when child component is released" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnChildGripRelease", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventOnChildGripRelease_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndSecondaryUsed_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndSecondaryUsed_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Call to stop using an object\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Call to stop using an object" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndSecondaryUsed_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnEndSecondaryUsed", nullptr, nullptr, 0, nullptr, 0, RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndSecondaryUsed_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndSecondaryUsed_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndSecondaryUsed()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndSecondaryUsed_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndUsed_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndUsed_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Call to stop using an object\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Call to stop using an object" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndUsed_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnEndUsed", nullptr, nullptr, 0, nullptr, 0, RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndUsed_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndUsed_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndUsed()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndUsed_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GripInformation_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_GripInformation;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GrippingController_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_GrippingController;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GripInformation_MetaData[] = {
{ "NativeConst", "" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GripInformation = { "GripInformation", nullptr, (EPropertyFlags)0x0010008008000182, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnGrip_Parms, GripInformation), Z_Construct_UScriptStruct_FBPActorGripInformation, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GripInformation_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GripInformation_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GrippingController_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GrippingController = { "GrippingController", nullptr, (EPropertyFlags)0x0010000000080080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnGrip_Parms, GrippingController), Z_Construct_UClass_UGripMotionControllerComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GrippingController_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GrippingController_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GripInformation,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::NewProp_GrippingController,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Event triggered on the interfaced object when gripped\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Event triggered on the interfaced object when gripped" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnGrip", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventOnGrip_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics
{
static void NewProp_bWasSocketed_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bWasSocketed;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GripInformation_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_GripInformation;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReleasingController_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_ReleasingController;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_bWasSocketed_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventOnGripRelease_Parms*)Obj)->bWasSocketed = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_bWasSocketed = { "bWasSocketed", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventOnGripRelease_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_bWasSocketed_SetBit, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_GripInformation_MetaData[] = {
{ "NativeConst", "" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_GripInformation = { "GripInformation", nullptr, (EPropertyFlags)0x0010008008000182, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnGripRelease_Parms, GripInformation), Z_Construct_UScriptStruct_FBPActorGripInformation, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_GripInformation_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_GripInformation_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_ReleasingController_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_ReleasingController = { "ReleasingController", nullptr, (EPropertyFlags)0x0010000000080080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnGripRelease_Parms, ReleasingController), Z_Construct_UClass_UGripMotionControllerComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_ReleasingController_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_ReleasingController_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_bWasSocketed,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_GripInformation,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::NewProp_ReleasingController,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Event triggered on the interfaced object when grip is released\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Event triggered on the interfaced object when grip is released" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnGripRelease", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventOnGripRelease_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics
{
static const UE4CodeGen_Private::FBytePropertyParams NewProp_KeyEvent;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_Key;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::NewProp_KeyEvent = { "KeyEvent", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnInput_Parms, KeyEvent), Z_Construct_UEnum_Engine_EInputEvent, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::NewProp_Key = { "Key", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnInput_Parms, Key), Z_Construct_UScriptStruct_FKey, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::NewProp_KeyEvent,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::NewProp_Key,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Call to send an action event to the object\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Call to send an action event to the object" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnInput", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventOnInput_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GripInformation_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_GripInformation;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_SecondaryGripComponent_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_SecondaryGripComponent;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_GripInformation_MetaData[] = {
{ "NativeConst", "" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_GripInformation = { "GripInformation", nullptr, (EPropertyFlags)0x0010008008000182, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnSecondaryGrip_Parms, GripInformation), Z_Construct_UScriptStruct_FBPActorGripInformation, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_GripInformation_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_GripInformation_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_SecondaryGripComponent_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_SecondaryGripComponent = { "SecondaryGripComponent", nullptr, (EPropertyFlags)0x0010000000080080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnSecondaryGrip_Parms, SecondaryGripComponent), Z_Construct_UClass_USceneComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_SecondaryGripComponent_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_SecondaryGripComponent_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_GripInformation,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::NewProp_SecondaryGripComponent,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Event triggered on the interfaced object when secondary gripped\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Event triggered on the interfaced object when secondary gripped" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnSecondaryGrip", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventOnSecondaryGrip_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GripInformation_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_GripInformation;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ReleasingSecondaryGripComponent_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_ReleasingSecondaryGripComponent;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_GripInformation_MetaData[] = {
{ "NativeConst", "" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_GripInformation = { "GripInformation", nullptr, (EPropertyFlags)0x0010008008000182, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnSecondaryGripRelease_Parms, GripInformation), Z_Construct_UScriptStruct_FBPActorGripInformation, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_GripInformation_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_GripInformation_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_ReleasingSecondaryGripComponent_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_ReleasingSecondaryGripComponent = { "ReleasingSecondaryGripComponent", nullptr, (EPropertyFlags)0x0010000000080080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventOnSecondaryGripRelease_Parms, ReleasingSecondaryGripComponent), Z_Construct_UClass_USceneComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_ReleasingSecondaryGripComponent_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_ReleasingSecondaryGripComponent_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_GripInformation,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::NewProp_ReleasingSecondaryGripComponent,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Event triggered on the interfaced object when secondary grip is released\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Event triggered on the interfaced object when secondary grip is released" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnSecondaryGripRelease", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventOnSecondaryGripRelease_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryUsed_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryUsed_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Call to use an object\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Call to use an object" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryUsed_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnSecondaryUsed", nullptr, nullptr, 0, nullptr, 0, RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryUsed_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryUsed_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryUsed()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryUsed_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnUsed_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnUsed_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Call to use an object\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Call to use an object" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnUsed_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "OnUsed", nullptr, nullptr, 0, nullptr, 0, RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnUsed_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnUsed_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnUsed()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnUsed_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics
{
struct GrippableSkeletalMeshActor_eventPollReplicationEvent_Parms
{
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventPollReplicationEvent_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventPollReplicationEvent_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::Function_MetaDataParams[] = {
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "PollReplicationEvent", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventPollReplicationEvent_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x00020401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics
{
struct GrippableSkeletalMeshActor_eventRemoveFromClientReplicationBucket_Parms
{
bool ReturnValue;
};
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventRemoveFromClientReplicationBucket_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventRemoveFromClientReplicationBucket_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::Function_MetaDataParams[] = {
{ "Category", "Networking" },
{ "Comment", "// Remove this from client side physics replication\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Remove this from client side physics replication" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "RemoveFromClientReplicationBucket", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventRemoveFromClientReplicationBucket_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics
{
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FStructPropertyParams NewProp_RelativeTransform;
static const UE4CodeGen_Private::FNamePropertyParams NewProp_OptionalSocketName;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ParentToSocketTo_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_ParentToSocketTo;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventRequestsSocketing_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventRequestsSocketing_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_RelativeTransform = { "RelativeTransform", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventRequestsSocketing_Parms, RelativeTransform), Z_Construct_UScriptStruct_FTransform_NetQuantize, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FNamePropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_OptionalSocketName = { "OptionalSocketName", nullptr, (EPropertyFlags)0x0010000000000180, UE4CodeGen_Private::EPropertyGenFlags::Name, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventRequestsSocketing_Parms, OptionalSocketName), METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_ParentToSocketTo_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_ParentToSocketTo = { "ParentToSocketTo", nullptr, (EPropertyFlags)0x0010000000080180, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventRequestsSocketing_Parms, ParentToSocketTo), Z_Construct_UClass_USceneComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_ParentToSocketTo_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_ParentToSocketTo_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_RelativeTransform,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_OptionalSocketName,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::NewProp_ParentToSocketTo,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Returns if the object wants to be socketed\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Returns if the object wants to be socketed" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "RequestsSocketing", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventRequestsSocketing_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics
{
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventSecondaryGripType_Parms, ReturnValue), Z_Construct_UEnum_VRExpansionPlugin_ESecondaryGripType, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::NewProp_ReturnValue_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Secondary grip type\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Secondary grip type" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "SecondaryGripType", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventSecondaryGripType_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics
{
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_newMovement_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_newMovement;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::NewProp_newMovement_MetaData[] = {
{ "NativeConst", "" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::NewProp_newMovement = { "newMovement", nullptr, (EPropertyFlags)0x0010000008000082, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventServer_GetClientAuthReplication_Parms, newMovement), Z_Construct_UScriptStruct_FRepMovementVR, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::NewProp_newMovement_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::NewProp_newMovement_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::NewProp_newMovement,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::Function_MetaDataParams[] = {
{ "Category", "Networking" },
{ "Comment", "// Notify the server that we locally gripped something\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Notify the server that we locally gripped something" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "Server_GetClientAuthReplication", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventServer_GetClientAuthReplication_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x80220C40, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics
{
struct GrippableSkeletalMeshActor_eventSetDenyGripping_Parms
{
bool bDenyGripping;
};
static void NewProp_bDenyGripping_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bDenyGripping;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::NewProp_bDenyGripping_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventSetDenyGripping_Parms*)Obj)->bDenyGripping = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::NewProp_bDenyGripping = { "bDenyGripping", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventSetDenyGripping_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::NewProp_bDenyGripping_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::NewProp_bDenyGripping,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Sets the Deny Gripping variable on the FBPInterfaceSettings struct\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Sets the Deny Gripping variable on the FBPInterfaceSettings struct" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "SetDenyGripping", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventSetDenyGripping_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x04020401, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics
{
static void NewProp_bIsHeld_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bIsHeld;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_GripID;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_HoldingController_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_HoldingController;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_bIsHeld_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventSetHeld_Parms*)Obj)->bIsHeld = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_bIsHeld = { "bIsHeld", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventSetHeld_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_bIsHeld_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_GripID = { "GripID", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventSetHeld_Parms, GripID), nullptr, METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_HoldingController_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_HoldingController = { "HoldingController", nullptr, (EPropertyFlags)0x0010000000080080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventSetHeld_Parms, HoldingController), Z_Construct_UClass_UGripMotionControllerComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_HoldingController_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_HoldingController_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_bIsHeld,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_GripID,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::NewProp_HoldingController,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "/*BlueprintCallable,*/" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "BlueprintCallable," },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "SetHeld", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventSetHeld_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics
{
static void NewProp_ReturnValue_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
void Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::NewProp_ReturnValue_SetBit(void* Obj)
{
((GrippableSkeletalMeshActor_eventSimulateOnDrop_Parms*)Obj)->ReturnValue = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(GrippableSkeletalMeshActor_eventSimulateOnDrop_Parms), &Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::NewProp_ReturnValue_SetBit, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::NewProp_ReturnValue,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Should this object simulate on drop\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Should this object simulate on drop" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "SimulateOnDrop", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventSimulateOnDrop_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics
{
static const UE4CodeGen_Private::FEnumPropertyParams NewProp_ReturnValue;
static const UE4CodeGen_Private::FBytePropertyParams NewProp_ReturnValue_Underlying;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FEnumPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::NewProp_ReturnValue = { "ReturnValue", nullptr, (EPropertyFlags)0x0010000000000580, UE4CodeGen_Private::EPropertyGenFlags::Enum, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventTeleportBehavior_Parms, ReturnValue), Z_Construct_UEnum_VRExpansionPlugin_EGripInterfaceTeleportBehavior, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FBytePropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::NewProp_ReturnValue_Underlying = { "UnderlyingType", nullptr, (EPropertyFlags)0x0000000000000000, UE4CodeGen_Private::EPropertyGenFlags::Byte, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, nullptr, METADATA_PARAMS(nullptr, 0) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::NewProp_ReturnValue,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::NewProp_ReturnValue_Underlying,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// How an interfaced object behaves when teleporting\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "How an interfaced object behaves when teleporting" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "TeleportBehavior", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventTeleportBehavior_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x0C020C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior_Statics::FuncParams);
}
return ReturnFunction;
}
struct Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics
{
static const UE4CodeGen_Private::FFloatPropertyParams NewProp_DeltaTime;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GripInformation_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_GripInformation;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GrippingController_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_GrippingController;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Function_MetaDataParams[];
#endif
static const UE4CodeGen_Private::FFunctionParams FuncParams;
};
const UE4CodeGen_Private::FFloatPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_DeltaTime = { "DeltaTime", nullptr, (EPropertyFlags)0x0010000000000080, UE4CodeGen_Private::EPropertyGenFlags::Float, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventTickGrip_Parms, DeltaTime), METADATA_PARAMS(nullptr, 0) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GripInformation_MetaData[] = {
{ "NativeConst", "" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GripInformation = { "GripInformation", nullptr, (EPropertyFlags)0x0010008008000182, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventTickGrip_Parms, GripInformation), Z_Construct_UScriptStruct_FBPActorGripInformation, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GripInformation_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GripInformation_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GrippingController_MetaData[] = {
{ "EditInline", "true" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GrippingController = { "GrippingController", nullptr, (EPropertyFlags)0x0010000000080080, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(GrippableSkeletalMeshActor_eventTickGrip_Parms, GrippingController), Z_Construct_UClass_UGripMotionControllerComponent_NoRegister, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GrippingController_MetaData, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GrippingController_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_DeltaTime,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GripInformation,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::NewProp_GrippingController,
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::Function_MetaDataParams[] = {
{ "Category", "VRGripInterface" },
{ "Comment", "// Event triggered each tick on the interfaced object when gripped, can be used for custom movement or grip based logic\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Event triggered each tick on the interfaced object when gripped, can be used for custom movement or grip based logic" },
};
#endif
const UE4CodeGen_Private::FFunctionParams Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::FuncParams = { (UObject*(*)())Z_Construct_UClass_AGrippableSkeletalMeshActor, nullptr, "TickGrip", nullptr, nullptr, sizeof(GrippableSkeletalMeshActor_eventTickGrip_Parms), Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::PropPointers, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::PropPointers), RF_Public|RF_Transient|RF_MarkAsNative, (EFunctionFlags)0x08420C00, 0, 0, METADATA_PARAMS(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::Function_MetaDataParams, ARRAY_COUNT(Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::Function_MetaDataParams)) };
UFunction* Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip()
{
static UFunction* ReturnFunction = nullptr;
if (!ReturnFunction)
{
UE4CodeGen_Private::ConstructUFunction(ReturnFunction, Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip_Statics::FuncParams);
}
return ReturnFunction;
}
UClass* Z_Construct_UClass_AGrippableSkeletalMeshActor_NoRegister()
{
return AGrippableSkeletalMeshActor::StaticClass();
}
struct Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics
{
static UObject* (*const DependentSingletons[])();
static const FClassFunctionLinkInfo FuncInfo[];
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam Class_MetaDataParams[];
#endif
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_VRGripInterfaceSettings_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_VRGripInterfaceSettings;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bRepGripSettingsAndGameplayTags_MetaData[];
#endif
static void NewProp_bRepGripSettingsAndGameplayTags_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bRepGripSettingsAndGameplayTags;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_bAllowIgnoringAttachOnOwner_MetaData[];
#endif
static void NewProp_bAllowIgnoringAttachOnOwner_SetBit(void* Obj);
static const UE4CodeGen_Private::FBoolPropertyParams NewProp_bAllowIgnoringAttachOnOwner;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GameplayTags_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_GameplayTags;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_ClientAuthReplicationData_MetaData[];
#endif
static const UE4CodeGen_Private::FStructPropertyParams NewProp_ClientAuthReplicationData;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GripLogicScripts_MetaData[];
#endif
static const UE4CodeGen_Private::FArrayPropertyParams NewProp_GripLogicScripts;
#if WITH_METADATA
static const UE4CodeGen_Private::FMetaDataPairParam NewProp_GripLogicScripts_Inner_MetaData[];
#endif
static const UE4CodeGen_Private::FObjectPropertyParams NewProp_GripLogicScripts_Inner;
static const UE4CodeGen_Private::FPropertyParamsBase* const PropPointers[];
static const UE4CodeGen_Private::FImplementedInterfaceParams InterfaceParams[];
static const FCppClassTypeInfoStatic StaticCppClassTypeInfo;
static const UE4CodeGen_Private::FClassParams ClassParams;
};
UObject* (*const Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::DependentSingletons[])() = {
(UObject* (*)())Z_Construct_UClass_ASkeletalMeshActor,
(UObject* (*)())Z_Construct_UPackage__Script_VRExpansionPlugin,
};
const FClassFunctionLinkInfo Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::FuncInfo[] = {
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_AddToClientReplicationBucket, "AddToClientReplicationBucket" }, // 44154006
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_AdvancedGripSettings, "AdvancedGripSettings" }, // 228563426
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_AllowsMultipleGrips, "AllowsMultipleGrips" }, // 2461695618
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_CeaseReplicationBlocking, "CeaseReplicationBlocking" }, // 4204981807
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_ClosestGripSlotInRange, "ClosestGripSlotInRange" }, // 3853853389
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_DenyGripping, "DenyGripping" }, // 671361386
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripScripts, "GetGripScripts" }, // 870793665
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetGripStiffnessAndDamping, "GetGripStiffnessAndDamping" }, // 2884176147
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_GetPrimaryGripType, "GetPrimaryGripType" }, // 2827173669
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripBreakDistance, "GripBreakDistance" }, // 175101012
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripLateUpdateSetting, "GripLateUpdateSetting" }, // 1778420932
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_GripMovementReplicationType, "GripMovementReplicationType" }, // 4057300607
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_IsHeld, "IsHeld" }, // 3733598990
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGrip, "OnChildGrip" }, // 2337290985
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnChildGripRelease, "OnChildGripRelease" }, // 1389909031
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndSecondaryUsed, "OnEndSecondaryUsed" }, // 4095698958
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnEndUsed, "OnEndUsed" }, // 1500528666
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGrip, "OnGrip" }, // 1687606235
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnGripRelease, "OnGripRelease" }, // 4259085584
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnInput, "OnInput" }, // 2921106332
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGrip, "OnSecondaryGrip" }, // 3139471432
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryGripRelease, "OnSecondaryGripRelease" }, // 363724137
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnSecondaryUsed, "OnSecondaryUsed" }, // 3723231718
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_OnUsed, "OnUsed" }, // 357921475
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_PollReplicationEvent, "PollReplicationEvent" }, // 1080837258
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_RemoveFromClientReplicationBucket, "RemoveFromClientReplicationBucket" }, // 2700459516
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_RequestsSocketing, "RequestsSocketing" }, // 2981442952
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_SecondaryGripType, "SecondaryGripType" }, // 737709411
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_Server_GetClientAuthReplication, "Server_GetClientAuthReplication" }, // 3596088143
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetDenyGripping, "SetDenyGripping" }, // 2808611945
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_SetHeld, "SetHeld" }, // 238645155
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_SimulateOnDrop, "SimulateOnDrop" }, // 1222051768
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_TeleportBehavior, "TeleportBehavior" }, // 3304282802
{ &Z_Construct_UFunction_AGrippableSkeletalMeshActor_TickGrip, "TickGrip" }, // 4248868809
};
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::Class_MetaDataParams[] = {
{ "BlueprintSpawnableComponent", "" },
{ "BlueprintType", "true" },
{ "ClassGroupNames", "VRExpansionPlugin" },
{ "Comment", "/**\n*\n*/" },
{ "IncludePath", "Grippables/GrippableSkeletalMeshActor.h" },
{ "IsBlueprintBase", "true" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ObjectInitializerConstructorDeclared", "" },
};
#endif
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_VRGripInterfaceSettings_MetaData[] = {
{ "Category", "VRGripInterface" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_VRGripInterfaceSettings = { "VRGripInterfaceSettings", nullptr, (EPropertyFlags)0x0010008000000025, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(AGrippableSkeletalMeshActor, VRGripInterfaceSettings), Z_Construct_UScriptStruct_FBPInterfaceProperties, METADATA_PARAMS(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_VRGripInterfaceSettings_MetaData, ARRAY_COUNT(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_VRGripInterfaceSettings_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bRepGripSettingsAndGameplayTags_MetaData[] = {
{ "Category", "VRGripInterface" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
};
#endif
void Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bRepGripSettingsAndGameplayTags_SetBit(void* Obj)
{
((AGrippableSkeletalMeshActor*)Obj)->bRepGripSettingsAndGameplayTags = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bRepGripSettingsAndGameplayTags = { "bRepGripSettingsAndGameplayTags", nullptr, (EPropertyFlags)0x0010000000000025, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(AGrippableSkeletalMeshActor), &Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bRepGripSettingsAndGameplayTags_SetBit, METADATA_PARAMS(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bRepGripSettingsAndGameplayTags_MetaData, ARRAY_COUNT(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bRepGripSettingsAndGameplayTags_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bAllowIgnoringAttachOnOwner_MetaData[] = {
{ "Category", "Replication" },
{ "Comment", "// Skips the attachment replication if we are locally owned and our grip settings say that we are a client authed grip.\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Skips the attachment replication if we are locally owned and our grip settings say that we are a client authed grip." },
};
#endif
void Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bAllowIgnoringAttachOnOwner_SetBit(void* Obj)
{
((AGrippableSkeletalMeshActor*)Obj)->bAllowIgnoringAttachOnOwner = 1;
}
const UE4CodeGen_Private::FBoolPropertyParams Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bAllowIgnoringAttachOnOwner = { "bAllowIgnoringAttachOnOwner", nullptr, (EPropertyFlags)0x0010000000000025, UE4CodeGen_Private::EPropertyGenFlags::Bool | UE4CodeGen_Private::EPropertyGenFlags::NativeBool, RF_Public|RF_Transient|RF_MarkAsNative, 1, sizeof(bool), sizeof(AGrippableSkeletalMeshActor), &Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bAllowIgnoringAttachOnOwner_SetBit, METADATA_PARAMS(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bAllowIgnoringAttachOnOwner_MetaData, ARRAY_COUNT(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bAllowIgnoringAttachOnOwner_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GameplayTags_MetaData[] = {
{ "Category", "GameplayTags" },
{ "Comment", "/** Tags that are set on this object */" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Tags that are set on this object" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GameplayTags = { "GameplayTags", nullptr, (EPropertyFlags)0x0010000000000025, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(AGrippableSkeletalMeshActor, GameplayTags), Z_Construct_UScriptStruct_FGameplayTagContainer, METADATA_PARAMS(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GameplayTags_MetaData, ARRAY_COUNT(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GameplayTags_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_ClientAuthReplicationData_MetaData[] = {
{ "Category", "Replication" },
{ "Comment", "// ------------------------------------------------\n// Client Auth Throwing Data and functions \n// ------------------------------------------------\n" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
{ "ToolTip", "Client Auth Throwing Data and functions" },
};
#endif
const UE4CodeGen_Private::FStructPropertyParams Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_ClientAuthReplicationData = { "ClientAuthReplicationData", nullptr, (EPropertyFlags)0x0010000000000025, UE4CodeGen_Private::EPropertyGenFlags::Struct, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(AGrippableSkeletalMeshActor, ClientAuthReplicationData), Z_Construct_UScriptStruct_FVRClientAuthReplicationData, METADATA_PARAMS(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_ClientAuthReplicationData_MetaData, ARRAY_COUNT(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_ClientAuthReplicationData_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts_MetaData[] = {
{ "Category", "VRGripInterface" },
{ "EditInline", "true" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
};
#endif
const UE4CodeGen_Private::FArrayPropertyParams Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts = { "GripLogicScripts", nullptr, (EPropertyFlags)0x001000800000003d, UE4CodeGen_Private::EPropertyGenFlags::Array, RF_Public|RF_Transient|RF_MarkAsNative, 1, STRUCT_OFFSET(AGrippableSkeletalMeshActor, GripLogicScripts), METADATA_PARAMS(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts_MetaData, ARRAY_COUNT(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts_MetaData)) };
#if WITH_METADATA
const UE4CodeGen_Private::FMetaDataPairParam Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts_Inner_MetaData[] = {
{ "Category", "VRGripInterface" },
{ "EditInline", "true" },
{ "ModuleRelativePath", "Public/Grippables/GrippableSkeletalMeshActor.h" },
};
#endif
const UE4CodeGen_Private::FObjectPropertyParams Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts_Inner = { "GripLogicScripts", nullptr, (EPropertyFlags)0x0002000000080008, UE4CodeGen_Private::EPropertyGenFlags::Object, RF_Public|RF_Transient|RF_MarkAsNative, 1, 0, Z_Construct_UClass_UVRGripScriptBase_NoRegister, METADATA_PARAMS(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts_Inner_MetaData, ARRAY_COUNT(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts_Inner_MetaData)) };
const UE4CodeGen_Private::FPropertyParamsBase* const Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::PropPointers[] = {
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_VRGripInterfaceSettings,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bRepGripSettingsAndGameplayTags,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_bAllowIgnoringAttachOnOwner,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GameplayTags,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_ClientAuthReplicationData,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts,
(const UE4CodeGen_Private::FPropertyParamsBase*)&Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::NewProp_GripLogicScripts_Inner,
};
const UE4CodeGen_Private::FImplementedInterfaceParams Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::InterfaceParams[] = {
{ Z_Construct_UClass_UVRGripInterface_NoRegister, (int32)VTABLE_OFFSET(AGrippableSkeletalMeshActor, IVRGripInterface), false },
{ Z_Construct_UClass_UGameplayTagAssetInterface_NoRegister, (int32)VTABLE_OFFSET(AGrippableSkeletalMeshActor, IGameplayTagAssetInterface), false },
};
const FCppClassTypeInfoStatic Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::StaticCppClassTypeInfo = {
TCppClassTypeTraits<AGrippableSkeletalMeshActor>::IsAbstract,
};
const UE4CodeGen_Private::FClassParams Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::ClassParams = {
&AGrippableSkeletalMeshActor::StaticClass,
nullptr,
&StaticCppClassTypeInfo,
DependentSingletons,
FuncInfo,
Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::PropPointers,
InterfaceParams,
ARRAY_COUNT(DependentSingletons),
ARRAY_COUNT(FuncInfo),
ARRAY_COUNT(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::PropPointers),
ARRAY_COUNT(InterfaceParams),
0x009000A0u,
METADATA_PARAMS(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::Class_MetaDataParams, ARRAY_COUNT(Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::Class_MetaDataParams))
};
UClass* Z_Construct_UClass_AGrippableSkeletalMeshActor()
{
static UClass* OuterClass = nullptr;
if (!OuterClass)
{
UE4CodeGen_Private::ConstructUClass(OuterClass, Z_Construct_UClass_AGrippableSkeletalMeshActor_Statics::ClassParams);
}
return OuterClass;
}
IMPLEMENT_CLASS(AGrippableSkeletalMeshActor, 2525411379);
template<> VREXPANSIONPLUGIN_API UClass* StaticClass<AGrippableSkeletalMeshActor>()
{
return AGrippableSkeletalMeshActor::StaticClass();
}
static FCompiledInDefer Z_CompiledInDefer_UClass_AGrippableSkeletalMeshActor(Z_Construct_UClass_AGrippableSkeletalMeshActor, &AGrippableSkeletalMeshActor::StaticClass, TEXT("/Script/VRExpansionPlugin"), TEXT("AGrippableSkeletalMeshActor"), false, nullptr, nullptr, nullptr);
DEFINE_VTABLE_PTR_HELPER_CTOR(AGrippableSkeletalMeshActor);
PRAGMA_ENABLE_DEPRECATION_WARNINGS
#ifdef _MSC_VER
#pragma warning (pop)
#endif
|
import React from 'react';
export function FavoriteActiveSvg(): JSX.Element {
return(
<svg width="24" height="24" viewBox="0 0 24 24">
<path fill="currentColor" fillRule="evenodd" d="M16 3c3.59 0 6 2.41 6 6 0 4.452-3.44 8.308-9.311 11.824-.394.246-.98.246-1.366.006C5.46 17.353 2 13.466 2 9c0-3.59 2.41-6 6-6 1.39 0 2.746.61 4 1.641C13.254 3.61 14.61 3 16 3z"/>
</svg>
);
}
|
#include <stdio.h>
double dp[3000][3000];
long long n;
double arr[3000];
double solve(long long index,long long target)
{
if(index>=n)
{
if(target==0) return 1.0;
else return 0.0;
}
else if(dp[index][target]!=-1) return dp[index][target];
else return dp[index][target]=solve(index+1,target-1)*arr[index]+solve(index+1,target)*(1-arr[index]);
}
int main()
{
for(int i=0;i<3000;i++)
for (int j = 0; j < 3000; j++)
dp[i][j]=-1;
scanf("%lld",&n);
double ans=0.0;
for(int i=0;i<n;i++)
scanf("%lf",&arr[i]);
for(long long i=n/2+1;i<=n;i++)
ans+=solve(0,i);
printf("%.10lf\n",ans);
return 0;
} |
Interest-based Segments of TV Audiences
ABSTRACT This paper is one of 18 selected by the Editorial Review Board of The Journal of Advertising Research to be a ‘classic’ - an article that has withstood the test of time. First published in 1979, this paper reports on a face-to-face national probability survey of 2500 respondents in 1000 TV households covering leisure activities and TV viewing behaviour. The results were factor-analysed into 14 audience segments and have implications for TV station development and programme selection and scheduling. |
<gh_stars>1-10
// Package goaci is a a Cisco ACI client library for Go.
package goaci
import (
"crypto/tls"
"errors"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/http/cookiejar"
"strings"
"time"
"github.com/tidwall/gjson"
)
// Client is an HTTP ACI API client.
// Use goaci.NewClient to initiate a client.
// This will ensure proper cookie handling and processing of modifiers.
type Client struct {
// HttpClient is the *http.Client used for API requests.
HttpClient *http.Client
// Url is the APIC IP or hostname, e.g. 10.0.0.1:80 (port is optional).
Url string
// Usr is the APIC username.
Usr string
// Pwd is the APIC password.
Pwd string
// LastRefresh is the timestamp of the last token refresh interval.
LastRefresh time.Time
// Token is the current authentication token
Token string
}
// NewClient creates a new ACI HTTP client.
// Pass modifiers in to modify the behavior of the client, e.g.
// client, _ := NewClient("apic", "user", "password", RequestTimeout(120))
func NewClient(url, usr, pwd string, mods ...func(*Client)) (Client, error) {
// Normalize the URL
if !strings.HasPrefix(url, "http://") && !strings.HasPrefix(url, "https://") {
url = "https://" + url
}
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
}
cookieJar, _ := cookiejar.New(nil)
httpClient := http.Client{
Timeout: 60 * time.Second,
Transport: tr,
Jar: cookieJar,
}
client := Client{
HttpClient: &httpClient,
Url: url,
Usr: usr,
Pwd: <PASSWORD>,
}
for _, mod := range mods {
mod(&client)
}
return client, nil
}
// NewReq creates a new Req request for this client.
func (client Client) NewReq(method, uri string, body io.Reader, mods ...func(*Req)) Req {
httpReq, _ := http.NewRequest(method, client.Url+uri+".json", body)
req := Req{
HttpReq: httpReq,
Refresh: true,
}
for _, mod := range mods {
mod(&req)
}
return req
}
// RequestTimeout modifies the HTTP request timeout from the default of 60 seconds.
func RequestTimeout(x time.Duration) func(*Client) {
return func(client *Client) {
client.HttpClient.Timeout = x * time.Second
}
}
// Do makes a request.
// Requests for Do are built ouside of the client, e.g.
//
// req := client.NewReq("GET", "/api/class/fvBD", nil)
// res := client.Do(req)
func (client *Client) Do(req Req) (Res, error) {
if req.Refresh && time.Now().Sub(client.LastRefresh) > 480*time.Second {
if err := client.Refresh(); err != nil {
return Res{}, err
}
}
httpRes, err := client.HttpClient.Do(req.HttpReq)
if err != nil {
return Res{}, err
}
defer httpRes.Body.Close()
if httpRes.StatusCode != http.StatusOK {
return Res{}, fmt.Errorf("received HTTP status %d", httpRes.StatusCode)
}
body, err := ioutil.ReadAll(httpRes.Body)
if err != nil {
return Res{}, errors.New("cannot decode response body")
}
return Res(gjson.ParseBytes(body)), nil
}
// Get makes a GET request and returns a GJSON result.
// Results will be the raw data structure as returned by the APIC, wrapped in imdata, e.g.
//
// {
// "imdata": [
// {
// "fvTenant": {
// "attributes": {
// "dn": "uni/tn-mytenant",
// "name": "mytenant",
// }
// }
// }
// ],
// "totalCount": "1"
// }
func (client *Client) Get(path string, mods ...func(*Req)) (Res, error) {
req := client.NewReq("GET", path, nil, mods...)
return client.Do(req)
}
// GetClass makes a GET request by class and unwraps the results.
// Result is removed from imdata, but still wrapped in Class.attributes, e.g.
// [
// {
// "fvTenant": {
// "attributes": {
// "dn": "uni/tn-mytenant",
// "name": "mytenant",
// }
// }
// }
// ]
func (client *Client) GetClass(class string, mods ...func(*Req)) (Res, error) {
res, err := client.Get(fmt.Sprintf("/api/class/%s", class), mods...)
if err != nil {
return res, err
}
return res.Get("imdata"), nil
}
// GetDn makes a GET request by DN.
// Result is removed from imdata and first result is removed from the list, e.g.
// {
// "fvTenant": {
// "attributes": {
// "dn": "uni/tn-mytenant",
// "name": "mytenant",
// }
// }
// }
func (client *Client) GetDn(dn string, mods ...func(*Req)) (Res, error) {
res, err := client.Get(fmt.Sprintf("/api/mo/%s", dn), mods...)
if err != nil {
return res, err
}
return res.Get("imdata.0"), nil
}
// Post makes a POST request and returns a GJSON result.
// Hint: Use the Body struct to easily create POST body data.
func (client *Client) Post(path, data string, mods ...func(*Req)) (Res, error) {
req := client.NewReq("POST", path, strings.NewReader(data), mods...)
return client.Do(req)
}
// Login authenticates to the APIC.
func (client *Client) Login() error {
data := fmt.Sprintf(`{"aaaUser":{"attributes":{"name":"%s","pwd":"%s"}}}`,
client.Usr,
client.Pwd,
)
res, err := client.Post("/api/aaaLogin", data, NoRefresh)
if err != nil {
return err
}
errText := res.Get("imdata.0.error.attributes.text").Str
if errText != "" {
return errors.New("authentication error")
}
client.Token = res.Get("imdata.0.aaaLogin.attributes.token").Str
client.LastRefresh = time.Now()
return nil
}
// Refresh refreshes the authentication token.
// Note that this will be handled automatically be default.
// Refresh will be checked every request and the token will be refreshed after 8 minutes.
// Pass goaci.NoRefresh to prevent automatic refresh handling and handle it directly instead.
func (client *Client) Refresh() error {
res, err := client.Get("/api/aaaRefresh", NoRefresh)
if err != nil {
return err
}
client.Token = res.Get("imdata.0.aaaRefresh.attributes.token").Str
client.LastRefresh = time.Now()
return nil
}
|
def psaw_parse_response(self, res, db=None, save_data=False):
if not db:
self.last_id_count = 1
else:
sort = [('_id', -1)]
documents = db.get_documents(sort=sort, limit=1, show=False)
try:
self.last_id_count = documents[0]['doc_id'] + 1
except IndexError:
self.last_id_count = 1
if self.LOG_FILENAME:
self.MY_LOGGER.info(f"{datetime.now()} -- [CorpusProcessor] Last id count {self.last_id_count}...")
df = pd.DataFrame()
post = res[-1]
if not post['is_video'] and post['is_self']:
text = post['selftext']
full_name = 't3_'+post['id']
doc_id = self.last_id_count
corpus_savepath = self.corpus_filepath+post['subreddit']
try:
upvote_ratio = post['upvote_ratio']
except KeyError:
upvote_ratio = -1
data_dict = {
'doc_id': doc_id,
'full_name': full_name,
'subreddit': post['subreddit'],
'title': post['title'],
'little_taste': text[:150],
'selftext': post['selftext'],
'author': post['author'],
'upvote_ratio': upvote_ratio,
'score': post['score'],
'num_comments': post['num_comments'],
'permalink': post['permalink'],
'num_characters': len(text),
'num_bytes': getsizeof(text),
'created_utc': post['created_utc'],
'created_human_readable': datetime.utcfromtimestamp(post['created_utc'],).strftime('%Y-%m-%dT%H:%M:%SZ'),
'filepath':corpus_savepath+f'/{doc_id}_{full_name}.txt',
'train_test':'',
'api_type':'psaw'
}
if save_data:
if not os.path.exists(corpus_savepath):
os.makedirs(corpus_savepath)
try:
with open(corpus_savepath+f'/{doc_id}_{full_name}.txt', 'w', encoding='utf-8') as f:
f.write(text)
if self.LOG_FILENAME:
self.MY_LOGGER.info(f"{datetime.now()} -- [CorpusProcessor] Saved data to {doc_id}_{full_name}...")
except FileNotFoundError:
print(f'[FileNotFoundError] Error saving, skipping {doc_id}_{full_name}')
if self.LOG_FILENAME:
self.MY_LOGGER.info(f"{datetime.now()} -- [CorpusProcessor] [FileNotFoundError] Error saving, skipping {doc_id}_{full_name}...")
db.insert_documents(data_dict)
if self.LOG_FILENAME:
self.MY_LOGGER.info(f"{datetime.now()} -- [CorpusProcessor] Parsed json response...") |
package main
import "testing"
func TestBitSet(t *testing.T) {
n := 64
a := NewBitSet(n)
a.Set(10)
if !a.IsSet(10) {
t.Fatalf("10 should be set, but not")
}
a.Clear(10)
if a.IsSet(10) {
t.Fatalf("10 should not be set but wrong")
}
a.Set(10)
a = a.RightShift(3)
if a.IsSet(10) || !a.IsSet(7) {
t.Fatalf("7 should be set")
}
a = a.RightShift(8)
if a.IsSet(0) {
t.Fatalf("no one should be set")
}
}
func TestSample1(t *testing.T) {
W, H, N, M := 10, 10, 3, 3
X := []int{3, 6, 8}
Y := []int{1, 6, 10}
res := solve(W, H, N, M, X, Y)
if res != 3 {
t.Errorf("Sample expect 3, but got %d", res)
}
}
|
def remove_compounds(self,removed_compounds):
if type(removed_compounds) is not list:
userError("**Error! the input to 'remove_compounds' should be a list of compound objects")
for cmp in removed_compounds:
for rxn in cmp.reactions:
if rxn.stoichiometry[cmp] < 0:
if rxn.reactants != []:
del rxn.reactants[rxn.reactants.index(cmp)]
elif rxn.stoichiometry[cmp] > 0:
if rxn.products != []:
del rxn.products[rxn.products.index(cmp)]
del rxn.stoichiometry[cmp]
cmp_rxns = list(set([r for r in self.reactions if cmp in r.compounds + r.reactants + r.products + r.stoichiometry.keys()]))
if len(cmp_rxns) > 0:
for r in cmp_rxns:
try:
del r.compounds[r.compounds.index(cmp)]
except:
continue
try:
del r.reactants[r.reactant.index(cmp)]
except:
continue
try:
del r.products[r.products.index(cmp)]
except:
continue
try:
del r.stoichiometry.keys()[r.stoichiometry.keys().index(cmp)]
except:
continue
del self.compounds[self.compounds.index(cmp)]
self.compounds = sorted(set(list(self.compounds)),key=lambda x:x.id)
del self.compounds_by_id[cmp.id] |
def _inner_release(self):
if not self.is_acquired:
return False
try:
self._delete_nodes(self.nodes)
except NoNodeError:
pass
self.is_acquired = False
self.nodes = [None for _ in self.paths]
return True |
pub mod redis;
pub mod slack;
pub use redis::{RedisResponse, RedisServer};
pub use slack::{SlackApi, SlackUser, SlackUserGroup};
|
The Los Angeles Rams’ 2017 draft was peppered with small-school reaches. While the Rams may not have gained the best value from the 2017 NFL Draft, the overall process did contain a few positives. The offensive selections demonstrate that the front office has a clear acknowledgement of the scheme that new head coach Sean McVay wants to run. Furthermore, second rounder Gerald Everett – the Rams’ first pick – is a player McVay has coveted for years. It should be comforting for Rams fans to see evidence of a relationship between general manager Les Snead and his head coach; a rapport that has been lacking in previous seasons.
Everett has been compared to Jordan Reed on numerous occasions. Direct player comparisons are lazy, unfair, and incorrect. However, this likeness has merit in terms of the ideal offensive fit and role for both Everett and Reed. Both are branded as ‘tight ends:, yet are more mismatch, big slot receivers who bring similar skills to an offense.
We saw in Washington what McVay could do with a player like Reed. Very rarely did Reed line up in a traditional 3 point stance. He spent his snaps in the slot or on the wing, and even split out wide. McVay’s usage of Reed gives us insight into how he will attempt to use Everett in Los Angeles. He looked to utilize his run-after-catch ability, with plenty of shallow slants cleared out by verticals, quick out, and flat routes. This also extended to dump offs after play-action bootlegs. Additionally, Reed was used as a mismatch weapon: stretching a defense vertically up the seams and down the middle of the field, while being a size mismatch who was ideally isolated on the outside.
In this first video, McVay creates a one-on-one mismatch with linebacker Vontaze Burfict (#55) for Reed. Los Angeles leads 20-10 in the third quarter, and they are facing a 2nd and 8. The Cincinnati Bengals run a mixture of man and zone based on reads and keys made by the defenders. Reed is given a free release since he is lined up off the line of scrimmage in a stack. Washington runs a 10-yard out and a fade on the right side of the formation. The vertical route, from DeSean Jackson (#11), creates even more room for Reed. He runs his route well, beating Burfict with a sharp outwards cut while maintaining his speed. He comes back to the football and takes it for more yards and a touchdown. He has great ability with the ball in his hands:
Here, Washington is facing a big 3rd and 5 with a narrow lead of 13-10 in the third quarter. The Green Bay Packers are also running a mix of man and zone. It’s essentially a Cover 2 look, with the middle linebacker – safety Ha Ha Clinton-Dix (#42) – carrying and covering any seam routes deep. The curved, C-like, post route from Reed is again run adeptly. He finds a hole behind the zone coverage of safety Micah Hyde (#33), taking advantage of the space created by the skinny post run by slot receiver Jamison Crowder (#80). It’s the perfect example of what a switch concept can do. Reed is left wide open for a simple throw. Once more, the offensive chess piece creates yards after the catch:
In the redzone, McVay was inclined to split Reed out wide. Here, with Washington facing 1st and 7 with 2:00 left in their game against Dallas, they score a much-needed touchdown, as they were trailing 31-19. Reed wins on the slant against the isolated coverage of Brandon Carr (#39). He does well to create clear separation with a subtle brush of his arm. He catches away from his frame using his size for the eight-yard touchdown.
In college, Everett rarely lined up in-line or in a 3 point stance. His successes came in very similar ways to Reed’s game in Washington. He was a lethal yards-after-catch threat, running through arm tackles consistently with strong legs. He stretched the seam with speed and threatened over the middle on post routes. Finally, he showed the ability to be a sheer size mismatch. McVay’s usage of Reed in Washington is the perfect role for Everett in Los Angeles.
Against Georgia Southern, Everett’s run-after-catch ability was on display frequently. The defense seems to be in Cover 2 pre-snap. What initially appears to be Cover 4 is actually a 4 steal coverage. On the boundary, cornerback Darius Jones Jr. (#5) is in man coverage with receiver Tyrone Williams (#2). Meanwhile, weakside linebacker Ironhead Gallon (#27) is in man coverage with the running back. Weak safety Joshua Moon (#22) is tasked with working from the #3 receiver to the trips, aimed at picking up seam routes or deep crossers. The other two defensive backs are more conventionally covering their deep thirds.
South Alabama’s seam deep crossing route, run by Josh Magee (#1), causes strongside linebacker Ukeme Eligwe (#7) to gravitate toward it, creating space for Everett’s wheel route from the wing. Everett adjusts to the football mid-flight, making a back-shoulder catch. He establishes himself as a runner quickly – despite the ball being thrown behind him – and goes on to force four missed tackles, adding 20 yards to the 15 yard catch. It is reminiscent of Reed’s ability to catch in the flat and transform the gain, such as the one from the first video versus Cincinnati.
Here, Everett is again lined up on the wing. The defense is showing a Cover 4 or Cover 2 off look. The defense rotates into a Cover 3 buzz pass coverage. South Alabama runs a double-post concept, with a smash concept to the left. Everett’s post route faces contact from Eligwe (#7) passing him off to the deep coverage, but he works through it and finds the hole in the zone coverage. He makes the catch over the middle.
Again, his ability to create yards after the catch is showcased. He breaks the immediate tackle from the deep safety, Moon (#22), and keeps his balance and takes the ball for an additional 10 yards. This is exactly the sort of play that Reed executed under McVay – similar to the second clip and Reed’s play against Green Bay.
Before the snap on this next play, Mississippi State lines up in a goal-line formation, showing a Cover 0 look. Post-snap, they send seven to rush the quarterback and do indeed play straight one-on-one coverage. It is the second last chance for South Alabama to pull off a remarkable upset against a Power 5 school. They must convert this 3rd and goal, trailing 20-14 with just 1:01 left in the fourth quarter.
The Jaguars run a combination of an under route and a stick-nod route. Everett does a satisfactory job of running his stick-nod route, but the defensive back, Kivon Coman (#11), does not bite on his outside feint. However, what Everett flashes most on this play is the size mismatch he presents. Quarterback Dallas Davis (#11) throws the football up for Everett to go and get it. He uses his big frame – perhaps influenced by his basketball background – to box out the two defenders around the ball and catch the game-winning touchdown.
These examples all come with one large caveat: To have the level of success in the NFL akin to Reed, Everett needs to improve and refine numerous aspects of his game. Though he demonstrates acceleration into his routes, he appears slow off the line. He really needs to develop his route-running overall. It lacks sharpness, urgency, and nous – such as selling the deep route better by pushing harder vertically. In his role, he will be most hurt by this on post routes against Cover 2. In that scenario, it is vital that he is able to manipulate the safety. His hands also looked inconsistent. His poor blocking should be less of an issue since he will not be playing the traditional tight-end role, but it suffers from flawed technique.
Against better competition, a lot of Everett’s plays would not have had the same results. In the first example, a better linebacker would have stayed disciplined and therefore would have been in prime position to play the ball. In the second, the deep safety would have recognized the post and broke on the ball. This is why it is so important for Everett to develop early on in his NFL career.
The offense that Everett is joining needs to be taken into consideration as well. Washington persistently tried to establish the run last year, with limited success. In Los Angeles, the running game should be better; Todd Gurley’s down year does not make him a less talented back than those McVay had in Washington.
As Everett arrives to fill that Reed role, other offensive players will be used similarly to the gameplan in Washington. Tavon Austin, for instance, provides the speed to be able to clear out space for Everett underneath or on switch concepts. Crowder was often tasked with this responsibility in Washington. Note, though, that Austin is missing OTAs with a left wrist injury.
An intriguing aspect of the Everett selection is what will happen to Tyler Higbee. The Rams’ 2016 fourth rounder will still be a part of the offense but, though he is more of a conventional tight end, he is still in the “‘move”’ mold rather than being an “‘inline”’ type. Reassuringly, McVay managed to scheme the most offensive yards for tight ends last season in Washington, where Vernon Davis managed to experience a mini-resurgence. This was despite Washington running two or more tight end sets for only 26.26% of their offensive snaps, which placed 18th in the league (league average of 25.41%). NFL Network’s Steve Wyche eported an increased amount of two tight end sets in OTAs, with the Rams planning to run more of a tight end-focused passing attack in 2017.
The overall situation on offense is just plain embarrassing though. The Rams over-drafted Cooper Kupp and Josh Reynolds in an attempt to improve their mediocre wide receiving corps. On the offensive line, the signing of the ageing Andrew Whitworth will not cover all the pores. Yet the biggest issue remains under center, where 2016’s #1 pick Jared Goff severely underwhelmed. Goff showed a lack of accuracy, footwork issues, and struggles with mental processing at the NFL level. Even McVay will struggle to scheme around that, particularly as the 31-year-old deals with the added rigors of his first year as a head coach.
Want more Inside the Pylon? Subscribe to our podcasts, follow us on Twitter, like us on Facebook or catch us at our YouTube channel.
About the author
Matty Brown Matty currently attends the University of East Anglia, England. When he's not studying history, he coaches defensive backs at the UEA Pirates whilst also scouting their upcoming opponent. He has an unhealthy obsession with planning semi-realistic football trips to America. |
<reponame>kyungmin96/myfcdd
from typing import List, Tuple
import torch
from fcdd.models.bases import FCDDNet, BaseNet
from fcdd.training.ae import AETrainer
from fcdd.training.fcdd import FCDDTrainer
from fcdd.training.hsc import HSCTrainer
from fcdd.util.logging import Logger
from torch.optim.lr_scheduler import _LRScheduler
from torch.optim.optimizer import Optimizer
from torch.utils.data.dataloader import DataLoader
class SuperTrainer(object):
def __init__(
self, net: BaseNet, opt: Optimizer, sched: _LRScheduler, dataset_loaders: Tuple[DataLoader, DataLoader],
logger: Logger, device=torch.device('cuda:0'), objective='fcdd',
quantile=0.93, resdown=64, gauss_std: float = None, blur_heatmaps=True
):
"""
This super trainer maintains networks, optimizers, schedulers, and everything related to training and testing.
Most importantely, it offers the :meth:`train` and :meth:`test`.
Both methods are adjusted to fit the objective, i.e. the super trainer creates individual sub trainer instances
based on the objective -- e.g. an FCDDTrainer for the FCDD objective -- whose train and test methods are invoked
respectively.
For training, the trainer trains the network using the optimizer and scheduler, and it
logs losses and other relevant metrics.
For testing, the trainer computes scores (ROCs) for the test samples and generates heatmaps for samples
arranged in different ways for both training and test sets (see :meth:`fcdd.training.bases.BaseADTrainer.test`)
:param net: neural network model that is to be trained and tested.
:param opt: some optimizer that is used to fit the network parameters.
:param sched: some learning rate scheduler that adjusts the learning rate during training.
:param dataset_loaders: train and test loader, might either return 2 values (input, label)
or 3 values (input, label, ground-truth map).
:param logger: some logger that is used to log all training and test information.
:param device: either a cuda device or cpu.
:param objective: the objective that is to be trained, one of {'fcdd', 'hsc', 'ae'}.
:param quantile: the quantile used for normalizing the heatmaps (see Appendix of the paper).
:param resdown: the maximum allowed resolution per heatmap for logged images (height and width at once).
:param gauss_std: the standard deviation used for Gaussian kernels (upsampling and blurring).
None defaults to the formula in :func:`fcdd.datasets.noise.kernel_size_to_std`.
:param blur_heatmaps: whether to blur heatmaps that have not been upsampled with a Gaussian kernel.
"""
if objective in ['fcdd']:
assert isinstance(net, FCDDNet), 'For the FCDD objective, the net needs to be an FCDD net!'
elif objective in ['hsc']:
assert not isinstance(net, FCDDNet), 'For the HSC objective, the net must not be an FCDD net!'
elif objective in ['ae']:
assert hasattr(net, 'encoder_cls'), 'For the AE objective, the net must be an autoencoder!'
if objective == 'fcdd':
self.trainer = FCDDTrainer(
net, opt, sched, dataset_loaders, logger, objective, gauss_std, quantile, resdown, blur_heatmaps, device
)
elif objective == 'hsc':
self.trainer = HSCTrainer(
net, opt, sched, dataset_loaders, logger, objective, gauss_std, quantile, resdown, blur_heatmaps, device
)
else:
self.trainer = AETrainer(
net, opt, sched, dataset_loaders, logger, objective, gauss_std, quantile, resdown, blur_heatmaps, device
)
self.logger = logger
self.res = {} # keys = {pt_roc, roc, gtmap_roc, prc, gtmap_prc}
def train(self, epochs: int, snap: str = None, acc_batches=1):
"""
Trains the model for anomaly detection. Afterwards, stores and plots all metrics that have
been logged during training in respective files in the log directory. Additionally, saves a snapshot
of the model.
:param epochs: number of epochs (full data loader iterations).
:param snap: path to training snapshot to load network parameters for model before any training.
If epochs exceeds the current epoch loaded from the snapshot, training is continued with
the optimizer and schedulers having loaded their state from the snapshot as well.
:param acc_batches: accumulate that many batches (see :meth:`fcdd.training.bases.BaseTrainer.train`).
"""
start = self.load(snap)
try:
self.trainer.train(epochs - start, acc_batches)
finally:
self.logger.save()
self.logger.plot()
self.trainer.snapshot(epochs)
def test(self, specific_viz_ids: Tuple[List[int], List[int]] = ()) -> dict:
"""
Tests the model, i.e. computes scores and heatmaps and stores them in the log directory.
For details see :meth:`fcdd.training.bases.BaseTrainer.test`.
:param specific_viz_ids: See :meth:`fcdd.training.bases.BaseTrainer.test`
"""
res = self.trainer.test(specific_viz_ids)
if res is not None:
self.res.update(res)
return self.res
def load(self, path):
""" loads snapshot of model parameters and training state """
epoch = 0
if path is not None:
epoch = self.trainer.load(path)
return epoch
|
A CBC News investigation has revealed the Conservative Party candidate running against Liberal Leader Justin Trudeau is a performance artist whose campaign is at least partially intended to "mess with" the Tories.
Performance artist Chris Lloyd was formally acclaimed as the Conservative candidate in the Montreal riding of Papineau in February.
But CBC News has learned his campaign and party involvement is part of an art project he's working on.
Lloyd has been writing a letter to the prime minister nearly every day since 2001. His topics run from the mundane to more critical.
He declined CBC's request for an interview, but freelance journalist Corey Robichaud recorded a talk Lloyd gave at an art space in Fredericton on March 5.
During that talk, he revealed how his artistic interest in Canadian politics is as varied as it is committed: on top of running a Conservative campaign, he is a member of the group Leadnow, a group bent on preventing a Conservative majority.
Active in Papineau since 2011
In 2011, Lloyd contacted his electoral riding association executives to ask about attending the national convention. He said they were initially suspicious of him, saying he didn't "seem" like a conservative.
During his talk, Lloyd said he explained to the executives he was an artist doing a project involving politics.
"But as soon as I said 'art' and 'project' and stuff like that, their eyes kind of glazed over a bit," he said.
He eventually became the electoral association's president, and in February, he was acclaimed to become the official candidate.
Since then, his winking online posts have outwardly appeared to support Prime Minister Stephen Harper. His official blog is called "Certainly not Justin."
This post on the Conservative Party's Papineau Facebook page seem to outwardly support the party's policies. (Facebook)
In his speech in Fredericton, he said he's not a natural actor or role player, so he's adopted a persona, though it's unclear to what extent the party knows that.
"The easiest persona I've been able to summon up ... is to somehow convince myself that by taking on the Conservative candidature, I'm doing it to defeat some greater evil which is perhaps Justin Trudeau," he said.
"So I'm earnestly trying to unseat him and I can sleep at night with that idea, with that knowledge."
He said he has no specific objective for the project.
"I've been telling the prime minister about this whole thing from, like, the get-go with all sorts of imaginings and fantasies and options, like, 'Yeah, I'm going to become the candidate, I'm going to like mess with your party, I'm totally, like, going to wait till the writ is dropped then it's going to be party time," he said.
Chris Lloyd wrote this fake cheque to pay for the controversial F-35 fighter jets. (Chris Lloyd)
Nomination could be revoked
The Conservative Party still has time to revoke Lloyd's nomination. His name will not appear on the ballot until Harper signs his official papers after the writ is dropped.
But Quebec political organizer Brigitte Legault warns against parties dropping candidates too frequently.
She also said members pick candidates, and the party ought to respect the members' decisions.
"The party can still drop [a candidate], but it will be very bad for the reputation of the party ... to drop people after a long process of vetting," she said.
In the campaigns she's been involved with, Legault said there was ample vetting not only of the candidate's legal history, but also their online presence, including social media.
A spokesman for the Conservative party said Lloyd went through the same vetting process as all the other candidates. |
<reponame>michalMilewski-8/MillingSimulator<filename>Torus.h
#pragma once
#include "Object.h"
class Torus :
public Object
{
public:
Torus(float R, float r, int vertical, int horizontal,glm::vec4 color, Shader sh);
void DrawObject(glm::mat4 mvp) override;
void CreateMenu() override;
float GetR() const { return R; }
float Getr() const { return r; }
float GetVertical() const { return vertical_points_number; }
float GetHorizontal() const { return horizontal_points_number; }
glm::vec4 GetColor() const { return color; }
void Serialize(xml_document<>& document, xml_node<>* scene) override;
std::vector<std::function<glm::vec3(double, double)>> GetParametrisations() override;
std::vector<std::function<glm::vec3(double, double)>> GetUParametrisations() override;
std::vector<std::function<glm::vec3(double, double)>> GetVParametrisations() override;
void SetR(float _R);
void Setr(float _r);
void SetVertical(int _v);
void SetHorizontal(float _h);
void SetColor(glm::vec4 _c);
static unsigned int counter;
private:
void create_torus_points();
glm::vec3 torus_point(float alfa_r, float beta_r);
void update_object() override;
float R;
float r;
int vertical_points_number;
int horizontal_points_number;
std::vector<float> points;
std::vector<unsigned int> triangles;
};
|
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.