|
PMIC
|
Header file of DMA HAL extension module. More...
#include "stm32f1xx_hal_def.h"
Go to the source code of this file.
Macros | |
| #define | __HAL_DMA_GET_TC_FLAG_INDEX(__HANDLE__) |
| Returns the current DMA Channel transfer complete flag. More... | |
| #define | __HAL_DMA_GET_HT_FLAG_INDEX(__HANDLE__) |
| Return the current DMA Channel half transfer complete flag. More... | |
| #define | __HAL_DMA_GET_TE_FLAG_INDEX(__HANDLE__) |
| Return the current DMA Channel transfer error flag. More... | |
| #define | __HAL_DMA_GET_GI_FLAG_INDEX(__HANDLE__) |
| Return the current DMA Channel Global interrupt flag. More... | |
| #define | __HAL_DMA_GET_FLAG(__HANDLE__, __FLAG__) (DMA1->ISR & (__FLAG__)) |
| Get the DMA Channel pending flags. More... | |
| #define | __HAL_DMA_CLEAR_FLAG(__HANDLE__, __FLAG__) (DMA1->IFCR = (__FLAG__)) |
| Clear the DMA Channel pending flags. More... | |
Header file of DMA HAL extension module.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
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.


DⒶ Protocols
The Development Protocol Series
The DⒶ protocols are the first, and simplest, protocols made to demonstrate the Ⓐ protocol language and routines that implment it for applications and test suites. They are NOT meant for live use on the open internet. Especially at the simpler levels they lack robust precautions against attackers. Before a protocol is released as an Ⓐ "live" protocol, it should undergo documented testing as a TⒶ protocol*the point of documenting testing is to provide a baseline for future testers to expand on. The testing documentation should be linked as a parent block for the protocol definition. DⒶ might be linked as parent to a TⒶ protocol, but more often the parent of the TⒶ protocol would be another, somewhat less developed protocol that the TⒶ protocol was developed from.
.
DⒶ0 defines four roles: writer client, writer server, reader server and reader client. There are four message types that can be exchanged: write request, write response, read request and read response. The write request merely contains data to be written. The write response tells the time at which the data was written, which becomes a unique key with which to retrieve the record. The read request sends a unique key, and the read response sends back the data associated with that key, or no data if there was any kind of problem. There is no defined error reporting. Any application which intends to interpret and implement generalized Ⓐ protocols can start out by trying out DⒶ0.
DⒶ1 adds identification of the clients. This enables implementation on message passing exchanges like AMQP and MQTT as implemented by RabbitMQ and similar exchanges. Servers listen to all messages on an exchange, and clients can subscribe to a topic that matches their I.D. so they only receive messages of interest to themselves.
DⒶ2 adds identification of a database*Many Ⓐ servers will handle transactions for multiple blockchains.
to write the record into / read it from, segregating records by database id and laying some groundwork for selective service of chosen databases. DⒶ2 also starts adding error and error type reporting.
DⒶ3 adds identification of the protocol in use within each message. While a short name would be sufficient in a "friendly" environment, DⒶ3 adds a hash of the entire protocol definition to prevent confusion in the case of short name collisions between diverse protocol developers.
DⒶ4 adds a query/response for protocols supported by servers. Rather than define optional elements of a given protocol, it is preferred to fully implement a given protocol and define a new protocol lacking any optional element not supported. This way, full protocol definitions can be independently tested / approved and if there are serious problems identified with any protocol, it can be deactivated without complications. Clients wanting to implement a "lite" version of a protocol can define that lite version, and hope they find servers willing to speak that protocol with them*Removing some elements from a protocol can make it less secure, or outright incompatible with blockchain records that require more information. For the most part, the blockchain will define which protocols are acceptable for transactions on that chain.
.
DⒶ5 adds a requirement for read response payload contents to be timestamped and hashed.
DⒶ6 adds a requirement for recorded payloads to include the hash of parent block(s), marking the start of actual "blockchain" operation.
DⒶ7 adds definition of how to include separable items and their hashes.
DⒶ8 adds client id cryptographic signatures to the block to be recorded.
DⒶ9 adds server cryptographic signatures to the blocks retrieved, making communications more traceable / secure. Hobbyist protocols branch off from here.
DⒶ10 adds definition of shares in the blockchain, marking the start of value store operations.
DⒶ11 adds expiration of share value over time - preventing infinitely extending chain records.
DⒶ12 adds definition of a fixed number of "coins" or "tokens" expressing relative ownership of the chain that increases as un-maintained shares expire.
Many more to come.
Assign Onward
14 November 2021
MIT License
Copyright (c) 2021 Assign Onward
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


| Silhouetted by the glare of the first Saturn V launch, a flock of birds calmly conducts its dawn patrol of the lagoon. As the vehicle begins to clear the launch pad, several more seconds will pass before the crashing roar reaches the flock. This is Apollo 4, the first "all up" test of the launch vehicle and spacecraft, proving out their flight compatibility in an unmanned Earth-orbiting mission. |


--- layout: index title: Home permalink: / ---
Welcome.  Collectively, these provide a foundation for understanding and adapting to change.


This program carries out rotations of orientation data (azimuth of dip/ angle of dip or strike/angle of dip/direction of dip) around an arbitrarily oriented rotation axis. The calculation is done with the use of a rotation tensor.(WALLBRECHER, 1986:24ff).
The menu 'data input' is the same as in the program 'calculations. Additionally input can be made from an excel sheet. Manual input is also possible for universal stage data azimuth and tilt angle of axes (i.e. quartz-c-axes) or normals to planes (i.e. poles to miaca-planes). These data are converted to azimuths of dip and angles of dip internally. All further processing of these data is done in this format. The type of data must be set in the menu 'fabric type'. In the menu ‚angle‚ you choose input in the 1..360° or 1..400gon scale.
For data input from a file, the fabric types "U-stage-axes" and "U-stage-poles“ are not active, because U-stage data are saved in *.LIN files.


Step into My Office, is the note and exams sharing web app for high school and college students. Login or Register and join your school and class to begin sharing your past notes, exams, quizzes or homework assignments! You can also chat with other students. Learning is easier when we learn together!


#include <pb_constraint.h>
Definition at line 515 of file pb_constraint.h.
◆ PbConstraints()
| operations_research::sat::PbConstraints::PbConstraints |
( |
Model * |
model | ) |
|
|
inlineexplicit |
◆ ~PbConstraints()
| operations_research::sat::PbConstraints::~PbConstraints |
( |
| ) |
|
|
inlineoverride |
◆ Propagate()
| bool operations_research::sat::PbConstraints::Propagate |
( |
Trail * |
trail | ) |
|
|
finalvirtual |
◆ Untrail()
| void operations_research::sat::PbConstraints::Untrail |
( |
const Trail & |
trail, |
|
|
int |
trail_index |
|
) |
| |
|
finalvirtual |
◆ Reason()
| absl::Span<const Literal> operations_research::sat::PbConstraints::Reason |
( |
const Trail & |
trail, |
|
|
int |
trail_index |
|
) |
| const |
|
finalvirtual |
◆ Resize()
| void operations_research::sat::PbConstraints::Resize |
( |
int |
num_variables | ) |
|
|
inline |
◆ AddConstraint()
| bool operations_research::sat::PbConstraints::AddConstraint |
( |
const std::vector< LiteralWithCoeff > & |
cst, |
|
|
Coefficient |
rhs, |
|
|
Trail * |
trail |
|
) |
| |
◆ AddLearnedConstraint()
| bool operations_research::sat::PbConstraints::AddLearnedConstraint |
( |
const std::vector< LiteralWithCoeff > & |
cst, |
|
|
Coefficient |
rhs, |
|
|
Trail * |
trail |
|
) |
| |
◆ NumberOfConstraints()
| int operations_research::sat::PbConstraints::NumberOfConstraints |
( |
| ) |
const |
|
inline |
◆ ClearConflictingConstraint()
| void operations_research::sat::PbConstraints::ClearConflictingConstraint |
( |
| ) |
|
|
inline |
◆ ConflictingConstraint()
◆ ReasonPbConstraint()
◆ BumpActivity()
◆ RescaleActivities()
| void operations_research::sat::PbConstraints::RescaleActivities |
( |
double |
scaling_factor | ) |
|
◆ UpdateActivityIncrement()
| void operations_research::sat::PbConstraints::UpdateActivityIncrement |
( |
| ) |
|
◆ DeleteConstraint()
| void operations_research::sat::PbConstraints::DeleteConstraint |
( |
int |
index | ) |
|
|
inline |
◆ num_constraint_lookups()
| int64 operations_research::sat::PbConstraints::num_constraint_lookups |
( |
| ) |
const |
|
inline |
◆ num_inspected_constraint_literals()
| int64 operations_research::sat::PbConstraints::num_inspected_constraint_literals |
( |
| ) |
const |
|
inline |
◆ num_threshold_updates()
| int64 operations_research::sat::PbConstraints::num_threshold_updates |
( |
| ) |
const |
|
inline |
The documentation for this class was generated from the following file:


{% extends "base.html" %} {% block content %}
{{ get_entry_translation(entry, locale) }}
{% endfor %}We're stoked you want to try Foundation! To get going, this file (index.html) includes some basic styles you can modify, play around with, or totally destroy to get going.
Once you've exhausted the fun in this document, you should check out:


{% extends "layout.html" %} {% block content %} Withdraw Funds Are you sure you want to withdraw ${{ balance }} The available funds will be transferred to your linked bank account within three business days. This action is irreversible. Your account will be deleted. Confirm {% endblock %}


Program started on Wed, Sep 30 2020 at 4:25 PM.
Analyzed requests from Wed, Apr 29 2020 at 2:55 PM to Wed, Sep 30 2020 at 3:37 PM (154.03 days).
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Figures in parentheses refer to the 7-day period ending Sep 30 2020 at 4:25 PM.
Successful requests: 11,307 (1,358)
Average successful requests per day: 73 (193)
Failed requests: 160 (2)
Redirected requests: 611 (1)
Distinct files requested: 1,216 (8)
Distinct hosts served: 370 (7)
Data transferred: 27.04 megabytes (2.16 megabytes)
Average data transferred per day: 179.76 kilobytes (316.02 kilobytes)
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Each unit () represents 1 request for a page.
| month | #reqs | #pages | |
|---|---|---|---|
| Apr 2020 | 176 | 0 | |
| May 2020 | 1110 | 0 | |
| Jun 2020 | 3744 | 0 | |
| Jul 2020 | 1225 | 0 | |
| Aug 2020 | 1360 | 0 | |
| Sep 2020 | 3692 | 0 |
Busiest month: Apr 2020 (0 requests for pages).
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Each unit () represents 1 request for a page.
| day | #reqs | #pages | |
|---|---|---|---|
| Sun | 2109 | 0 | |
| Mon | 923 | 0 | |
| Tue | 732 | 0 | |
| Wed | 1763 | 0 | |
| Thu | 2542 | 0 | |
| Fri | 982 | 0 | |
| Sat | 2256 | 0 |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Each unit () represents 1 request for a page.
| hour | #reqs | #pages | |
|---|---|---|---|
| 0 | 241 | 0 | |
| 1 | 331 | 0 | |
| 2 | 290 | 0 | |
| 3 | 173 | 0 | |
| 4 | 72 | 0 | |
| 5 | 216 | 0 | |
| 6 | 228 | 0 | |
| 7 | 135 | 0 | |
| 8 | 177 | 0 | |
| 9 | 124 | 0 | |
| 10 | 99 | 0 | |
| 11 | 402 | 0 | |
| 12 | 1481 | 0 | |
| 13 | 1075 | 0 | |
| 14 | 826 | 0 | |
| 15 | 1438 | 0 | |
| 16 | 1134 | 0 | |
| 17 | 607 | 0 | |
| 18 | 281 | 0 | |
| 19 | 543 | 0 | |
| 20 | 399 | 0 | |
| 21 | 360 | 0 | |
| 22 | 500 | 0 | |
| 23 | 175 | 0 |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing domains, sorted by the amount of traffic.
| #reqs | %bytes | domain |
|---|---|---|
| 11307 | 100% | [unresolved numerical addresses] |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing the top 20 organizations by the number of requests, sorted by the number of requests.
| #reqs | %bytes | organization |
|---|---|---|
| 2486 | 20.96% | 5 |
| 1081 | 2.41% | 23 |
| 1048 | 10.39% | 91 |
| 1009 | 5.87% | 89 |
| 915 | 3.55% | 86 |
| 651 | 9.54% | 66.249 |
| 647 | 1.02% | 185.242 |
| 528 | 3.47% | 188.229 |
| 351 | 2.17% | 188.210 |
| 260 | 1.51% | 83 |
| 253 | 0.73% | 193.176 |
| 252 | 2.40% | 80.210 |
| 231 | 1.84% | 77 |
| 225 | 0.72% | 85 |
| 199 | 0.57% | 204.18 |
| 196 | 2.85% | 31 |
| 101 | 1.34% | 37 |
| 95 | 1.65% | 46 |
| 88 | 0.83% | 212.103 |
| 56 | 1.09% | 188.245 |
| 635 | 25.10% | [not listed: 43 organizations] |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing the top 30 referring URLs by the number of redirected requests, sorted by the number of redirected requests.
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing referring URLs, sorted by the number of failed requests.
| #reqs | URL |
|---|---|
| 10 | http://go.iranbaguette.ir/admin |
| 4 | http://go.iranbaguette.ir/admin/index |
| 2 | http://go.iranbaguette.ir/admin/login |
| 2 | http://go.iranbaguette.ir/ |
| 2 | http://baidu.com/ |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing referring sites, sorted by the number of requests.
| #reqs | site |
|---|---|
| 10308 | http://iranbaguette.ir/ |
| 613 | http://go.iranbaguette.ir/ |
| 261 | http://www.iranbaguette.ir/ |
| 20 | http://<IP_ADDRESS>:8000/ |
| 8 | http://iranbaguette.com/ |
| 8 | http://localhost:8000/ |
| 8 | http://mail.iranbaguette.ir/ |
| 2 | http://www.iranbaguette.com/ |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing browsers with at least 1 request for a page, sorted by the number of requests for pages.
| #reqs | #pages | browser |
|---|---|---|
| 11307 | 0 | [not listed: 100 browsers] |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing browsers with at least 1 request for a page, sorted by the number of requests for pages.
| # | #reqs | #pages | browser |
|---|---|---|---|
| 11307 | 0 | [not listed: 9 browsers] |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing operating systems, sorted by the number of requests for pages.
| # | #reqs | #pages | OS |
|---|---|---|---|
| 1 | 788 | 0 | Unix |
| 788 | 0 | Linux | |
| 2 | 3 | 0 | Known robots |
| 3 | 289 | 0 | OS unknown |
| 4 | 102 | 0 | Macintosh |
| 5 | 10125 | 0 | Windows |
| 9664 | 0 | Windows NT | |
| 461 | 0 | Unknown Windows |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing status codes, sorted numerically.
| #reqs | status code |
|---|---|
| 11252 | 200 OK |
| 23 | 206 Partial content |
| 611 | 302 Document found elsewhere |
| 32 | 304 Not modified since last retrieval |
| 160 | 404 Document not found |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
| size | #reqs | %bytes |
|---|---|---|
| 0 | 7779 | |
| 1B- 10B | 5 | |
| 11B- 100B | 37 | 0.01% |
| 101B- 1kB | 1750 | 3.58% |
| 1kB- 10kB | 1284 | 20.95% |
| 10kB-100kB | 451 | 74.55% |
| 100kB- 1MB | 1 | 0.90% |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing extensions with at least 0.1% of the traffic, sorted by the amount of traffic.
| #reqs | %bytes | extension |
|---|---|---|
| 1392 | 45.86% | .js [JavaScript code] |
| 157 | 28.83% | .css [Cascading Style Sheets] |
| 133 | 17.59% | .ogg |
| 9597 | 4.09% | [no extension] |
| 10 | 2.00% | .woff2 |
| 1 | 0.90% | .wav [WAV sound files] |
| 11 | 0.68% | .mp3 [MP3 sound files] |
| 6 | 0.04% | [not listed: 1 extension] |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing directories with at least 0.01% of the traffic, sorted by the amount of traffic.
| #reqs | %bytes | directory |
|---|---|---|
| 1704 | 95.87% | /assets/ |
| 9067 | 2.77% | [root directory] |
| 510 | 1.31% | /admin/ |
| 6 | 0.04% | /uploads/ |
| 20 | 0.01% | [not listed: 1 directory] |
(Go To: Top | General Summary | Monthly Report | Daily Summary | Hourly Summary | Domain Report | Organization Report | Redirected Referrer Report | Failed Referrer Report | Referring Site Report | Browser Report | Browser Summary | Operating System Report | Status Code Report | File Size Report | File Type Report | Directory Report | Request Report)
Listing files with at least 20 requests, sorted by the number of requests.
| #reqs | %bytes | last time | file |
|---|---|---|---|
| 8090 | 0.54% | Sep/30/20 3:37 PM | /update |
| 877 | 2.01% | Sep/30/20 1:03 PM | /live_chat |
| 595 | 16.36% | Sep/30/20 1:03 PM | /assets/js/jquery.validate.min.js |
| 584 | 3.74% | Sep/30/20 1:03 PM | /assets/js/live_chat.min.js |
| 307 | 0.48% | Sep/20/20 12:47 PM | /admin/index/update |
| 193 | 25.13% | Sep/30/20 4:13 AM | /assets/js/jquery.min.js |
| 16 | 2.20% | Sep/16/20 7:50 PM | /assets/js/jquery.min.js?<IP_ADDRESS> |
| 12 | 1.23% | Aug/12/20 5:48 PM | /assets/js/jquery.min.js?<IP_ADDRESS> |
| 145 | 0.49% | Sep/20/20 3:55 PM | /admin/login |
| 127 | 16.70% | Sep/29/20 10:23 AM | /assets/sounds/alert_1.ogg |
| 116 | 27.14% | Sep/29/20 10:23 AM | /assets/css/live_chat.css |
| 63 | 0.11% | Sep/20/20 4:08 PM | /contact_operators |
| 31 | 0.11% | Sep/20/20 11:57 AM | /admin |
| 179 | 7.21% | Sep/24/20 7:02 PM | [not listed: 43 files] |


Description: Change a players gamemode to Survival, Creative, Adventure, or Spectator
Permission: proton.gamemode, proton.gamemode.other
Usage: /gamemode [creative|survival|adventure|spectator] (player)
Aliases: /gm
Example 1: /gamemode creative vexio - Changes Vexio's gamemode to creative
Example 2: /gm s vexio - Changes Vexio's gamemode to survival
Example 3: /gma - Changes the sender's gamemode to adventure
command /gamemode [<text>] [<text="%player%">]: permission: proton.gamemode description: Changes gamemode permission message: {@em} [proton.gamemode] usage: /gamemode [gamemode] (player) aliases: /gm trigger: set {_p} to arg-2 parsed as player if {_p} is online: if arg 1 is not set: send "&cUsage: /gamemode [num] (player)" else if arg 1 is "creative" or "c" or "1": set {_p}'s gamemode to creative send "{@p} Your gamemode has been updated to {<EMAIL_ADDRESS>to {_p} if {_p} isn't sender: send "{@p} {@h}%{_p}%{@t}'s gamemode was updated to {<EMAIL_ADDRESS>to sender else if arg 1 is "survival" or "s" or "0": set {_p}'s gamemode to survival send "{@p} Your gamemode has been updated to {<EMAIL_ADDRESS>to {_p} if {_p} isn't sender: send "{@p} {@h}%{_p}%{@t}'s gamemode was updated to {<EMAIL_ADDRESS>to sender else if arg 1 is "adventure" or "a" or "2": set {_p}'s gamemode to adventure send "{@p} Your gamemode has been updated to {<EMAIL_ADDRESS>to {_p} if {_p} isn't sender: send "{@p} {@h}%{_p}%{@t}'s gamemode was updated to {<EMAIL_ADDRESS>to sender else if arg 1 is "spectator" or "sp" or "3" or "spec": set {_p}'s gamemode to spectator send "{@p} Your gamemode has been updated to {<EMAIL_ADDRESS>to {_p} if {_p} isn't sender: send "{@p} {@h}%{_p}%{@t}'s gamemode was updated to {<EMAIL_ADDRESS>to sender else: send "{@a} Invalid Argument." send "&cUsage: /gamemode &m%arg-1%&c (player)" else: send "{@a} Player is not online." send "&cUsage: /gamemode %arg-1% &m%arg-2%"
Usage: /fly (player)
Aliases: None
Example 1: /fly vexio - Toggles flight mode for Vexio
Example 2: /fly - Toggles flight mode for the sender
command /fly [<text="%player%">]: permission: proton.fly description: Toggles flight permission message: {@em} [proton.fly] usage: /fly (player) trigger: set {_p} to arg-1 parsed as player if {_p} is online: if {proton.fly::%{_p}%} is true: delete {proton.fly::%{_p}%} set {_p}'s fly mode to false send "{@p} Flight mode {<EMAIL_ADDRESS>to {_p} if arg 1 isn't sender: send "{@p} {@h}%{_p}%{@t}'s flight mode was {<EMAIL_ADDRESS>to sender else: set {proton.fly::%{_p}%} to true set {_p}'s fly mode to true send "{@p} Flight mode {<EMAIL_ADDRESS>to {_p} if arg 1 isn't sender: send "{@p} {@h}%{_p}%{@t}'s flight mode was {<EMAIL_ADDRESS>to sender else: send "{@a} Player is not online." send "&cUsage: /fly &m%arg-1%"
Usage: /tp [player] (player)
Aliases: None
Example 1: /tp vexio vxo - Teleports Vexio to vxo
Example 2: /tp vxo - Teleports the sender to vxo
command /tp [<player>] [<player>]: permission: proton.tp description: Teleports to player permission message: {@em} [proton.tp] usage: /tp [player] (player) trigger: if arg 1 is not set: send "&cUsage: /tp [player] (player)" else if arg 1 is set: if arg 2 is not set: if {proton.teleporting::%sender%} is true: send "{@a} &cPlayer is already being teleported" stop else: set {proton.teleporting::%sender%} to true set {proton.lastLoc::%sender%} to sender's location teleport sender to arg-1 send "{@p} Teleported to {<EMAIL_ADDRESS>to sender wait 1 second delete {proton.teleporting::%sender%} else: if {proton.teleporting::%arg-1%} is true: send "&c&oPlayer is already being teleported" stop else: set {proton.teleporting::%arg-1%} to true set {proton.lastLoc::%arg-1%} to arg-1's location teleport arg-1 to arg-2 send "{@p} Teleported {@h}%arg-1%{@t} to {@t}%arg-2%{@t}" to sender send "{@p} Teleported to {<EMAIL_ADDRESS>to arg-1 wait 1 second delete {proton.teleporting::%arg-1%}
Usage: /tphere [player]
Aliases: /s
Example 1: /tphere vxo - Teleports vxo to the sender
Example 2: /s vxo - Teleports vxo to the sender
command /tphere [<player>]: permission: proton.tphere description: Teleports a player to sender permission message: {@em} [proton.tphere] usage: /tphere [player] aliases: /s trigger: if arg 1 is not set: send "&cUsage: /tphere [player]" else: make player execute command "/tp %arg 1% %sender%"
Usage: /tpall
Aliases: None
Example 1: /tpall - Teleports all players to the sender
command /tpall: permission: proton.tpall description: Teleports all players to sender permission message: {@em} usage: /tpall trigger: set {_loc} to sender's location set {_count} to 0 set {_countTotal} to 0 set {_total} to number of all players loop all players: teleport loop-player to sender's location add 1 to {_count} add 1 to {_countTotal} if {_count} = 20: set {_count} to 0 send "{@p} Sent %{_countTotal}% people. Next group in {@h}3s{@t}. &8[&e%{_countTotal}%&7/&e%{_total}%&8]" wait 3 seconds delete {_loc} send "{@p} Teleported all players to your location" broadcast "{@p} Teleported to {<EMAIL_ADDRESS>Description: Teleports to specified coordinates
Permission: proton.tpcoords
Usage: /tpcoords [x] [y] [z]
Aliases: /tppos
Example 1: /tpcoords 100 63 -125 - Teleports the sender to X=100, Y=63, Z=-125
command /tpcoords [<integer>] [<integer>] [<integer>]: permission: proton.tpcoords aliases: /tppos permission message: {@em} [proton.tpcoords] usage: /tpcoords [x] [y] [z] trigger: if arg 1 is not set: send "&cUsage: /tpcoords [x] [y] [z]" else if arg 1 is set: if arg 2 is set: if arg 3 is set: if {proton.teleporting::%arg-1%} is true: send "{@a} &cPlayer is already being teleported" stop else: set {_x} to arg-1 set {_z} to arg-3 add 0.5 to {_x} add 0.5 to {_z} set {proton.teleporting::%arg-1%} to true set {proton.lastLoc::%sender%} to sender's location set {_world} to sender's world set {_loc} to location({_x}, arg-2, {_z}, {_world}) teleport sender to {_loc} send "{@p} Teleported to {@h}%{_x}%, %arg-2%<EMAIL_ADDRESS>wait 1 second delete {proton.teleporting::%arg-1%} else: send "{@a} Invalid Argument." send "&cUsage: /tpcoords [x] [y] [z]" else: send "{@a} Invalid Argument." send "&cUsage: /tpcoords [x] [y] [z]"
Usage: /sethome
Aliases: None
Example 1: /sethome - Sets the sender's home location to where the sender is standing
command /sethome: permission: proton.sethome permission message: {@em} [proton.sethome] usage: /sethome trigger: set {proton.home::%sender's uuid%} to sender's location set {_x} to sender's x-coordinate set {_y} to sender's y-coordinate set {_z} to sender's z-coordinate send "{@p} Home set at {@h}%{_x}%, %{_y}%<EMAIL_ADDRESS>Usage: /home
Aliases: None
Example 1: /home - Teleports the sender to their home
command /home: permission: proton.home permission message: {@em} [proton.home] usage: /home trigger: if {proton.home::%sender's uuid%} is set: if {proton.teleporting::%sender%} is true: send "{@a} &cPlayer is already being teleported" stop else: set {proton.teleporting::%sender%} to true set {proton.lastLoc::%sender%} to sender's location teleport sender to {proton.home::%sender's uuid%} send "{@p} Teleported to your home location." wait 1 second delete {proton.teleporting::%sender%} else: send "{@a} &cYou do not have a home set." send "&cUsage: /sethome"
Description: Sets the server's spawn location to the sender's location
Permission: proton.setspawn
Usage: /setspawn
Aliases: /spawnset
Example 1: /setspawn - Sets the spawn location to the sender's location
command /setspawn: permission: proton.setspawn permission message: {@em} [proton.setspawn] usage: /setspawn trigger: set {proton.spawn} to sender's location set {_x} to sender's x-coordinate set {_y} to sender's y-coordinate set {_z} to sender's z-coordinate send "{@p} Spawn location set to {@h}%{_x}%, %{_y}%, %{_z}%{@t}."


|
| void | VehicleCharacterEvent__DelegateSignature (class UVehicleSeatComponent *Seat, class AOakCharacter *Character) |
| |
| void | UnlockWorldTravel (const struct FName &Reason) |
| |
| void | TestTeleportFailSafeLocation () |
| |
| void | TeleportVehicle (const struct FVector &Location, const struct FRotator &Rotation) |
| |
| void | StopZooming (bool bForcedStop) |
| |
| void | StopUsingWeapon (class UWeaponSlotData *Slot, unsigned char InputChannel) |
| |
| void | StopUsingSecondaryWeapons () |
| |
| void | StopUsingSecondarySeatWeapon () |
| |
| void | StopUsingPrimaryWeapons (unsigned char InputChannel) |
| |
| void | StopReload (class UWeaponSlotData *Slot) |
| |
| void | StopHover () |
| |
| void | StopHornSequence () |
| |
| void | StopHorn () |
| |
| void | StopFeedbackOnOccupants (class UFeedbackData *FeedbackData, bool bOnlyLocalPlayers) |
| |
| void | StopEffects (EVehicleEffectEvent EffectType) |
| |
| void | StopEBrakeFeedback () |
| |
| void | StopEBrake (bool bTriggerPowerSlide) |
| |
| void | StopBoost (bool bForce) |
| |
| void | StartZooming () |
| |
| void | StartUsingWeapon (class UWeaponSlotData *Slot, unsigned char InputChannel) |
| |
| void | StartUsingSecondaryWeapons () |
| |
| bool | StartUsingSecondarySeatWeapon () |
| |
| void | StartUsingPrimaryWeapons (unsigned char InputChannel) |
| |
| void | StartHover () |
| |
| void | StartHornSequence (TArray< struct FHornSequenceEntry > HornSequenceIn) |
| |
| void | StartHorn () |
| |
| void | StartEBrake (bool bTriggerPowerSlide) |
| |
| void | StartBoost () |
| |
| void | SetVehicleSpawnByCatchARideOwner (class AActor *NewCAROwner) |
| |
| void | SetVehicleDisable (bool bDisable, bool bEvictOccupant) |
| |
| void | SetThrottleInput (float Throttle) |
| |
| void | SetSteeringInput (float Steering) |
| |
| void | SetNavPainterLayerEnabled (ENavPainterLayer Layer, bool bEnable) |
| |
| void | SetLockSeatForPlayers (bool bIsSeatLock) |
| |
| void | SetInSiegeMode (bool bWantedInSiegeMode) |
| |
| void | SetHoverInput (const struct FVector &WantedInput) |
| |
| void | SetHijackProtectionEnabled (bool bEnable) |
| |
| void | SetHandbrake (bool bHandBrake) |
| |
| void | SetDrivingInputDisabled (bool bDrivingInputDisabled) |
| |
| void | SetDead (EVehicleDeathType InDeathType) |
| |
| void | SetBoost (bool bBoosting) |
| |
| void | SetAirControlInput (float PitchInput, float RollInput) |
| |
| void | SetAIPathFindingData (class UHavokPathFindingData *PathFindingData) |
| |
| void | ServerStopEBrake (bool bTriggerPowerSlide) |
| |
| void | ServerStartEBrake (bool bTriggerPowerSlide) |
| |
| void | ResetAIPathFindingData () |
| |
| void | Reload (class UWeaponSlotData *Slot) |
| |
| void | RegisterSeatComponent (class UVehicleSeatComponent *SeatComponent) |
| |
| void | ReceiveOnVehicleDestroyWithPlayerIn (class UVehicleSeatComponent *Seat, class AOakCharacter *Character) |
| |
| void | ReceiveOnPlayerHijacksVehicle (class UVehicleSeatComponent *Seat, class AOakCharacter *Character) |
| |
| void | ReceiveOnPlayerExitsVehicle (class UVehicleSeatComponent *Seat, class AOakCharacter *Character) |
| |
| void | ReceiveOnPlayerEntersVehicle (class UVehicleSeatComponent *Seat, class AOakCharacter *Character) |
| |
| void | ReceiveOnExitVehicleStarted (class UVehicleSeatComponent *Seat, class AOakCharacter *Character) |
| |
| void | ReceiveOnExitVehicle (class UVehicleSeatComponent *Seat, class AOakCharacter *Character) |
| |
| void | ReceiveOnEnterVehicle (class UVehicleSeatComponent *Seat, class AOakCharacter *Character) |
| |
| void | PlayEffects (EVehicleEffectEvent EffectType) |
| |
| void | PerformFeedbackOnOccupants (class UFeedbackData *FeedbackData, float Scale, bool bLoop, bool bOnlyLocalPlayers) |
| |
| void | OnScanningSuccess () |
| |
| void | OnScanningStarted () |
| |
| void | OnScanningCancelled () |
| |
| void | OnRep_VehicleTeamCollisionChannel () |
| |
| void | OnRep_SpawnByCatchARide () |
| |
| void | OnRep_Seats () |
| |
| void | OnRep_IsEBraking () |
| |
| void | OnRep_HealthState () |
| |
| void | OnRep_DrivingInputDisabled () |
| |
| void | OnRep_Color () |
| |
| void | OnReceivedElementalEffect (class AActor *Receiver, const struct FStatusEffectSpec &Spec, EOakElementalType ElementalType) |
| |
| void | OnPrimaryOccupantLevelChange (int OldExperienceLevel, int NewExperienceLevel) |
| |
| void | OnLanded (float TimeSpentInAir, float LandAngle, int NumWheelsOnGround, bool bAllWheelsLanded) |
| |
| void | OnHijackProtectionTriggeredSignature__DelegateSignature (class AController *Hijacker, class UVehicleSeatComponent *HijackedSeat) |
| |
| void | OnHealthResourceDepleted (class UDamageComponent *DamageReceiver, class UDamageCauserComponent *DamageCauser) |
| |
| void | OnGearShifted (int Gear, bool bIsUpShifting) |
| |
| void | OnDriverAttachStateChanged () |
| |
| void | OnBoostEnd () |
| |
| void | OnBecameAirborn () |
| |
| void | OakVehicleHornEvent__DelegateSignature () |
| |
| void | OakVehicleGearShiftEvent__DelegateSignature (int Gear, bool bIsShiftingUp) |
| |
| void | OakVehicleEvent__DelegateSignature () |
| |
| void | OakVehicleBoostComponentChangedEvent__DelegateSignature (class UOakVehicleBoostComponent *Current, class UOakVehicleBoostComponent *Previous) |
| |
| void | LockWorldTravel (const struct FName &Reason) |
| |
| void | LockAllSeat (bool bLock) |
| |
| void | K2_OnEBrakeReleased () |
| |
| void | K2_OnEBrakePressed () |
| |
| void | K2_InitializeSeats () |
| |
| bool | IsWorldTravelLocked () |
| |
| bool | IsVehicleScannable () |
| |
| bool | IsVehicleOwnedSolelyBy (class AActor *Actor) |
| |
| bool | IsVehicleOwnedByPlayer () |
| |
| bool | IsVehicleOwnedBy (class AActor *Actor) |
| |
| bool | IsVehicleOwned () |
| |
| bool | IsVehicleOccupant (class APawn *Occupant, bool bIncludeDetaching) |
| |
| bool | IsPrimarySeatOccupied (bool bIncludeDetaching) |
| |
| bool | IsPreviewModel () |
| |
| bool | IsPhysicsDisabled () |
| |
| bool | IsPartEquipped (TSoftObjectPtr< class UVehiclePartData > PartData) |
| |
| bool | IsInSiegeMode () |
| |
| bool | IsInPowerSlideBoost () |
| |
| bool | IsHovering () |
| |
| bool | IsEBraking () |
| |
| bool | IsDrivingInputDisabled () |
| |
| bool | IsDrifting () |
| |
| bool | IsDigiThrusting () |
| |
| bool | IsControllerInVehicle (class AController *ControllerToCheck) |
| |
| bool | IsBraking () |
| |
| bool | IsBoosting () |
| |
| void | InterpolateToGround (float InterpolationSpeed) |
| |
| void | IgnoreVehicleCollision (class AActor *TargetToIgnore, bool AllChilds) |
| |
| bool | HasShieldEquipped () |
| |
| bool | HasPlayerOccupants () |
| |
| bool | HasOccupants (bool bIncludeDetaching) |
| |
| bool | HasHealthOfType (class UHealthTypeData *HealthTypeToFind) |
| |
| bool | HasFriendySeatReserved () |
| |
| bool | HasAnyDuelingOccupants () |
| |
| class AWeapon * | GetVehicleWeapon (class UWeaponSlotData *WantedSlot) |
| |
| float | GetThrottleInput () |
| |
| TEnumAsByte< ETeamAttitude > | GetTeamAttitudeTowardsActor (class AActor *Actor) |
| |
| struct FVector | GetTargetActorLocation () |
| |
| float | GetSteeringInput () |
| |
| float | GetSpeedInMPH () |
| |
| float | GetSpeedInKPH () |
| |
| class AVehicleSeatPawn * | GetSecondaryWeaponSeatPawn (bool bMustBeUnoccupied) |
| |
| struct FRotator | GetSeatWeaponRotation (int Slot, bool bWorldSpace) |
| |
| class APawn * | GetSeatOccupant (int SeatSlot, bool bIncludeDetaching) |
| |
| int | GetSeatCountUse () |
| |
| int | GetSeatCount () |
| |
| class UVehicleSeatComponent * | GetSeatComponent (int Slot) |
| |
| struct FRotator | GetRotationDelta () |
| |
| class APawn * | GetPrimaryOccupant (bool bIncludeDetaching) |
| |
| float | GetPlanarSpeedInMPH () |
| |
| int | GetOccupantSeatSlot (class APawn *Occupant, bool bIncludeDetaching) |
| |
| class UVehicleSeatComponent * | GetOccupantSeat (class APawn *Occupant, bool bIncludeDetaching) |
| |
| class UOakDamageComponent * | GetOakDamageComponent () |
| |
| class AOakAIController * | GetOakAIController () |
| |
| float | GetMass () |
| |
| struct FVector | GetLastFrameVelocity () |
| |
| struct FVector | GetGroundAjustement () |
| |
| int | GetGearsCount () |
| |
| bool | GetFirstHealthInformationByType (class UHealthTypeData *HealthTypeToFind, struct FHealthType *OutHealthType) |
| |
| TArray< class UVehicleSeatComponent * > | GetAvailableSeatsForPlayers () |
| |
| TArray< class APawn * > | GetAllOccupants (bool bIncludeDetaching) |
| |
| class AWeapon * | GetActiveWeapon (unsigned char Slot) |
| |
| void | FlipOver (class AActor *AwayFromActor) |
| |
| class UVehicleSeatComponent * | FindNearestSeatComponent (class AActor *SearchActor, float MaxDistance, bool bIsHostile, bool bSearchNearestSeat) |
| |
| void | EnableVehiclePhysics (const struct FName &Reason) |
| |
| void | EnableTransitionControl (bool bEnable) |
| |
| void | EnableDoorTeleportFailSafe (const struct FVector &Offset, float TestDelay) |
| |
| void | EnableAIUseSlot (bool bEnable) |
| |
| void | EjectOccupants (bool bKillOccupants, bool bForceResurrectKilledPlayers, bool bInstantKill, bool bFellOutOfWorld, bool bInstantDetach) |
| |
| void | DisableVehiclePhysics (const struct FName &Reason) |
| |
| void | DigistructOutTeleport () |
| |
| void | DigistructOutEffectOnly () |
| |
| void | DigistructIn () |
| |
| void | DebugBraking () |
| |
| void | DamageReaction_DetachBreakable (const struct FDamageReactionEventSummary &Summary) |
| |
| void | ClientVehicleSpawnedFromCatchARide () |
| |
| void | ClearNavPainterLayer (ENavPainterLayer Layer) |
| |
| void | ClearInputWithFilter (TEnumAsByte< EClearInputFilter > Filter) |
| |
| void | ClearAllInput () |
| |
| bool | CanVehicleBeControlled () |
| |
| bool | CanHover () |
| |
| bool | CanDrive () |
| |
| bool | CanBeFlippedOver (bool bMustBeUnoccupied) |
| |
| void | BroadcastHornStoppedEvent () |
| |
| void | BroadcastHornStartedEvent () |
| |
| void | BlendedRPMAttenuation () |
| |
| void | BeforeVehicleDestroyedEvent (EVehicleDeathType VehicleDeathType) |
| |
| void | AddVehicleForce (const struct FVector &ForceToAdd, const struct FName &ForceSource) |
| |
| void | AddImpulseFromMelee (float ImpulseStrength, float UpRatio, class AController *InstigatedBy) |
| |
| void | SetTeam (class UTeam *Team) |
| |
| void | RemoveVehiclePart (class UVehiclePartData *CharacterPart) |
| |
| void | OnRep_VehicleParts () |
| |
| bool | IsPowerSliding () |
| |
| bool | IsInAir () |
| |
| class UTeamComponent * | GetTeamComponent () |
| |
| class UTeam * | GetTeam () |
| |
| class UTargetingComponent * | GetTargetingComponent () |
| |
| class UTargetableComponent * | GetTargetableComponent () |
| |
| int | GetNumWheelsInAir () |
| |
| TArray< class UVehiclePartData * > | GetEquipedParts () |
| |
| void | AddVehiclePart (class UVehiclePartData *CharacterPart) |
| |
| void | SpawnDefaultController () |
| |
| void | SetCanAffectNavigationGeneration (bool bNewValue, bool bForceUpdate) |
| |
| void | ReceiveUnpossessed (class AController *OldController) |
| |
| void | ReceivePossessed (class AController *NewController) |
| |
| void | PawnMakeNoise (float Loudness, const struct FVector &NoiseLocation, bool bUseNoiseMakerLocation, class AActor *NoiseMaker) |
| |
| void | OnRep_PlayerState () |
| |
| void | OnRep_Controller () |
| |
| void | LaunchPawn (const struct FVector &LaunchVelocity, bool bXYOverride, bool bZOverride) |
| |
| struct FVector | K2_GetMovementInputVector () |
| |
| bool | IsPlayerControlled () |
| |
| bool | IsMoveInputIgnored () |
| |
| bool | IsLocallyControlled () |
| |
| bool | IsControlled () |
| |
| struct FVector | GetPendingMovementInputVector () |
| |
| struct FVector | GetNavAgentLocation () |
| |
| class UPawnMovementComponent * | GetMovementComponent () |
| |
| struct FVector | GetLastMovementInputVector () |
| |
| struct FRotator | GetControlRotation () |
| |
| class AController * | GetController () |
| |
| struct FRotator | GetBaseAimRotation () |
| |
| void | DetachFromControllerPendingDestroy () |
| |
| struct FVector | ConsumeMovementInputVector () |
| |
| void | AddMovementInput (const struct FVector &WorldDirection, float ScaleValue, bool bForce) |
| |
| void | AddControllerYawInput (float Val) |
| |
| void | AddControllerRollInput (float Val) |
| |
| void | AddControllerPitchInput (float Val) |
| |
| bool | WasRecentlyRendered (float Tolerance) |
| |
| void | UserConstructionScript () |
| |
| void | TearOff () |
| |
| void | SnapRootComponentTo (class AActor *InParentActor, const struct FName &InSocketName) |
| |
| void | SetTickGroup (TEnumAsByte< ETickingGroup > NewTickGroup) |
| |
| void | SetTickableWhenPaused (bool bTickableWhenPaused) |
| |
| void | SetReplicates (bool bInReplicates) |
| |
| void | SetReplicateMovement (bool bInReplicateMovement) |
| |
| void | SetOwner (class AActor *NewOwner) |
| |
| void | SetOnlyRelevantToOwner (bool bNewOnlyRelevantToOwner) |
| |
| void | SetNetUseOwnerRelevancy (bool bNewNetUseOwnerRelevancy) |
| |
| void | SetNetUpdateFrequency (float NewFrequency, float NewMinFrequency) |
| |
| void | SetNetDormancy (TEnumAsByte< ENetDormancy > NewDormancy) |
| |
| void | SetLifeSpan (float InLifespan) |
| |
| void | SetAlwaysRelevant (bool bNewAlwaysRelevant) |
| |
| void | SetActorTickInterval (float TickInterval) |
| |
| void | SetActorTickEnabled (bool bEnabled) |
| |
| void | SetActorScale3D (const struct FVector &NewScale3D) |
| |
| void | SetActorRelativeScale3D (const struct FVector &NewRelativeScale) |
| |
| void | SetActorHiddenInGame (bool bNewHidden) |
| |
| void | SetActorEnableCollision (bool bNewActorEnableCollision) |
| |
| void | RemoveTickPrerequisiteComponent (class UActorComponent *PrerequisiteComponent) |
| |
| void | RemoveTickPrerequisiteActor (class AActor *PrerequisiteActor) |
| |
| void | ReceiveTick (float DeltaSeconds) |
| |
| void | ReceiveRadialDamage (float DamageReceived, class UDamageType *DamageType, const struct FVector &Origin, const struct FHitResult &HitInfo, class AController *InstigatedBy, class AActor *DamageCauser) |
| |
| void | ReceivePointDamage (float Damage, class UDamageType *DamageType, const struct FVector &HitLocation, const struct FVector &HitNormal, class UPrimitiveComponent *HitComponent, const struct FName &BoneName, const struct FVector &ShotFromDirection, class AController *InstigatedBy, class AActor *DamageCauser, const struct FHitResult &HitInfo) |
| |
| void | ReceiveHit (class UPrimitiveComponent *MyComp, class AActor *Other, class UPrimitiveComponent *OtherComp, bool bSelfMoved, const struct FVector &HitLocation, const struct FVector &HitNormal, const struct FVector &NormalImpulse, const struct FHitResult &Hit) |
| |
| void | ReceiveEndPlay (TEnumAsByte< EEndPlayReason > EndPlayReason) |
| |
| void | ReceiveDestroyed () |
| |
| void | ReceiveBeginPlay () |
| |
| void | ReceiveAnyDamage (float Damage, class UDamageType *DamageType, class AController *InstigatedBy, class AActor *DamageCauser) |
| |
| void | ReceiveActorOnReleased (const struct FKey &ButtonReleased) |
| |
| void | ReceiveActorOnInputTouchLeave (TEnumAsByte< ETouchIndex > FingerIndex) |
| |
| void | ReceiveActorOnInputTouchEnter (TEnumAsByte< ETouchIndex > FingerIndex) |
| |
| void | ReceiveActorOnInputTouchEnd (TEnumAsByte< ETouchIndex > FingerIndex) |
| |
| void | ReceiveActorOnInputTouchBegin (TEnumAsByte< ETouchIndex > FingerIndex) |
| |
| void | ReceiveActorOnClicked (const struct FKey &ButtonPressed) |
| |
| void | ReceiveActorEndOverlap (class AActor *OtherActor) |
| |
| void | ReceiveActorEndCursorOver () |
| |
| void | ReceiveActorBeginOverlap (class AActor *OtherActor) |
| |
| void | ReceiveActorBeginCursorOver () |
| |
| void | PrestreamTextures (float Seconds, bool bEnableStreaming, int CinematicTextureGroups) |
| |
| void | OnRep_ReplicateMovement () |
| |
| void | OnRep_ReplicatedMovement () |
| |
| void | OnRep_Owner () |
| |
| void | OnRep_Instigator () |
| |
| void | OnRep_AttachmentReplication () |
| |
| void | MakeNoise (float Loudness, class APawn *NoiseInstigator, const struct FVector &NoiseLocation, float MaxRange, const struct FName &Tag) |
| |
| class UMaterialInstanceDynamic * | MakeMIDForMaterial (class UMaterialInterface *Parent) |
| |
| bool | K2_TeleportTo (const struct FVector &DestLocation, const struct FRotator &DestRotation) |
| |
| bool | K2_SetActorTransform (const struct FTransform &NewTransform, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| bool | K2_SetActorRotation (const struct FRotator &NewRotation, bool bTeleportPhysics) |
| |
| void | K2_SetActorRelativeTransform (const struct FTransform &NewRelativeTransform, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| void | K2_SetActorRelativeRotation (const struct FRotator &NewRelativeRotation, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| void | K2_SetActorRelativeLocation (const struct FVector &NewRelativeLocation, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| bool | K2_SetActorLocationAndRotation (const struct FVector &NewLocation, const struct FRotator &NewRotation, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| bool | K2_SetActorLocation (const struct FVector &NewLocation, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| void | K2_OnReset () |
| |
| void | K2_OnEndViewTarget (class APlayerController *PC) |
| |
| void | K2_OnBecomeViewTarget (class APlayerController *PC) |
| |
| class USceneComponent * | K2_GetRootComponent () |
| |
| struct FRotator | K2_GetActorRotation () |
| |
| struct FVector | K2_GetActorLocation () |
| |
| void | K2_DetachFromActor (EDetachmentRule LocationRule, EDetachmentRule RotationRule, EDetachmentRule ScaleRule) |
| |
| void | K2_DestroyComponent (class UActorComponent *Component) |
| |
| void | K2_DestroyActor_DEPRECATED () |
| |
| void | K2_AttachToComponent (class USceneComponent *Parent, const struct FName &SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies) |
| |
| void | K2_AttachToActor (class AActor *ParentActor, const struct FName &SocketName, EAttachmentRule LocationRule, EAttachmentRule RotationRule, EAttachmentRule ScaleRule, bool bWeldSimulatedBodies) |
| |
| void | K2_AttachRootComponentToActor (class AActor *InParentActor, const struct FName &InSocketName, TEnumAsByte< EAttachLocation > AttachLocationType, bool bWeldSimulatedBodies) |
| |
| void | K2_AttachRootComponentTo (class USceneComponent *InParent, const struct FName &InSocketName, TEnumAsByte< EAttachLocation > AttachLocationType, bool bWeldSimulatedBodies) |
| |
| void | K2_AddActorWorldTransform (const struct FTransform &DeltaTransform, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| void | K2_AddActorWorldRotation (const struct FRotator &DeltaRotation, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| void | K2_AddActorWorldOffset (const struct FVector &DeltaLocation, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| void | K2_AddActorLocalTransform (const struct FTransform &NewTransform, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| void | K2_AddActorLocalRotation (const struct FRotator &DeltaRotation, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| void | K2_AddActorLocalOffset (const struct FVector &DeltaLocation, bool bSweep, bool bTeleport, struct FHitResult *SweepHitResult) |
| |
| bool | IsOverlappingActor (class AActor *Other) |
| |
| bool | IsChildActor () |
| |
| bool | IsActorTickEnabled () |
| |
| bool | IsActorBeingDestroyed () |
| |
| bool | HasAuthority () |
| |
| float | GetVerticalDistanceTo (class AActor *OtherActor) |
| |
| struct FVector | GetVelocity () |
| |
| struct FTransform | GetTransform () |
| |
| bool | GetTickableWhenPaused () |
| |
| float | GetSquaredDistanceTo (class AActor *OtherActor) |
| |
| TEnumAsByte< ENetRole > | GetRemoteRole () |
| |
| class UChildActorComponent * | GetParentComponent () |
| |
| class AActor * | GetParentActor () |
| |
| class AActor * | GetOwner () |
| |
| void | GetOverlappingComponents (TArray< class UPrimitiveComponent * > *OverlappingComponents) |
| |
| void | GetOverlappingActors (class UClass *ClassFilter, TArray< class AActor * > *OverlappingActors) |
| |
| TEnumAsByte< ENetRole > | GetLocalRole () |
| |
| float | GetLifeSpan () |
| |
| class AController * | GetInstigatorController () |
| |
| class APawn * | GetInstigator () |
| |
| struct FVector | GetInputVectorAxisValue (const struct FKey &InputAxisKey) |
| |
| float | GetInputAxisValue (const struct FName &InputAxisName) |
| |
| float | GetInputAxisKeyValue (const struct FKey &InputAxisKey) |
| |
| float | GetHorizontalDotProductTo (class AActor *OtherActor) |
| |
| float | GetHorizontalDistanceTo (class AActor *OtherActor) |
| |
| float | GetGameTimeSinceCreation () |
| |
| float | GetDotProductTo (class AActor *OtherActor) |
| |
| float | GetDistanceTo (class AActor *OtherActor) |
| |
| TArray< class UActorComponent * > | GetComponentsByTag (class UClass *ComponentClass, const struct FName &Tag) |
| |
| TArray< class UActorComponent * > | GetComponentsByClass (class UClass *ComponentClass) |
| |
| class UActorComponent * | GetComponentByTag (class UClass *ComponentClass, const struct FName &Tag) |
| |
| class UActorComponent * | GetComponentByClass (class UClass *ComponentClass) |
| |
| struct FName | GetAttachParentSocketName () |
| |
| class AActor * | GetAttachParentActor () |
| |
| void | GetAttachedActors (TArray< class AActor * > *OutActors) |
| |
| class APawn * | GetAssociatedVehicle () |
| |
| class APlayerState * | GetAssociatedPlayerState () |
| |
| class APlayerController * | GetAssociatedPlayerController () |
| |
| class APawn * | GetAssociatedPawn () |
| |
| class AController * | GetAssociatedController () |
| |
| class ACharacter * | GetAssociatedCharacter () |
| |
| void | GetAllChildActors (bool bIncludeDescendants, TArray< class AActor * > *ChildActors) |
| |
| struct FVector | GetActorUpVector () |
| |
| float | GetActorTimeDilation () |
| |
| float | GetActorTickInterval () |
| |
| struct FVector | GetActorScale3D () |
| |
| struct FVector | GetActorRightVector () |
| |
| struct FVector | GetActorRelativeScale3D () |
| |
| struct FVector | GetActorForwardVector () |
| |
| void | GetActorEyesViewPoint (struct FVector *OutLocation, struct FRotator *OutRotation) |
| |
| bool | GetActorEnableCollision () |
| |
| void | GetActorBounds (bool bOnlyCollidingComponents, struct FVector *Origin, struct FVector *BoxExtent) |
| |
| void | GetActorAimViewPoint (struct FVector *OutLocation, struct FRotator *OutRotation) |
| |
| void | GbxDestroyActor (bool bDestroyImmediately) |
| |
| void | ForceNetUpdate () |
| |
| void | FlushNetDormancy () |
| |
| class USceneComponent * | FindAttachComponent (const struct FName &SocketName, bool bForegroundLayer) |
| |
| void | EnableInput (class APlayerController *PlayerController) |
| |
| void | DisableInput (class APlayerController *PlayerController) |
| |
| void | DetachRootComponentFromParent (bool bMaintainWorldPosition) |
| |
| void | AddTickPrerequisiteComponent (class UActorComponent *PrerequisiteComponent) |
| |
| void | AddTickPrerequisiteActor (class AActor *PrerequisiteActor) |
| |
| class UActorComponent * | AddComponent (const struct FName &TemplateName, bool bManualAttachment, const struct FTransform &RelativeTransform, class UObject *ComponentTemplateContext) |
| |
| void | ActorPostBeginPlaySignature__DelegateSignature () |
| |
| bool | ActorHasTag (const struct FName &Tag) |
| |
| std::string | GetName () const |
| |
| std::string | GetFullName () const |
| |
| bool | IsA (UClass *cmp) const |
| |
| void | ProcessEvent (class UFunction *function, void *parms) |
| |
| void | ExecuteUbergraph (int EntryPoint) |
| |


Poll: Overwhelming majority of Australians want policing of social media
by Colin BrinsdenAlmost three quarters of Australians want tighter controls surrounding political advertising on social media platforms as a new report found current regulation is “grossly inadequate”.
A survey by Essential Research found 73 per cent of respondents support requiring social media platforms to ensure political ads are factual, while 70 per cent believe platforms should be required to confirm the organisations advertising are registered locally.
The figures were released as part of a report by the Australia Institute on the impact of social media on the 2019 election.
It found misinformation on social media was rife and the absence of blackouts increased its influence in the final days of the campaign.
The report by the institute’s Centre for Responsible Technology found the regulation over social media during elections is grossly inadequate.
Centre director Peter Lewis said the report, backed by public research, suggest the time has come to regulate social media during elections.
“This report shows that election regulations have not kept pace with technological change and the big social media platforms are currently operating as a law unto themselves,” Mr Lewis said.
“The experience across western democracy is that the way these online platforms are operating is driving division, amplifying discord and abrogating any responsibility to ensure political advertisements are true.”
-AAP


The Foreign Function Interface (FFI) has two purposes: it enables (1) to describe in Haskell the interface to foreign language functionality and (2) to use from foreign code Haskell routines. More generally, its aim is to support the implementation of programs in a mixture of Haskell and other languages such that the source code is portable across different implementations of Haskell and non-Haskell systems as well as independent of the architecture and operating system.
The Haskell FFI currently only specifies the interaction between Haskell code and foreign code that follows the C calling convention. However, the design of the FFI is such that it enables the modular extension of the present definition to include the calling conventions of other programming languages, such as C++ and Java. A precise definition of the support for those languages is expected to be included in later versions of the language. The second major omission is the definition of the interaction with multithreading in the foreign language and, in particular, the treatment of thread-local state, and so these details are currently implementation-defined.
The core of the present specification is independent of the foreign language that is used in conjunction with Haskell. However, there are two areas where FFI specifications must become language specific: (1) the specification of external names and (2) the marshalling of the basic types of a foreign language. As an example of the former, consider that in C [9] a simple identifier is sufficient to identify an object, while Java [5], in general, requires a qualified name in conjunction with argument and result types to resolve possible overloading. Regarding the second point, consider that many languages do not specify the exact representation of some basic types. For example the type int in C may be 16, 32, or 64 bits wide. Similarly, Haskell guarantees only that Int covers at least the range [−229,229 − 1] (Section 6.4). As a consequence, to reliably represent values of C’s int in Haskell, we have to introduce a new type CInt, which is guaranteed to match the representation of int.
The specification of external names, dependent on a calling convention, is described in Section 8.5, whereas the marshalling of the basic types in dependence on a foreign language is described in Section 8.6.
For a given Haskell system, we define the Haskell context to be the execution context of the abstract machine on which the Haskell system is based. This includes the heap, stacks, and the registers of the abstract machine and their mapping onto a concrete architecture. We call any other execution context an external context. Generally, we cannot assume any compatibility between the data formats and calling conventions between the Haskell context and a given external context, except where Haskell explicitly prescribes a specific data format.
The principal goal of a foreign function interface is to provide a programmable interface between the Haskell context and external contexts. As a result Haskell threads can access data in external contexts and invoke functions that are executed in an external context as well as vice versa. In the rest of this definition, external contexts are usually identified by a calling convention.
Given that many external languages support static types, the question arises whether the consistency of Haskell types with the types of the external language can be enforced for foreign functions. Unfortunately, this is, in general, not possible without a significant investment on the part of the implementor of the Haskell system (i.e., without implementing a dedicated type checker). For example, in the case of the C calling convention, the only other approach would be to generate a C prototype from the Haskell type and leave it to the C compiler to match this prototype with the prototype that is specified in a C header file for the imported function. However, the Haskell type is lacking some information that would be required to pursue this route. In particular, the Haskell type does not contain any information as to when const modifiers have to be emitted.
As a consequence, this definition does not require the Haskell system to check consistency with foreign types. Nevertheless, Haskell systems are encouraged to provide any cross language consistency checks that can be implemented with reasonable effort.
The FFI reserves a single keyword foreign, and a set of special identifiers. The latter have a special meaning only within foreign declarations, but may be used as ordinary identifiers elsewhere.
The special identifiers ccall, cplusplus, dotnet, jvm, and stdcall are defined to denote calling conventions. However, a concrete implementation of the FFI is free to support additional, system-specific calling conventions whose name is not explicitly listed here.
To refer to objects of an external C context, we introduce the following phrases:
| chname | → | {chchar} . h | (C header filename) |
| cid | → | letter {letter | ascDigit} | (C identifier) |
| chchar | → | letter | ascSymbol⟨&⟩ | |
| letter | → | ascSmall | ascLarge | _ |
The range of lexemes that are admissible for chname is a subset of those permitted as arguments to the #include directive in C. In particular, a file name chname must end in the suffix .h. The lexemes produced by cid coincide with those allowed as C identifiers, as specified in [9].
The syntax of foreign declarations is as follows:
| topdecl | → | foreign fdecl | |
| fdecl | → | import callconv [safety] impent var :: ftype | (define variable) |
| | | export callconv expent var :: ftype | (expose variable) | |
| callconv | → | ccall | stdcall | cplusplus | (calling convention) |
| | | jvm | dotnet | ||
| | | system-specific calling conventions | ||
| impent | → | [string] | |
| expent | → | [string] | |
| safety | → | unsafe | safe |
There are two flavours of foreign declarations: import and export declarations. An import declaration makes an external entity, i.e., a function or memory location defined in an external context, available in the Haskell context. Conversely, an export declaration defines a function of the Haskell context as an external entity in an external context. Consequently, the two types of declarations differ in that an import declaration defines a new variable, whereas an export declaration uses a variable that is already defined in the Haskell module.
The external context that contains the external entity is determined by the calling convention given in the foreign declaration. Consequently, the exact form of the specification of the external entity is dependent on both the calling convention and on whether it appears in an import declaration (as impent) or in an export declaration (as expent). To provide syntactic uniformity in the presence of different calling conventions, it is guaranteed that the description of an external entity lexically appears as a Haskell string lexeme. The only exception is where this string would be the empty string (i.e., be of the form ""); in this case, the string may be omitted in its entirety.
The binary interface to an external entity on a given architecture is determined by a calling convention. It often depends on the programming language in which the external entity is implemented, but usually is more dependent on the system for which the external entity has been compiled.
As an example of how the calling convention is dominated by the system rather than the programming language, consider that an entity compiled to byte code for the Java Virtual Machine (JVM) [11] needs to be invoked by the rules of the JVM rather than that of the source language in which it is implemented (the entity might be implemented in Oberon, for example).
Any implementation of the Haskell FFI must at least implement the C calling convention denoted by ccall. All other calling conventions are optional. Generally, the set of calling conventions is open, i.e., individual implementations may elect to support additional calling conventions. In addition to ccall, Table 8.1 specifies a range of identifiers for common calling conventions.
| Identifier | Represented calling convention |
| ccall | Calling convention of the standard C compiler on a system |
| cplusplus | Calling convention of the standard C++ compiler on a system |
| dotnet | Calling convention of the .net platform |
| jvm | Calling convention of the Java Virtual Machine |
| stdcall | Calling convention of the Win32 API (matches Pascal conventions) |
Implementations need not implement all of these conventions, but if any is implemented, it must use the listed name. For any other calling convention, implementations are free to choose a suitable name.
Only the semantics of the calling conventions ccall and stdcall are defined herein; more calling conventions may be added in future versions of Haskell.
It should be noted that the code generated by a Haskell system to implement a particular calling convention may vary widely with the target code of that system. For example, the calling convention jvm will be trivial to implement for a Haskell compiler generating Java code, whereas for a Haskell compiler generating C code, the Java Native Interface (JNI) [10] has to be targeted.
The following types constitute the set of basic foreign types:
A Haskell system that implements the FFI needs to be able to pass these types between the Haskell and the external context as function arguments and results.
Foreign types are produced according to the following grammar:
| ftype | → | frtype | |
| | | fatype → ftype | ||
| frtype | → | fatype | |
| | | () | ||
| fatype | → | qtycon atype1 … atypek | (k ≥ 0) |
A foreign type is the Haskell type of an external entity. Only a subset of Haskell’s types are permissible as foreign types, as only a restricted set of types can be canonically transferred between the Haskell context and an external context. A foreign type has the form at1 -> -> atn -> rt where n ≥ 0. It implies that the arity of the external entity is n.
External functions are strict in all arguments.
Marshallable foreign types. The argument types ati produced by fatype must be marshallable foreign types; that is, either
newtype T a1 … an = N t
and
Consequently, in order for a type defined by newtype to be used in a foreign declaration outside of the module that defines it, the type must not be exported abstractly. The module Foreign.C.Types that defines the Haskell equivalents for C types follows this convention; see Chapter 28.
Marshallable foreign result types. The result type rt produced by frtype must be a marshallable foreign result type; that is, either
newtype T a1 … an = N t
and
Generally, an import declaration has the form foreign import c e v :: t which declares the variable v of type t to be defined externally. Moreover, it specifies that v is evaluated by executing the external entity identified by the string e using calling convention c. The precise form of e depends on the calling convention and is detailed in Section 8.5. If a variable v is defined by an import declaration, no other top-level declaration for v is allowed in the same module. For example, the declaration
introduces the function cstrlen, which invokes the external function strlen using the standard C calling convention. Some external entities can be imported as pure functions; for example,
Such a declaration asserts that the external entity is a true function; i.e., when applied to the same argument values, it always produces the same result.
Whether a particular form of external entity places a constraint on the Haskell type with which it can be imported is defined in Section 8.5. Although, some forms of external entities restrict the set of Haskell types that are permissible, the system can generally not guarantee the consistency between the Haskell type given in an import declaration and the argument and result types of the external entity. It is the responsibility of the programmer to ensure this consistency.
Optionally, an import declaration can specify, after the calling convention, the safety level that should be used when invoking an external entity. A safe call is less efficient, but guarantees to leave the Haskell system in a state that allows callbacks from the external code. In contrast, an unsafe call, while carrying less overhead, must not trigger a callback into the Haskell system. If it does, the system behaviour is undefined. The default for an invocation is to be safe. Note that a callback into the Haskell system implies that a garbage collection might be triggered after an external entity was called, but before this call returns. Consequently, objects other than stable pointers (cf. Section 36) may be moved or garbage collected by the storage manager.
The general form of export declarations is foreign export c e v :: t Such a declaration enables external access to v, which may be a value, field name, or class method that is declared on the top-level of the same module or imported. Moreover, the Haskell system defines the external entity described by the string e, which may be used by external code using the calling convention c; an external invocation of the external entity e is translated into evaluation of v. The type t must be an instance of the type of v. For example, we may have
If an evaluation triggered by an external invocation of an exported Haskell value returns with an exception, the system behaviour is undefined. Thus, Haskell exceptions have to be caught within Haskell and explicitly marshalled to the foreign code.
Each foreign declaration has to specify the external entity that is accessed or provided by that declaration. The syntax and semantics of the notation that is required to uniquely determine an external entity depends heavily on the calling convention by which this entity is accessed. For example, for the calling convention ccall, a global label is sufficient. However, to uniquely identify a method in the calling convention jvm, type information has to be provided. For the latter, there is a choice between the Java source-level syntax of types and the syntax expected by JNI—but, clearly, the syntax of the specification of an external entity depends on the calling convention and may be non-trivial.
Consequently, the FFI does not fix a general syntax for denoting external entities, but requires both impent and expent to take the form of a Haskell string literal. The formation rules for the values of these strings depend on the calling convention and a Haskell system implementing a particular calling convention will have to parse these strings in accordance with the calling convention.
Defining impent and expent to take the form of a string implies that all information that is needed to statically analyse the Haskell program is separated from the information needed to generate the code interacting with the foreign language. This is, in particular, helpful for tools processing Haskell source code. When ignoring the entity information provided by impent or expent, foreign import and export declarations are still sufficient to infer identifier definition and use information as well as type information.
For more complex calling conventions, there is a choice between the user-level syntax for identifying entities (e.g., Java or C++) and the system-level syntax (e.g., the type syntax of JNI or mangled C++, respectively). If such a choice exists, the user-level syntax is preferred. Not only because it is more user friendly, but also because the system-level syntax may not be entirely independent of the particular implementation of the foreign language.
The following defines the syntax for specifying external entities and their semantics for the calling conventions ccall and stdcall. Other calling conventions from Table 8.1 are expected to be defined in future versions of Haskell.
The following defines the structure of external entities for foreign declarations under the ccall calling convention for both import and export declarations separately. Afterwards additional constraints on the type of foreign functions are defined.
The FFI covers only access to C functions and global variables. There are no mechanisms to access other entities of C programs. In particular, there is no support for accessing pre-processor symbols from Haskell, which includes #defined constants. Access from Haskell to such entities is the domain of language-specific tools, which provide added convenience over the plain FFI as defined here.
Import Declarations For import declarations, the syntax for the specification of external entities under the ccall calling convention is as follows:
| impent | → | " [static] [chname] [&] [cid] " | (static function or address) |
| | | " dynamic " | (stub factory importing addresses) | |
| | | " wrapper " | (stub factory exporting thunks) |
The first alternative either imports a static function cid or, if & precedes the identifier, a static address. If cid is omitted, it defaults to the name of the imported Haskell variable. The optional filename chname specifies a C header file, where the intended meaning is that the header file declares the C entity identified by cid. In particular, when the Haskell system compiles Haskell to C code, the directive
#include "chname"
needs to be placed into any generated C file that refers to the foreign entity before the first occurrence of that entity in the generated C file.
The second and third alternative, identified by the keywords dynamic and wrapper, respectively, import stub functions that have to be generated by the Haskell system. In the case of dynamic, the stub converts C function pointers into Haskell functions; and conversely, in the case of wrapper, the stub converts Haskell thunks to C function pointers. If neither of the specifiers static, dynamic, or wrapper is given, static is assumed. The specifier static is nevertheless needed to import C routines that are named dynamic or wrapper.
It should be noted that a static foreign declaration that does not import an address (i.e., where & is not used in the specification of the external entity) always refers to a C function, even if the Haskell type is non-functional. For example,
refers to a pure C function foo with no arguments that returns an integer value. Similarly, if the type is IO CInt, the declaration refers to an impure nullary function. If a Haskell program needs to access a C variable bar of integer type,
must be used to obtain a pointer referring to the variable. The variable can be read and updated using the routines provided by the module Foreign.Storable (cf. Section 37).
Export Declarations External entities in ccall export declarations are of the form
| expent | → | " [cid] " |
The optional C identifier cid defines the external name by which the exported Haskell variable is accessible in C. If it is omitted, the external name defaults to the name of the exported Haskell variable.
Constraints on Foreign Function Types In the case of import declaration, there are, depending on the kind of import declaration, constraints regarding the admissible Haskell type that the variable defined in the import may have. These constraints are specified in the following.
As an example, consider
This declaration imports the system() function whose prototype is available from stdlib.h.
As an example, consider
It imports the address of the variable errno, which is of the C type int.
As an example, consider
The stub factory mkFun converts any pointer to a C function that gets an integer value as its only argument and does not have a return value into a corresponding Haskell function.
As an example, consider
The stub factory mkCallback turns any Haskell computation of type IO () into a C function pointer that can be passed to C routines, which can call back into the Haskell context by invoking the referenced function.
Specification of Header Files A C header specified in an import declaration is always included by #include "chname". There is no explicit support for #include <chname> style inclusion. The ISO C99 [7] standard guarantees that any search path that would be used for a #include <chname> is also used for #include "chname" and it is guaranteed that these paths are searched after all paths that are unique to #include "chname". Furthermore, we require that chname ends in .h to make parsing of the specification of external entities unambiguous.
The specification of include files has been kept to a minimum on purpose. Libraries often require a multitude of include directives, some of which may be system-dependent. Any design that attempts to cover all possible configurations would introduce significant complexity. Moreover, in the current design, a custom include file can be specified that uses the standard C preprocessor features to include all relevant headers.
Header files have no impact on the semantics of a foreign call, and whether an implementation uses the header file or not is implementation-defined. However, as some implementations may require a header file that supplies a correct prototype for external functions in order to generate correct code, portable FFI code must include suitable header files.
C Argument Promotion The argument passing conventions of C are dependent on whether a function prototype for the called functions is in scope at a call site. In particular, if no function prototype is in scope, default argument promotion is applied to integral and floating types. In general, it cannot be expected from a Haskell system that it is aware of whether a given C function was compiled with or without a function prototype being in scope. For the sake of portability, we thus require that a Haskell system generally implements calls to C functions as well as C stubs for Haskell functions as if a function prototype for the called function is in scope.
This convention implies that the onus for ensuring the match between C and Haskell code is placed on the FFI user. In particular, when a C function that was compiled without a prototype is called from Haskell, the Haskell signature at the corresponding foreign import declaration must use the types after argument promotion. For example, consider the following C function definition, which lacks a prototype:
The lack of a prototype implies that a C compiler will apply default argument promotion to the parameter a, and thus, foo will expect to receive a value of type double, not float. Hence, the correct foreign import declaration is
In contrast, a C function compiled with the prototype
requires
A similar situation arises in the case of foreign export declarations that use types that would be altered under the C default argument promotion rules. When calling such Haskell functions from C, a function prototype matching the signature provided in the foreign export declaration must be in scope; otherwise, the C compiler will erroneously apply the promotion rules to all function arguments.
Note that for a C function defined to accept a variable number of arguments, all arguments beyond the explicitly typed arguments suffer argument promotion. However, because C permits the calling convention to be different for such functions, a Haskell system will, in general, not be able to make use of variable argument functions. Hence, their use is deprecated in portable code.
The specification of external entities under the stdcall calling convention is identical to that for standard C calls. The two calling conventions only differ in the generated code.
In addition to the language extension discussed in previous sections, the FFI includes a set of standard libraries, which ease portable use of foreign functions as well as marshalling of compound structures. Generally, the marshalling of Haskell structures into a foreign representation and vice versa can be implemented in either Haskell or the foreign language. At least where the foreign language is at a significantly lower level, e.g. C, there are good reasons for doing the marshalling in Haskell:
Consequently, the Haskell FFI emphasises Haskell-side marshalling.
The interface to the marshalling libraries is provided by the module Foreign (Chapter 24) plus a language-dependent module per supported language. In particular, the standard requires the availability of the module Foreign.C (Chapter 25), which simplifies portable interfacing with external C code. Language-dependent modules, such as Foreign.C, generally provide Haskell types representing the basic types of the foreign language using a representation that is compatible with the foreign types as implemented by the default implementation of the foreign language on the present architecture. This is especially important for languages where the standard leaves some aspects of the implementation of basic types open. For example, in C, the size of the various integral types is not fixed. Thus, to represent C interfaces faithfully in Haskell, for each integral type in C, we need to have an integral type in Haskell that is guaranteed to have the same size as the corresponding C type.
| C symbol | Haskell symbol | Constraint on concrete C type |
| HsChar | Char | integral type |
| HsInt | Int | signed integral type, ≥ 30 bit |
| HsInt8 | Int8 | signed integral type, 8 bit; int8_t if available |
| HsInt16 | Int16 | signed integral type, 16 bit; int16_t if available |
| HsInt32 | Int32 | signed integral type, 32 bit; int32_t if available |
| HsInt64 | Int64 | signed integral type, 64 bit; int64_t if available |
| HsWord8 | Word8 | unsigned integral type, 8 bit; uint8_t if available |
| HsWord16 | Word16 | unsigned integral type, 16 bit; uint16_t if available |
| HsWord32 | Word32 | unsigned integral type, 32 bit; uint32_t if available |
| HsWord64 | Word64 | unsigned integral type, 64 bit; uint64_t if available |
| HsFloat | Float | floating point type |
| HsDouble | Double | floating point type |
| HsBool | Bool | int |
| HsPtr | Ptr a | (void ⋆) |
| HsFunPtr | FunPtr a | (void (⋆)(void)) |
| HsStablePtr | StablePtr a | (void ⋆) |
| CPP symbol | Haskell value | Description |
| HS_CHAR_MIN | minBound :: Char |
|
| HS_CHAR_MAX | maxBound :: Char |
|
| HS_INT_MIN | minBound :: Int |
|
| HS_INT_MAX | maxBound :: Int |
|
| HS_INT8_MIN | minBound :: Int8 |
|
| HS_INT8_MAX | maxBound :: Int8 |
|
| HS_INT16_MIN | minBound :: Int16 |
|
| HS_INT16_MAX | maxBound :: Int16 |
|
| HS_INT32_MIN | minBound :: Int32 |
|
| HS_INT32_MAX | maxBound :: Int32 |
|
| HS_INT64_MIN | minBound :: Int64 |
|
| HS_INT64_MAX | maxBound :: Int64 |
|
| HS_WORD8_MAX | maxBound :: Word8 |
|
| HS_WORD16_MAX | maxBound :: Word16 |
|
| HS_WORD32_MAX | maxBound :: Word32 |
|
| HS_WORD64_MAX | maxBound :: Word64 |
|
| HS_FLOAT_RADIX | floatRadix :: Float |
|
| HS_FLOAT_ROUND | n/a | rounding style as per [7] |
| HS_FLOAT_EPSILON | n/a | difference between 1 and the least value greater than 1 as per [7] |
| HS_DOUBLE_EPSILON | n/a | (as above) |
| HS_FLOAT_DIG | n/a | number of decimal digits as per [7] |
| HS_DOUBLE_DIG | n/a | (as above) |
| HS_FLOAT_MANT_DIG | floatDigits :: Float |
|
| HS_DOUBLE_MANT_DIG | floatDigits :: Double |
|
| HS_FLOAT_MIN | n/a | minimum floating point number as per [7] |
| HS_DOUBLE_MIN | n/a | (as above) |
| HS_FLOAT_MIN_EXP | fst . floatRange :: Float |
|
| HS_DOUBLE_MIN_EXP | fst . floatRange :: Double |
|
| HS_FLOAT_MIN_10_EXP | n/a | minimum decimal exponent as per [7] |
| HS_DOUBLE_MIN_10_EXP | n/a | (as above) |
| HS_FLOAT_MAX | n/a | maximum floating point number as per [7] |
| HS_DOUBLE_MAX | n/a | (as above) |
| HS_FLOAT_MAX_EXP | snd . floatRange :: Float |
|
| HS_DOUBLE_MAX_EXP | snd . floatRange :: Double |
|
| HS_FLOAT_MAX_10_EXP | n/a | maximum decimal exponent as per [7] |
| HS_DOUBLE_MAX_10_EXP | n/a | (as above) |
| HS_BOOL_FALSE | False |
|
| HS_BOOL_TRUE | True |
|
Every Haskell system that implements the FFI needs to provide a C header file named HsFFI.h that defines the C symbols listed in Tables 8.2 and 8.3. Table 8.2 table lists symbols that represent types together with the Haskell type that they represent and any constraints that are placed on the concrete C types that implement these symbols. When a C type HsT represents a Haskell type T, the occurrence of T in a foreign function declaration should be matched by HsT in the corresponding C function prototype. Indeed, where the Haskell system translates Haskell to C code that invokes foreignimported C routines, such prototypes need to be provided and included via the header that can be specified in external entity strings for foreign C functions (cf. Section 8.5.1); otherwise, the system behaviour is undefined. It is guaranteed that the Haskell value nullPtr is mapped to (HsPtr) NULL in C and nullFunPtr is mapped to (HsFunPtr) NULL and vice versa.
Table 8.3 contains symbols characterising the range and precision of the types from Table 8.2. Where available, the table states the corresponding Haskell values. All C symbols, with the exception of HS_FLOAT_ROUND are constants that are suitable for use in #if preprocessing directives. Note that there is only one rounding style (HS_FLOAT_ROUND) and one radix (HS_FLOAT_RADIX), as this is all that is supported by ISO C [7].
Moreover, an implementation that does not support 64 bit integral types on the C side should implement HsInt64 and HsWord64 as a structure. In this case, the bounds HS_INT64_MIN, HS_INT64_MAX, and HS_WORD64_MAX are undefined.
In addition, to the symbols from Table 8.2 and 8.3, the header HsFFI.h must also contain the following prototypes:
These routines are useful for mixed language programs, where the main application is implemented in a foreign language that accesses routines implemented in Haskell. The function hs_init() initialises the Haskell system and provides it with the available command line arguments. Upon return, the arguments solely intended for the Haskell runtime system are removed (i.e., the values that argc and argv point to may have changed). This function must be called during program startup before any Haskell function is invoked; otherwise, the system behaviour is undefined. Conversely, the Haskell system is deinitialised by a call to hs_exit(). Multiple invocations of hs_init() are permitted, provided that they are followed by an equal number of calls to hs_exit() and that the first call to hs_exit() is after the last call to hs_init(). In addition to nested calls to hs_init(), the Haskell system may be de-initialised with hs_exit() and be re-initialised with hs_init() at a later point in time. This ensures that repeated initialisation due to multiple libraries being implemented in Haskell is covered.
The Haskell system will ignore the command line arguments passed to the second and any following calls to hs_init(). Moreover, hs_init() may be called with NULL for both argc and argv, signalling the absence of command line arguments.
The function hs_set_argv() sets the values returned by the functions getProgName and getArgs of the module System.Environment (Section 39). This function may only be invoked after hs_init(). Moreover, if hs_set_argv() is called at all, this call must precede the first invocation of getProgName and getArgs. Note that the separation of hs_init() and hs_set_argv() is essential in cases where in addition to the Haskell system other libraries that process command line arguments during initialisation are used.
The function hs_perform_gc() advises the Haskell storage manager to perform a garbage collection, where the storage manager makes an effort to releases all unreachable objects. This function must not be invoked from C functions that are imported unsafe into Haskell code nor may it be used from a finalizer.
Finally, hs_free_stable_ptr() and hs_free_fun_ptr() are the C counterparts of the Haskell functions freeStablePtr and freeHaskellFunPtr.


/* This file is part of Ext JS 4 Copyright (c) 2011 Sencha Inc Contact: http://www.sencha.com/contact Commercial Usage Licensees holding valid commercial licenses may use this file in accordance with the Commercial Software License Agreement provided with the Software or, alternatively, in accordance with the terms contained in a written agreement between you and Sencha. If you are unsure which license is appropriate for your use, please contact the sales department at http://www.sencha.com/contact. */ /** * @docauthor Jason Johnston<EMAIL_ADDRESS>* * FormPanel provides a standard container for forms. It is essentially a standard {@link Ext.panel.Panel} which * automatically creates a {@link Ext.form.Basic BasicForm} for managing any {@link Ext.form.field.Field} * objects that are added as descendants of the panel. It also includes conveniences for configuring and * working with the BasicForm and the collection of Fields. * * # Layout * * By default, FormPanel is configured with `{@link Ext.layout.container.Anchor layout:'anchor'}` for * the layout of its immediate child items. This can be changed to any of the supported container layouts. * The layout of sub-containers is configured in {@link Ext.container.Container#layout the standard way}. * * # BasicForm * * Although **not listed** as configuration options of FormPanel, the FormPanel class accepts all * of the config options supported by the {@link Ext.form.Basic} class, and will pass them along to * the internal BasicForm when it is created. * * **Note**: If subclassing FormPanel, any configuration options for the BasicForm must be applied to * the `initialConfig` property of the FormPanel. Applying {@link Ext.form.Basic BasicForm} * configuration settings to `this` will *not* affect the BasicForm's configuration. * * The following events fired by the BasicForm will be re-fired by the FormPanel and can therefore be * listened for on the FormPanel itself: * * - {@link Ext.form.Basic#beforeaction beforeaction} * - {@link Ext.form.Basic#actionfailed actionfailed} * - {@link Ext.form.Basic#actioncomplete actioncomplete} * - {@link Ext.form.Basic#validitychange validitychange} * - {@link Ext.form.Basic#dirtychange dirtychange} * * # Field Defaults * * The {@link #fieldDefaults} config option conveniently allows centralized configuration of default values * for all fields added as descendants of the FormPanel. Any config option recognized by implementations * of {@link Ext.form.Labelable} may be included in this object. See the {@link #fieldDefaults} documentation * for details of how the defaults are applied. * * # Form Validation * * With the default configuration, form fields are validated on-the-fly while the user edits their values. * This can be controlled on a per-field basis (or via the {@link #fieldDefaults} config) with the field * config properties {@link Ext.form.field.Field#validateOnChange} and {@link Ext.form.field.Base#checkChangeEvents}, * and the FormPanel's config properties {@link #pollForChanges} and {@link #pollInterval}. * * Any component within the FormPanel can be configured with `formBind: true`. This will cause that * component to be automatically disabled when the form is invalid, and enabled when it is valid. This is most * commonly used for Button components to prevent submitting the form in an invalid state, but can be used on * any component type. * * For more information on form validation see the following: * * - {@link Ext.form.field.Field#validateOnChange} * - {@link #pollForChanges} and {@link #pollInterval} * - {@link Ext.form.field.VTypes} * - {@link Ext.form.Basic#doAction BasicForm.doAction clientValidation notes} * * # Form Submission * * By default, Ext Forms are submitted through Ajax, using {@link Ext.form.action.Action}. See the documentation for * {@link Ext.form.Basic} for details. * * # Example usage * * @example * Ext.create('Ext.form.Panel', { * title: 'Simple Form', * bodyPadding: 5, * width: 350, * * // The form will submit an AJAX request to this URL when submitted * url: 'save-form.php', * * // Fields will be arranged vertically, stretched to full width * layout: 'anchor', * defaults: { * anchor: '100%' * }, * * // The fields * defaultType: 'textfield', * items: [{ * fieldLabel: 'First Name', * name: 'first', * allowBlank: false * },{ * fieldLabel: 'Last Name', * name: 'last', * allowBlank: false * }], * * // Reset and Submit buttons * buttons: [{ * text: 'Reset', * handler: function() { * this.up('form').getForm().reset(); * } * }, { * text: 'Submit', * formBind: true, //only enabled once the form is valid * disabled: true, * handler: function() { * var form = this.up('form').getForm(); * if (form.isValid()) { * form.submit({ * success: function(form, action) { * Ext.Msg.alert('Success', action.result.msg); * }, * failure: function(form, action) { * Ext.Msg.alert('Failed', action.result.msg); * } * }); * } * } * }], * renderTo: Ext.getBody() * }); * */ Ext.define('Ext.form.Panel', { extend:'Ext.panel.Panel', mixins: { fieldAncestor: 'Ext.form.FieldAncestor' }, alias: 'widget.form', alternateClassName: ['Ext.FormPanel', 'Ext.form.FormPanel'], requires: ['Ext.form.Basic', 'Ext.util.TaskRunner'], /** * @cfg {Boolean} pollForChanges * If set to `true`, sets up an interval task (using the {@link #pollInterval}) in which the * panel's fields are repeatedly checked for changes in their values. This is in addition to the normal detection * each field does on its own input element, and is not needed in most cases. It does, however, provide a * means to absolutely guarantee detection of all changes including some edge cases in some browsers which * do not fire native events. Defaults to `false`. */ /** * @cfg {Number} pollInterval * Interval in milliseconds at which the form's fields are checked for value changes. Only used if * the {@link #pollForChanges} option is set to `true`. Defaults to 500 milliseconds. */ /** * @cfg {String} layout * The {@link Ext.container.Container#layout} for the form panel's immediate child items. * Defaults to `'anchor'`. */ layout: 'anchor', ariaRole: 'form', initComponent: function() { var me = this; if (me.frame) { me.border = false; } me.initFieldAncestor(); me.callParent(); me.relayEvents(me.form, [ 'beforeaction', 'actionfailed', 'actioncomplete', 'validitychange', 'dirtychange' ]); // Start polling if configured if (me.pollForChanges) { me.startPolling(me.pollInterval || 500); } }, initItems: function() { // Create the BasicForm var me = this; me.form = me.createForm(); me.callParent(); me.form.initialize(); }, /** * @private */ createForm: function() { return Ext.create('Ext.form.Basic', this, Ext.applyIf({listeners: {}}, this.initialConfig)); }, /** * Provides access to the {@link Ext.form.Basic Form} which this Panel contains. * @return {Ext.form.Basic} The {@link Ext.form.Basic Form} which this Panel contains. */ getForm: function() { return this.form; }, /** * Loads an {@link Ext.data.Model} into this form (internally just calls {@link Ext.form.Basic#loadRecord}) * See also {@link Ext.form.Basic#trackResetOnLoad trackResetOnLoad}. * @param {Ext.data.Model} record The record to load * @return {Ext.form.Basic} The Ext.form.Basic attached to this FormPanel */ loadRecord: function(record) { return this.getForm().loadRecord(record); }, /** * Returns the currently loaded Ext.data.Model instance if one was loaded via {@link #loadRecord}. * @return {Ext.data.Model} The loaded instance */ getRecord: function() { return this.getForm().getRecord(); }, /** * Convenience function for fetching the current value of each field in the form. This is the same as calling * {@link Ext.form.Basic#getValues this.getForm().getValues()} * @return {Object} The current form field values, keyed by field name */ getValues: function() { return this.getForm().getValues(); }, beforeDestroy: function() { this.stopPolling(); this.form.destroy(); this.callParent(); }, /** * This is a proxy for the underlying BasicForm's {@link Ext.form.Basic#load} call. * @param {Object} options The options to pass to the action (see {@link Ext.form.Basic#load} and * {@link Ext.form.Basic#doAction} for details) */ load: function(options) { this.form.load(options); }, /** * This is a proxy for the underlying BasicForm's {@link Ext.form.Basic#submit} call. * @param {Object} options The options to pass to the action (see {@link Ext.form.Basic#submit} and * {@link Ext.form.Basic#doAction} for details) */ submit: function(options) { this.form.submit(options); }, /* * Inherit docs, not using onDisable because it only gets fired * when the component is rendered. */ disable: function(silent) { this.callParent(arguments); this.form.getFields().each(function(field) { field.disable(); }); }, /* * Inherit docs, not using onEnable because it only gets fired * when the component is rendered. */ enable: function(silent) { this.callParent(arguments); this.form.getFields().each(function(field) { field.enable(); }); }, /** * Start an interval task to continuously poll all the fields in the form for changes in their * values. This is normally started automatically by setting the {@link #pollForChanges} config. * @param {Number} interval The interval in milliseconds at which the check should run. */ startPolling: function(interval) { this.stopPolling(); var task = Ext.create('Ext.util.TaskRunner', interval); task.start({ interval: 0, run: this.checkChange, scope: this }); this.pollTask = task; }, /** * Stop a running interval task that was started by {@link #startPolling}. */ stopPolling: function() { var task = this.pollTask; if (task) { task.stopAll(); delete this.pollTask; } }, /** * Forces each field within the form panel to * {@link Ext.form.field.Field#checkChange check if its value has changed}. */ checkChange: function() { this.form.getFields().each(function(field) { field.checkChange(); }); } });


At Least 15 Killed in Collision of 2 Trains in Bangladesh - Reports
MOSCOW (Sputnik) - At least 15 people were killed and many were injured in a head-on collision of two trains in Bangladesh, local newspaper Daily Star reported on Tuesday.
The incident occurred on Tuesday morning at a train station in Brahmanbaria District in eastern Bangladesh. The Udayan Express train was approaching a platform when it collided with another train. As a result of the collision, at least two railway cars were seriously damaged.
A local police spokesman said a rescue operation was underway at the site, and the death toll might increase.
Earlier in the year, five people were killed and 100 more injured as several carriages of a train fell off a bridge in the Moulvibazar district, in the north of Bangladesh.