Module World
The b2.World
class inherits from the following class: EventDispatcher
.
The b2.World
class manages all physics entities and dynamic simulation. It is possible to create and manage more than one b2.World
instance.
Type World
| World:addEventListener(listener, data) |
Registers a listener function and an optional data value so that the listener function is called when an event of a particular type occurs. |
| World:clearForces() |
Call this after you are done with time steps to clear the forces. |
| World:createBody(bodyDef) |
Creates a rigid body given a definition. |
| World:createJoint(jointDef) |
Creates a joint given a definition. |
| World:destroyBody(body) |
Destroys a rigid body. |
| World:destroyJoint(joint) |
Destroy a joint. |
| World:dispatchEvent(event) |
Dispatches an event to this |
| World:getGravity() |
Returns the gravity vector. |
| World:hasEventListener() |
Checks if the |
| World.new(gravityx, gravityy, doSleep) |
Creates a new |
| World:queryAABB(lowerx, lowery, upperx, uppery) |
Query the world for all fixtures that potentially overlap the provided AABB. |
| World:rayCast(x1, y1, x2, y2, listener, data) |
Ray-cast the world for all fixtures in the path of the ray. |
| World:removeEventListener(listener, data) |
Removes a listener from the |
| World:setDebugDraw() |
Registers a b2.DebugDraw instance for debug drawing. |
| World:setGravity(gravityx, gravityy) |
Sets the gravity vector. |
| World:step(timeStep, velocityIterations, positionIterations) |
Take a time step. |
Type World
Field(s)
- World:addEventListener(listener, data)
-
Registers a listener function and an optional data value so that the listener function is called when an event of a particular type occurs.
Parameters
-
listener
: (function) The listener function that processes the event. -
data
: (optional) An optional data parameter that is passed as a first argument to the listener function.
-
- World:clearForces()
-
Call this after you are done with time steps to clear the forces.
You normally call this after each call to
b2.World:step
, unless you are performing sub-steps. By default, forces will be automatically cleared, so you don't need to call this function.
- World:createBody(bodyDef)
-
Creates a rigid body given a definition.
The body definition is given as an ordinary table. The fields of the body definition table are:
- type: (number) The body type:
b2.STATIC_BODY
,b2.KINEMATIC_BODY
, orb2.DYNAMIC_BODY
. Note: if a dynamic body would have zero mass, the mass is set to one. - position: (table) The world position of the body (see the example below to understand how this table is set). Avoid creating bodies at the origin since this can lead to many overlapping shapes.
- angle: (number) The world angle of the body in radians.
- linearVelocity: (table) The linear velocity of the body's origin in world co-ordinates (see the example below to understand how this table is set).
- angularVelocity: (number) The angular velocity of the body.
- linearDamping: (number) Linear damping is use to reduce the linear velocity. The damping parameter can be larger than 1.0 but the damping effect becomes sensitive to the time step when the damping parameter is large.
- angularDamping: (number) Angular damping is use to reduce the angular velocity. The damping parameter can be larger than 1.0 but the damping effect becomes sensitive to the time step when the damping parameter is large.
- allowSleep: (boolean) Set this flag to false if this body should never fall asleep. Note that this increases CPU usage.
- awake: (boolean) Is this body initially awake or sleeping?
- fixedRotation: (boolean) Should this body be prevented from rotating? Useful for characters.
- bullet: (boolean) Is this a fast moving body that should be prevented from tunneling through other moving bodies? Note that all bodies are prevented from tunneling through kinematic and static bodies. This setting is only considered on dynamic bodies. Warning: You should use this flag sparingly since it increases processing time.
- active: (boolean) Does this body start out active?
- gravityScale: (number) Scale the gravity applied to this body.
The unset fields gets default values.
Warning: This function is locked during callbacks.
Parameter
-
bodyDef
: (table)
Return value
Body#Body: The created
b2.Body
instance. - type: (number) The body type:
- World:createJoint(jointDef)
-
Creates a joint given a definition.
All 9 types of joints is created by using this function:
Revolute Joint
Revolute joint definition. This requires defining an anchor point where the bodies are joined. The definition uses local anchor points so that the initial configuration can violate the constraint slightly. You also need to specify the initial relative angle for joint limits. This helps when saving and loading a game. The local anchor points are measured from the body's origin rather than the center of mass because:
- you might not know where the center of mass will be.
- if you add/remove shapes from a body
and recompute the mass, the joints will be broken.
- type: (number) b2.REVOLUTE_JOINT
- bodyA: (b2.Body) The first attached body.
- bodyB: (b2.Body) The second attached body.
- collideConnected: (boolean) Set this flag to true if the attached bodies should collide.
- localAnchorA: (table) The local anchor point relative to bodyA's origin.
- localAnchorB: (table) The local anchor point relative to bodyB's origin.
- referenceAngle: (number) The bodyB angle minus bodyA angle in the reference state (radians).
- enableLimit: (boolean) A flag to enable joint limits.
- lowerAngle: (number) The lower angle for the joint limit (radians).
- upperAngle: (number) The upper angle for the joint limit (radians).
- enableMotor: (boolean) A flag to enable the joint motor.
- motorSpeed: (number) The desired motor speed. Usually in radians per second.
- maxMotorTorque: (number) The maximum motor torque used to achieve the desired motor speed. Usually in N-m.
Also, you can use b2.createRevoluteJointDef function to create a revolute joint definiton table easier.
Prismatic Joint
Prismatic joint definition. This requires defining a line of motion using an axis and an anchor point. The definition uses local anchor points and a local axis so that the initial configuration can violate the constraint slightly. The joint translation is zero when the local anchor points coincide in world space. Using local anchors and a local axis helps when saving and loading a game.
- type: (number) b2.PRISMATIC_JOINT
- bodyA: (b2.Body) The first attached body.
- bodyB: (b2.Body) The second attached body.
- collideConnected: (boolean) Set this flag to true if the attached bodies should collide.
- localAnchorA: (table) The local anchor point relative to bodyA's origin.
- localAnchorB: (table) The local anchor point relative to bodyB's origin.
- localAxisA: (table) The local translation axis in bodyA.
- referenceAngle: (number) The body2 angle minus body1 angle in the reference state (radians).
- enableLimit: (boolean) A flag to enable joint limits.
- lowerTranslation: (number) The lower translation limit, usually in meters.
- upperTranslation: (number) The upper translation limit, usually in meters.
- enableMotor: (boolean) A flag to enable the joint motor.
- maxMotorForce: (number) The maximum motor torque, usually in N-m.
- motorSpeed: (number) The desired motor speed in radians per second.
Also, you can use b2.createPrismaticJointDef function to create a prismatic joint definiton table easier.
Distance Joint
Distance joint definition. This requires defining an anchor point on both bodies and the non-zero length of the distance joint. The definition uses local anchor points so that the initial configuration can violate the constraint slightly. This helps when saving and loading a game.
- type: (number) b2.DISTANCE_JOINT
- bodyA: (b2.Body) The first attached body.
- bodyB: (b2.Body) The second attached body.
- collideConnected: (boolean) Set this flag to true if the attached bodies should collide.
- localAnchorA: (table) The local anchor point relative to bodyA's origin.
- localAnchorB: (table) The local anchor point relative to bodyB's origin.
- length: (number) The natural length between the anchor points. Do not use a zero or short length.
- frequencyHz: (number) The mass-spring-damper frequency in Hertz.
- dampingRatio: (number) The damping ratio. 0 = no damping, 1 = critical damping.
Also, you can use b2.createDistanceJointDef function to create a distance joint definiton table easier.
Pulley Joint
Pulley joint definition. This requires two ground anchors, two dynamic body anchor points, max lengths for each side, and a pulley ratio.
- type: (number) b2.PULLEY_JOINT
- bodyA: (b2.Body) The first attached body.
- bodyB: (b2.Body) The second attached body.
- collideConnected: (boolean) Set this flag to true if the attached bodies should collide.
- groundAnchorA: (table) The first ground anchor in world coordinates. This point never moves.
- groundAnchorB: (table) The second ground anchor in world coordinates. This point never moves.
- localAnchorA: (table) The local anchor point relative to bodyA's origin.
- localAnchorB: (table) The local anchor point relative to bodyB's origin.
- lengthA: (number) The a reference length for the segment attached to bodyA.
- lengthB: (number) The a reference length for the segment attached to bodyB.
- ratio: (number) The pulley ratio, used to simulate a block-and-tackle.
Also, you can use b2.createPulleyJointDef function to create a pulley joint definiton table easier.
Mouse Joint
Mouse joint definition. This requires a world target point, tuning parameters, and the time step.
- type: (number) b2.MOUSE_JOINT
- bodyA: (b2.Body) The first attached body.
- bodyB: (b2.Body) The second attached body.
- collideConnected: (boolean) Set this flag to true if the attached bodies should collide.
- target: (table) The initial world target point. This is assumed to coincide with the body anchor initially.
- maxForce: (number) The maximum constraint force that can be exerted to move the candidate body. Usually you will express as some multiple of the weight (multiplier * mass * gravity).
- frequencyHz: (number) The response speed.
- dampingRatio: (number) The damping ratio. 0 = no damping, 1 = critical damping.
Also, you can use b2.createMouseJointDef function to create a mouse joint definiton table easier.
Gear Joint
Gear joint definition. This definition requires two existing revolute or prismatic joints (any combination will work). The provided joints must attach a dynamic body to a static body.
- type: (number) b2.GEAR_JOINT
- bodyA: (b2.Body) The first attached body.
- bodyB: (b2.Body) The second attached body.
- collideConnected: (boolean) Set this flag to true if the attached bodies should collide.
- joint1: (b2.Joint) The first revolute/prismatic joint attached to the gear joint.
- joint2: (b2.Joint) The second revolute/prismatic joint attached to the gear joint.
- ratio: (number) The gear ratio.
Also, you can use b2.createGearJointDef function to create a gear joint definiton table easier.
Wheel Joint
Wheel joint definition. This requires defining a line of motion using an axis and an anchor point. The definition uses local anchor points and a local axis so that the initial configuration can violate the constraint slightly. The joint translation is zero when the local anchor points coincide in world space. Using local anchors and a local axis helps when saving and loading a game.
- type: (number) b2.WHEEL_JOINT
- bodyA: (b2.Body) The first attached body.
- bodyB: (b2.Body) The second attached body.
- collideConnected: (boolean) Set this flag to true if the attached bodies should collide.
- localAnchorA: (table) The local anchor point relative to bodyA's origin.
- localAnchorB: (table) The local anchor point relative to bodyB's origin.
- localAxisA: (table) The local translation axis in bodyA.
- enableMotor: (boolean) A flag to enable the joint motor.
- maxMotorTorque: (number) The maximum motor torque, usually in N-m.
- motorSpeed: (number) The desired motor speed in radians per second.
- frequencyHz: (number) Suspension frequency, zero indicates no suspension.
- dampingRatio: (number) Suspension damping ratio, one indicates critical damping.
Also, you can use b2.createWheelJointDef function to create a wheel joint definiton table easier.
Weld Joint
Weld joint definition. You need to specify local anchor points where they are attached and the relative body angle. The position of the anchor points is important for computing the reaction torque.
- type: (number) b2.WELD_JOINT
- bodyA: (b2.Body) The first attached body.
- bodyB: (b2.Body) The second attached body.
- collideConnected: (boolean) Set this flag to true if the attached bodies should collide.
- localAnchorA: (table) The local anchor point relative to bodyA's origin.
- localAnchorB: (table) The local anchor point relative to bodyB's origin.
- referenceAngle: (number) The bodyB angle minus bodyA angle in the reference state (radians).
Also, you can use b2.createWeldJointDef function to create a weld joint definiton table easier.
Friction Joint
Friction joint definition.
- type: (number) b2.LINE_JOINT
- bodyA: (b2.Body) The first attached body.
- bodyB: (b2.Body) The second attached body.
- collideConnected: (boolean) Set this flag to true if the attached bodies should collide.
- localAnchorA: (table) The local anchor point relative to bodyA's origin.
- localAnchorB: (table) The local anchor point relative to bodyB's origin.
- maxForce: (number) The maximum friction force in N.
- maxTorque: (number) The maximum friction torque in N-m.
Parameter
-
jointDef
: (table)
Return value
The created joint instance.
- World:destroyBody(body)
-
Destroys a rigid body.
This function is locked during callbacks.
Warning:
- This automatically deletes all associated shapes and joints.
- This function is locked during callbacks.
Parameter
-
body
: (b2.Body) body to be destroyed
- World:destroyJoint(joint)
-
Destroy a joint.
This may cause the connected bodies to begin colliding.
Warning: This function is locked during callbacks.
Parameter
-
joint
: (b2.Joint) joint to be destroyed
-
- World:dispatchEvent(event)
-
Dispatches an event to this
EventDispatcher
instance.Parameter
-
event
: (Event) TheEvent
object to be dispatched.
-
- World:getGravity()
-
Returns the gravity vector.
Return value
x and y component of gravity vector.
- World:hasEventListener()
-
Checks if the
EventDispatcher
object has a event listener registered for the specified type of event.Return value
A value of
true
if a listener of the specified type is registered;false
otherwise.
- World.new(gravityx, gravityy, doSleep)
-
Creates a new
b2.World
object.You can create more then one
b2.World
object to manage independent worlds.Parameters
-
gravityx
: (number) the x component the gravity -
gravityy
: (number) the y component the gravity -
doSleep
: (boolean, default = true) improve performance by not simulating inactive bodies
Return value
#World: A new
b2.World
object. -
- World:queryAABB(lowerx, lowery, upperx, uppery)
-
Query the world for all fixtures that potentially overlap the provided AABB.
Parameters
-
lowerx
: (number) the lower x coordinate of the query box -
lowery
: (number) the lower y coordinate of the query box -
upperx
: (number) the upper x coordinate of the query box -
uppery
: (number) the upper y coordinate of the query box
Return value
Array of fixtures that potentially overlaps the provided AABB
-
- World:rayCast(x1, y1, x2, y2, listener, data)
-
Ray-cast the world for all fixtures in the path of the ray.
Your callback controls whether you get the closest point, any point, or n-points. The ray-cast ignores shapes that contain the starting point.
Listener function is called for each fixture found in the query and accepts 6 parameters (7 if data parameter is provided):
- the fixture hit by the ray
- the x coordinate of the point of initial intersection
- the y coordinate of the point of initial intersection
- the x coordinate of the normal vector at the point of intersection
- the y coordinate of the normal vector at the point of intersection
- fraction
You control how the ray cast proceeds by returning a number:
- return no value or -1: ignore this fixture and continue
- return 0: terminate the ray cast
- return fraction: clip the ray to this point
- return 1: don't clip the ray and continue
Parameters
-
x1
: (number) the x coordinate of the ray starting point -
y1
: (number) the y coordinate of the ray starting point -
x2
: (number) the x coordinate of the ray ending point -
y2
: (number) the y coordinate of the ray ending point -
listener
: (function) the listener function that processes the results -
data
: (optional) an optional data parameter that is passed as a first argument to the listener function
- World:removeEventListener(listener, data)
-
Removes a listener from the
EventDispatcher
object.removeEventListener()
function expects the same arguments withaddEventListener()
to remove the event. If there is no matching listener registered, a call to this function has no effect.Parameters
-
listener
: (function) The listener object to remove. -
data
: The data parameter that is used while registering the event.
-
- World:setDebugDraw()
-
Registers a b2.DebugDraw instance for debug drawing.
- World:setGravity(gravityx, gravityy)
-
Sets the gravity vector.
Parameters
-
gravityx
: (number) the x component the gravity -
gravityy
: (number) the y component the gravity
-
- World:step(timeStep, velocityIterations, positionIterations)
-
Take a time step.
This performs collision detection, integration, and constraint solution.
Parameters
-
timeStep
: (number) the amount of time to simulate, this should not vary -
velocityIterations
: (number) for the velocity constraint solver -
positionIterations
: (number) for the position constraint solver
-


Home
About us
Contact
Recipe Book
Vegetable-Spring-Rolls
Info
Time
1:00 H
Preparation
30 Minutes
Servings
5
Ingredients
1
2 tsp oil
2
2 garlic cloves, finely chopped
3
1 inch ginger, finely chopped
4
1 carrot, thinly shredded
5
4 spring onions, finely chopped
6
1 cup cabbage, thinly shredded
7
1 tsp sugar
8
1-2 tsp chilli sauce
9
1 tsp soy sauce / soya sauce
10
1 tsp salt
11
2 tsp vinegar
12
1 tsp black pepper, crushed
13
1 tsp corn flour
14
7 spring roll pastry sheets
15
oil for deep frying
Directions
Firstly, in a large kadai add oil along with finely chopped ginger and garlic,finely chopped spring onions.
Furthermore, add shredded carrot and cabbage. saute them.
Also add sugar, chilli sauce, soy sauce, vinegar, black pepper and salt, mix everything well.
Take spring roll pastry sheet and place spoonful of prepared stuffing.
Pull and fold over the corner tightly till it reaches half the sheet.
Furthermore, fold over sides like a envelope leaving no air pockets.
Deep fry till they turn golden brown stirring occasionally..
Once they turn golden brown, drain them over absorbent paper.
Finally, serve crispy veg spring rolls hot with sweet chilli sauce or tomato sauce.
Go to back to recipes.


“Natthi koci bhavo nicco,
saṅkhārā vāpi sassatā;
Uppajjanti ca te khandhā,
cavanti aparāparaṁ.
No life is permanent,
and no conditions last forever.
The aggregates are reborn
and pass away, again and again.
Etamādīnavaṁ ñatvā,
bhavenamhi anatthiko;
Nissaṭo sabbakāmehi,
patto me āsavakkhayo”ti.
Itthaṁ sudaṁ āyasmā uttaro thero gāthāyo abhāsitthāti.
Knowing this danger,
I don’t need another life.
I’ve escaped all sensual pleasures,
and attained the ending of defilements.
It was thus that these verses were recited by the senior venerable Uttara.


This is a collection of live concert information. The goal of this site is to help you find live concert recordings. The data served here is updated periodically. If you need the latest data use etreedb.org


High resolution digital terrain models (DTM) of Mars are created from HiRISE stereo pairs provided by University of Arizona.
Product type: digital elevation model
Instrument: Mars Reconnaissance Orbiter (MRO) / High Resolution Imaging Science Experiment (HiRISE)


Telegram bot using webscript.io
Posted: | More posts about lua telegram webscript
Telegram recently released their official Bot API. It make writing bot so easy compared to building your own client using the client API.
The only requirement for your bot is that an HTTPS endpoint that you can tell TG where to forward the incoming message from user. Being an HTTPS endpoint, it mean you need to have a valid SSL cert for your domain (if you haven't got one yet).
Another option is to use free hosting that provide you with HTTPS endpoint. There are a number of them. Among others:-
- Heroku - Provide HTTPS endpoint for .herokuapp.com
- Openshift - https://yourname-appname.rhc-cloud.com/
- Google App Engine - https://yourname.appsppot.com/
To test directly from your laptop, use service such as ngrok.com.
But in this post I want to mention another alternative that is using webscript.io script as endpoint for TG bot. After signing up to the service, just create new Lua script like below:-
Then you need to create your bot using BotFather through your Telegram app. Once you get the auth token, replace tg_token
variable in the script above with your auth token. Before the script can start accepting messages from Telegram, you need to tell TG using the setWebhook
API method. So you have to make a request to the webscript endpoint yourself like:-
curl 'https://demo-xxxx.webscript.io/script?admin_command=setURL&pass=xxxx'
If there's no error, all set now. You can also check the logging that Webscript.io provide to check for any error.
The only downside of Webscript.io is that it's not free. The script created under the free account will only last for 7 days. With the same amount of money, you can get a small VPS from Digital Ocean to run the bot + some other stuff as well. But if you're not interested in maintaining another server then this is a great service. This can also be your great excuse to learn Lua ;)


TODO
TODO, citing [[RDF-STAR-FOUNDATION]]
TODO (the purpose of this section will be to provide an informal introduction to the approach for practitioners)
The syntax of RDF is defined in two layers:
Similarly, this document defines the abstract syntax of RDF* in , and one concrete syntax based on Turtle [[TURTLE]] in .
An RDF* graph is a set of RDF* triples.
An RDF* triple is a 3-tuple defined recursively as follows:
As for RDF triples, we call the 3 components of an RDF* triple its subject, predicate and object, respectively. From the definitions above, it follows that any RDF graph is also an RDF* graph. Note also that, by definition, an RDF* triple cannot contain itself and cannot be nested infinitely.
IRIs, literals, blank nodes and RDF* triples are collectively known as RDF* terms.
For every RDF* triple t, we define its constituent terms (or simply constituents) as the set containing its subject, its predicate, its object, plus all the constituent terms of its subject and/or its object if they are themselves RDF* triples. By extension, we define the constituent terms of an RDF* graph to be the union set of the constituent terms of all its triples.
Its set of constituent terms comprises the IRIs `:name`, `:statedBy`, `:bob`, the blank node `_:a`, the literal `"Alice"`, and the triple `<< _:a :name "Alice" >>`.
An RDF* triple used as the subject or object of another RDF* triple is called an embedded triple. An RDF* triple that is an element of an RDF* graph is called an asserted triple. Note that, in a given RDF* graph, the same triple MAY be both embedded and asserted.
An RDF* dataset is a collection of RDF* graphs, and comprises:
Again, this definition is an extension of the notion of RDF dataset, hence it follows that any RDF dataset is also an RDF* dataset.
In this section, we present Turtle*, an extension of the Turtle format [[TURTLE]] allowing to represent RDF* graphs. For the sake of conciseness, we only describe here the differences between Turtle* and Turtle.
Turtle* is defined to follow the same grammar as Turtle, except for the EBNF productions specified below, which replace the productions with the same number (if any) in the original grammar.
| [10] | `subject` | ::= | iri `|` BlankNode `|` collection `|` embTriple |
| [12] | `object` | ::= | iri `|` BlankNode `|` collection `|` blankNodePropertyList `|` literal `|` embTriple |
| [27] | `embTriple` | ::= |
'<<'
embSubject
verb
embObject
'>>'
|
| [28] | `embSubject` | ::= | iri `|` BlankNode `|` embTriple |
| [29] | `embObject` | ::= | iri `|` BlankNode `|` literal `|` embTriple |
The only changes are that `subject` and `object` productions have been extended to accept embedded triples, which are described by the new productions 27 to 29. Note that embedded triples accept a more restricted range of subject and object expressions than asserted triples.
A Turtle* parser is similar to a Turtle parser as defined in Section 7 of the Turtle specification [[TURTLE]], with an additional item in its state :
Additionally, the |curSubject| can be bound to any RDF* term (including a embedded triple).
A Turtle* document defines an RDF* graph composed of a set of RDF* triples. The `subject` and `embSubject` productions sets the |curSubject|. The `verb` production sets the |curPredicate|. The `embObject` productions sets the |curObject|. For each `object` |N|, an RDF* triple |curSubject| |curPredicate| |N| is generated and added to the RDF* graph.
Beginning the `embTriple` production records the |curSubject| and |curPredicate|. Finishing the `embTriple` production yields the RDF* triple |curSubject| |curPredicate| |curObject| and restores the recorded values of |curSubject| and |curPredicate|.
All other productions MUST be handled as specified by Section 7 of the Turtle specification [[TURTLE]], while still applying the changes above recursively.
While this document specifies only one concrete syntax, nothing prevents other concrete syntaxes of RDF* to be proposed. In particular, other existing concrete syntaxes for RDF, such as RDF/XML [[RDF-SYNTAX-GRAMMAR]], could be extended to support RDF*. In particular, the N-Triples syntax [[N-TRIPLES]] being a subset of Turtle, an appropriate subset of Turtle* could be defined to extend N-Triples accordingly.
This Section introduces SPARQL*, which is an RDF*-aware extension of the RDF query language SPARQL [[SPARQL11-QUERY]]; i.e., SPARQL* can be used to query RDF* graphs.
In the following, we introduce a number of SPARQL* specific definitions, which rely on the following notions, defined in [[[SPARQL11-QUERY]]] [[SPARQL11-QUERY]]: RDF term, query variable, triple pattern, property path pattern, property path expression, and solution mapping.
A SPARQL* triple pattern is a 3-tuple that is defined recursively as follows:
As for RDF* triples, a SPARQL* triple pattern MUST NOT contain itself.
A SPARQL* basic graph pattern (BGP*) is a set of SPARQL* triple patterns.
A SPARQL* property path pattern is a 3-tuple (|s|,|p|,|o|) where
A SPARQL* solution mapping μ is a partial function from the set of all query variables to the union set of all RDF* terms. The domain of μ, denoted by dom(μ), is the set of query variables for which μ is defined.
The notion of a SPARQL* solution mapping extends the notion of a standard SPARQL solution mapping; that is, every SPARQL solution mapping is a SPARQL* solution mapping. However, in contrast to SPARQL solution mappings, SPARQL* solution mappings may map variables also to RDF* triples.
SPARQL* is defined to follow the same grammar as SPARQL, except for the EBNF productions specified below, which replace the productions with the same number (if any) in the original grammar.
| [60] | `Bind` | ::= |
'BIND'
'('
(
Expression `|`
EmbTP
)
'AS'
Var
')'
|
| [75] | `TriplesSameSubject` | ::= | VarOrTermOrEmbTP PropertyListNotEmpty `|` TriplesNode PropertyList |
| [80] | `Object` | ::= | GraphNode `|` EmbTP |
| [81] | `TriplesSameSubjectPath` | ::= | VarOrTermOrEmbTP PropertyListPathNotEmpty `|` TriplesNode PropertyListPath |
| [105] | `GraphNodePath` | ::= | VarOrTermOrEmbTP `|` TriplesNodePath `|` |
| [174] | `EmbTP` | ::= |
'<<
EmbSubjectOrObject
Verb
EmbSubjectOrObject
'>>
|
| [175] | `EmbSubjectOrObject` | ::= | Var `|` BlankNode `|` iri `|` RDFLiteral `|` NumericLiteral `|` BooleanLiteral `|` EmbTP |
| [176] | `VarOrTermOrEmbTP` | ::= | Var `|` GraphTerm `|` EmbTP |
This introduces a notation for embedded triple patterns (productions [174] and following), which is similar to the one defined for embedded triples in , but accepting also variables. These embedded triple patterns are allowed in subject ([75], [81]) and object ([80], [105]) position of SPARQL* triple patterns, as well as in BIND statements ([60]).
Based on the SPARQL grammar the SPARQL specification defines the process of converting graph patterns and solution modifiers in a SPARQL query string into a SPARQL algebra expression
[SPARQL11-QUERY, Section 18.2]. This process must be adjusted to consider the extended grammar introduced above. In the following, any step of the conversion process that requires adjustment is discussed.
As a basis of the translation, the SPARQL specification introduces a notion of in-scope variables. To cover the new syntax elements introduced in this notion MUST be extended as follows.
not [be] in-scope from the preceeding elements in the group graph pattern in which [the BIND clause] is used[SPARQL11-QUERY, Section 18.2.1]].
The translation process starts with expanding abbreviations for IRIs and triple patterns
[SPARQL11-QUERY, Section <IP_ADDRESS>]. This step MUST be extended in two ways:
Abbreviations for triple patterns with embedded triple patterns MUST be expanded as if each embedded triple pattern was a variable (or an RDF term).
must be expanded to
Abbreviations for IRIs in all embedded triple patterns MUST be expanded.
must be expanded to
The translation of property path patterns has to be adjusted because the extended grammar allows for property path patterns whose subject or object is an embedded triple pattern (cf. ).
The translation as specified in the W3C specification distinguishes four cases. The first three of these cases do not require adjustment because they are taken care of either by recursion or by the adjusted translation of basic graph patterns (as defined in below). However, the fourth case MUST be adjusted as follows.
Let |X| |P| |Y| be a string that corresponds to the fourth case in [SPARQL11-QUERY, Section <IP_ADDRESS>]. Given the grammar introduced in , |X| and |Y| may be an RDF term, a variable, or an embedded triple pattern, respectively (and |P| is a property path expression). The string |X| |P| |Y| is translated to the algebra expression `Path`(X’,|P|,Y’) where X’ and Y’ are the result of calling a function named `Lift` for |X| and |Y|, respectively. For some input string |Z| (such as |X| or |Y|) that can be an RDF term, a variable, or an embedded triple pattern, the function `Lift` is defined as follows:
After translating property path patterns, the translation process collects any adjacent triple patterns [...] to form a basic graph pattern
[SPARQL11-QUERY, Section <IP_ADDRESS>]. This step has to be adjusted because triple patterns in the extended syntax may have an embedded triple pattern in their subject position or in their object position (or in both). To ensure that every result of this step is a BGP*, before adding a triple pattern to its corresponding collection, its subject and object MUST be replaced by the result of calling function `Lift` for the subject and the object, respectively.
The extended grammar in allows for BIND clauses with an embedded triple pattern. The translation of such a BIND clause to a SPARQL algebra expression requires a new algebra symbol:
Note that this symbol corresponds to SPARQL* expressions of the form (`tp` AS `?v`).
Then, any string of the form `BIND( T AS v )` with |T| being an embedded triple pattern (i.e., not a standard BIND expression) is translated to the algebra expression `TR`(T’, |v|) where T’ is the result of the function `Lift` for |T|.
Notice, the translation of BIND clauses with an embedded triple pattern as defined in this section is used during the translation of group graph patterns. The case of BIND clauses with an embedded triple pattern is covered in this translation of group graph patterns by the last, “catch all other” `IF` statement (i.e., the `IF` statement with the condition `E is any other form`) and not by the `IF` statement for BIND clauses with an expression.
TODO here the definitions of SPARQL* expression, evaluation...
The SPARQL specification defines a function eval(D(G), algebra expression) as the evaluation of an algebra expression with respect to a dataset D having active graph G
[SPARQL11-QUERY, Section 18.6]. Recall that the active graph |G| in the context of SPARQL* is an RDF* graph, and so is any other graph in dataset |D|. The definition of function eval is recursive; the two base cases of this definition for SPARQL* are given as follows:
For any other algebra expression, the SPARQL specification defines algebra operators [[SPARQL11-QUERY]]. These definitions can be extended naturally to operate over multisets of SPARQL* solution mappings (instead of ordinary solution mappings). Given this extension, the recursive steps of the definition of function eval for SPARQL* are the same as in the SPARQL specification.
TODO: brief introduction paragraph (including a note that result of a CONSTRUCT query or a DESCRIBE query can be serialized using Turtle*)
In this section, we provide a model-theoretic semantics for RDF*, by extending the one defined in [[[RDF11-MT]]] [[RDF11-MT]].
An RDF* simple interpretation |I| is a structure consisting of:
This definition is identical to the definition of simple interpretation [[RDF11-MT]] up to item 5 included. Items 6 and 7 extend it to support RDF* triples. As a consequence, any RDF simple interpretation can be considered as an RDF* simple interpretation with |IT|=|ITEXT|=∅.
We say that an RDF* graph is ground if its set of constituent terms contains no blank node. This is a generalization of the notion of ground RDF graph [[RDF11-MT]]. The denotation of a ground RDF* graph in an RDF* simple interpretation |I| is then given by the following rules, where the interpretation is also treated as a function from expressions (terms, triples and graphs) to elements of the universe and truth values:
Since |IL| and |IT| are partial mappings, |I|(|E|) may be undefined for some literal or embedded triple |E|. In that case, |E| has no semantic value in |I|, so any triple containing it will be false, hence any graph containing that triple will also be false.
An invertible mapping from the set blank nodes into itself is called a blank node renaming. By extension, we define the application of a blank node renaming |R| to other RDF* terms and to RDF* graphs as follow:
Suppose |I| is an RDF* simple interpretation and |A| is a mapping from a set of blank nodes to the universe |IR| of |I|. Define the mapping [|I|+|A|] of RDF* terms into |IR| to be |A| on blank nodes of the set, and |I| on any other term; and extend this mapping to RDF* triples and RDF* graphs using the rules given above for ground graphs. Then the denotation of any RDF* graph in |I| is given by:
Following [[[RDF11-MT]]], we extend the notions of satisfiability and entailment. An RDF* simple interpretation satisfies |E| when |I|(|E|)=true. |E| is (simply) satisfiable when an RDF* simple interpretation exists which satisfies it, otherwise (simply) unsatisfiable. An RDF* graph |G| simply entails an RDF* graph H when every interpretation which satisfies |G| also satisfies |H|. If two RDF* graphs |G| and |H| each entail the other then they are logically equivalent.
Any semantic extension of RDF MAY be extended to RDF* by replacing the semantic conditions, the notion of satisfiability and the notion of entailment, defined in [[[RDF11-MT]]], by their corresponding extension defined above. This is notably the case for Datatype entailment and RDFS entailment.
In this section, we discuss a number of desired features of RDF* semantics, in order to shed light on the design choices made in the previous section
RDF* must be able to quote a triple without asserting it, so that we can represent peoples' beliefs without endorsing them, or facts are no longer or not yet true. This is ensured by the fact that the semantic condition on embedded triples (introduced for in RDF*) is different from the one on asserted triples (inherited from RDF).
For example, the following graph:does not entail `:bob :name "Charlie"`, and the SPARQL* query below executed against the graph above would return no result.
Blank nodes in embedded triples have the same scope as blank nodes used in the subject or object position of asserted triples (usually the whole graph or the whole dataset in which they appear). This means that the same blank node identifier used in different embedded triples, or at different levels of nesting, will refer to the same thing.
For example, in the following graph:
the three occurrence of `_:x` must refer to the same resource in every interpretation of the graph. In other words, it must be the same resource that Alice knows, that she believes is named "Charlie", and that she believes works for ACME.
As a consequence, the following query will return `"Charlie"`:
As another consequence, the following graph does not entail the graph above (because the graph below allows the resource known by Alice to be different from the one about which she has beliefs).
Formally, the second graph is satisfied by an interpretation where:
but this interpretation can not satisfy the first graph, because the mapping `A` must map `_:x` to both Y (to satisfy |IEXT|(K)) and to X (to satisfy |ITEXT|(T1) and |ITEXT|(T2)).
Embedded triples are referentially opaque, meaning that triples using different terms are considered different, even if their terms can be inferred to be synonyms. Although RDF* simple entailment has no mean to entail any kind of synonymy, it is possible in some semantic extensions, such as OWL [[OWL2-RDF-BASED-SEMANTICS]].
A well known example is the superman problem:
Intuitively: this graph states that Superman and Clark Kent are the same person, so if Superman can fly, then it follows that Clark Kent can as well. So, under OWL2-entailment, this graph entails `:clarkKent :can :fly`. However, Lois Lane does not know that Superman and Clark Kent are the same person. So from her point of view, the two triples are not equivalent, and she can believe one without believing the other.
Referential opacity is ensured by differentiating the intension of embedded triples (represented by the |IT| mapping) from their extension (represented by |ITEXT|). Since |IT| is based solely on the syntax of triples, two syntactically different triples can always have different intentions, even if they are semantically equivalent (i.e. their extensions are identical).
In standard RDF, renaming a blank node does not change the semantics of a graph (provided that the new name was not already in use in that graph). This is ensured by the fact that RDF simple interpretations do not depend on blank node identifiers at all. In RDF*, however, because of the need for referential opacity, the |IT| mapping does depend on the blank node identifiers used in the embedded triple. This is why the notion of satisfiability in RDF additionally relies on a blank node renaming.
Consider the following graph:
Every interpretation satisfying this graph must have, for some A, B, C, N, T and X:
Any such interpretation can be shown to also satisfy the graph below:
For this, we must chose |R| such that |R|(`_:y`)=`_:x`, and |A| such that |A|(`_:x`)=X.


Academic/Research Publications
AIAA Guidance, Navigation, and Control Conference (AIAA SciTech Forum), Virtual Event, USA, 11th-19th Jan 2021.
IEEE Control Systems Letters 5 (5), 1573-1578, 2021.
AIAA Journal of Guidance, Control, and Dynamics, article in advance, 2020.
AIAA Journal of Guidance, Control, and Dynamics, article in advance, 2020.
IEEE TechRxiv, 2020.
IEEE Transactions on Aerospace and Electronic Systems 56 (5), 3556-3565, 2020.
International Journal of Control 93 (4), 858-871, 2020.
IEEE Transactions on Cybernetics 50 (7), 3254-3263, 2020.
American Control Conference (ACC), Denver, USA, 1st-3rd Jul 2020.
American Control Conference (ACC), Denver, USA, 1st-3rd Jul 2020.
IFAC PapersOnLine, 53 (1), 93–98, 2020, Awarded Best Paper.
AIAA Guidance, Navigation, and Control Conference (AIAA SciTech Forum), Orlando, USA, 6th-10th Jan 2020.
IEEE Transactions on Cybernetics 49 (12), 4450-4459, 2019.
European Journal of Control 45, 30-44, 2019.
International Journal of Communication Systems 33 (10), e4206, 2019.
6th Indian Control Conference (ICC), Hyderabad, India, 18th-20th Dec 2019.
Chemical Engineering Science 187, 52-59, 2018.
AEU– International Journal of Electronics and Communication, 90, 155-162, 2018.
IFAC PapersOnLine, 51 (1), 401–406, 2018.
IEEE 3rd International Conference for Convergence in Technology, Pune, India, 7th-8th Apr 2018.
accepted, IEEE Symposium Series on Computational Intelligence, Bengaluru, India, 18th-21st Nov 2018.
ArXiv e-prints, 2017.
Foundations and Frontiers in Computer, Communication and Electrical Engineering, Taylor and Francis, 2016.
Foundations and Frontiers in Computer, Communication and Electrical Engineering, Taylor and Francis, 2016.
International Journal of Electronics and Communication Technology, 61 (1), 32-37, 2015.
IEEE Power, Communication and Information Technology Conference (PCITC), Bhubaneswar, India, 15th-17th Oct, 2015.
IEEE International Conference on Innovations in Information, Embedded and Communication Systems (ICIIECS), Coimbatore, India, 19th-20th Mar 2015.
IEEE International Conference on Innovations in Information, Embedded and Communication Systems (ICIIECS), Coimbatore, India, 19th-20th Mar 2015.
IEEE International Conference on Innovations in Information, Embedded and Communication Systems (ICIIECS), Coimbatore, India, 19th-20th Mar 2015.
IEEE International Conference on Computing Communication Control and Automation (ICCUBEA), Pune, India, 26th-27th Feb 2015, Awarded Best Paper.
IEEE International Conference on Computational Intelligence and Networks (CINE), Bhubaneswar, India, 12th-13th Jan 2015.
7th IEEE International Conference on Information and Automation for Sustainability (ICIAfS), Colombo, Sri Lanka, 22nd-24th Dec 2014.
IEEE International Conference on Control, Automation, Robotics and Embedded Systems (CARE), Jabalpur, India, 16th-18th Dec 2013.


This update removes id stubbing and replaces with unique counters.
The Iteration controller allows multidemnsional arrays to be iterated in a controlled manner. Without an IterationController, a multidimensional array is rendered as a flattened (single dimension) list. This is so because each iterable object (array) is iterated when it is encountered: so if the 1st element in an array is also an array, the first element is iterated, then the second element of the top-level array is adressed and it too is iterated and so on recursively.
To allow a multi-dimensional array to be rendered in a more controlled fashion, for example as a table with rows and columns, an IterationController instruction can be used. This takes the form of {{iterationId:scopeObjectName}}. When an element 'id' attribute takes this form, the IterationController function is activated.
IterationController differs from simple iteration in that simple iteration will repeat any element whos id matches an the name of an iterable object (an array) in the current scope, whereas an IterationController will repeat the elements enclosed by the element containing the IterationInstruction, but not the enclosing element itself. This makes it suitable for rendering a two- or multi-dimensional array as a table.
Note: It is recommended to use the iteration Controller on a tbody elements rather than the table element - if used on the table the IterationController will create each row in its own tbody element, whereas if the controller is on an explicit tbody in the template, all rows will occupy the same tbody element, making a neater table in the Document Object Model.
This class name added to a template causes the template to be elaborated in-place and on page load (actually, as soon as the DOM is available). The template is elaborated using whatever object matches the template's id attribute in the window scope - i.e. window[template.id]
This version also implements the modelObject.dom as as array of elements modelObject.dt$dom rather than a single DOM element. An model object will be represented by more than one DOM element if it is rendered multiple times. This is a change from the initial prototype and earlier applications need to be aware of this change as it is the only known source of incompatibility.
| [row$index={{row$index}},$index={{$index}}(==col$index{{col$index}}) ] |
| ({{row$index}},{{row$index}}): | First Name: {{first_name}} | Surname: {{surname}} |
| [({{$index}}): First Name: {{first_name}}Surname: {{surname}}] |
| ({{$index}}) | First Name: {{first_name}} | Surname: {{surname}} |


Class: Aws::SecurityLake::Types::SubscriberResource
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb |
Overview
Provides details about the Amazon Security Lake account subscription. Subscribers are notified of new objects for a source as the data is written to your Amazon S3 bucket for Security Lake.
Constant Summary
Instance Attribute Summary
-
#access_types ⇒ Array<String>
rw
You can choose to notify subscribers of new objects with an Amazon Simple Queue Service (Amazon
::Aws::SQS
) queue or through messaging to an HTTPS endpoint provided by the subscriber. -
#created_at ⇒ Time
rw
The date and time when the subscriber was created.
-
#resource_share_arn ⇒ String
rw
The Amazon
::Aws::SecurityLake::Resource
Name (ARN) which uniquely defines the AWS RAM resource share. -
#resource_share_name ⇒ String
rw
The name of the resource share.
-
#role_arn ⇒ String
rw
The Amazon
::Aws::SecurityLake::Resource
Name (ARN) specifying the role of the subscriber. -
#s3_bucket_arn ⇒ String
rw
The ARN for the Amazon S3 bucket.
-
#sources ⇒ Array<Types::LogSourceResource>
rw
Amazon Security Lake supports log and event collection for natively supported Amazon Web Services.
-
#subscriber_arn ⇒ String
rw
The subscriber
::Aws::ARN
of the Amazon Security Lake subscriber account. -
#subscriber_description ⇒ String
rw
The subscriber descriptions for a subscriber account.
-
#subscriber_endpoint ⇒ String
rw
The subscriber endpoint to which exception messages are posted.
-
#subscriber_id ⇒ String
rw
The subscriber ID of the Amazon Security Lake subscriber account.
-
#subscriber_identity ⇒ Types::AwsIdentity
rw
The AWS identity used to access your data.
-
#subscriber_name ⇒ String
rw
The name of your Amazon Security Lake subscriber account.
-
#subscriber_status ⇒ String
rw
The subscriber status of the Amazon Security Lake subscriber account.
-
#updated_at ⇒ Time
rw
The date and time when the subscriber was last updated.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Aws::Structure#to_h. |
Instance Attribute Details
#access_types ⇒ Array
<String
> (rw)
You can choose to notify subscribers of new objects with an Amazon
Simple Queue Service (Amazon ::Aws::SQS
) queue or through messaging to an
HTTPS endpoint provided by the subscriber.
Subscribers can consume data by directly querying Lake Formation
tables in your Amazon S3 bucket through services like Amazon Athena.
This subscription type is defined as LAKEFORMATION
.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#created_at ⇒ Time
(rw)
The date and time when the subscriber was created.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#role_arn ⇒ String
(rw)
The Amazon ::Aws::SecurityLake::Resource
Name (ARN) specifying the role of the
subscriber.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#s3_bucket_arn ⇒ String
(rw)
The ARN for the Amazon S3 bucket.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#sources ⇒ Array
<Types::LogSourceResource> (rw)
Amazon Security Lake supports log and event collection for natively supported Amazon Web Services. For more information, see the Amazon Security Lake User Guide.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#subscriber_arn ⇒ String
(rw)
The subscriber ::Aws::ARN
of the Amazon Security Lake subscriber account.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#subscriber_description ⇒ String
(rw)
The subscriber descriptions for a subscriber account. The
description for a subscriber includes subscriberName
, accountID
,
externalID
, and subscriberId
.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#subscriber_endpoint ⇒ String
(rw)
The subscriber endpoint to which exception messages are posted.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#subscriber_id ⇒ String
(rw)
The subscriber ID of the Amazon Security Lake subscriber account.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#subscriber_identity ⇒ Types::AwsIdentity (rw)
The AWS identity used to access your data.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#subscriber_name ⇒ String
(rw)
The name of your Amazon Security Lake subscriber account.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#subscriber_status ⇒ String
(rw)
The subscriber status of the Amazon Security Lake subscriber account.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end
#updated_at ⇒ Time
(rw)
The date and time when the subscriber was last updated.
# File 'gems/aws-sdk-securitylake/lib/aws-sdk-securitylake/types.rb', line 1744
class SubscriberResource < Struct.new( :access_types, :created_at, :resource_share_arn, :resource_share_name, :role_arn, :s3_bucket_arn, :sources, :subscriber_arn, :subscriber_description, :subscriber_endpoint, :subscriber_id, :subscriber_identity, :subscriber_name, :subscriber_status, :updated_at) SENSITIVE = [] include Aws::Structure end


Welcome to Font Famous.
Stop wasting time searching Google Images and spinning out in Photoshop trying to format media logos for your site. Show off your recent press mentions with a couple lines of CSS and get back to making fame worthy products.
Easy Implementation
Simply include the Font Famous style sheet in your header and use the following classes to style any element as a logo.
Include the Font Famous style sheet in your <head>
section.
<link rel="stylesheet" href="https://maxcdn.fontfamous.com/css/font-famous.min.css" integrity="sha384-N1vMapL9Y7K4/qgjLNWBx0HRhh/BeJRKrss/nT2Z2te7DVIKN+WopNAfNG2aA19L" crossorigin="anonymous">
What is integrity
?
Set the class of the elements you want to style as a media logo.
<i class="pr pr-techcrunch"></i>


Accuracy (mean of diagonal of confusion matrix) is 42.53%
| Category name | Accuracy | Sample training images | Sample true positives | False positives with true label | False negatives with wrong predicted label | ||||
|---|---|---|---|---|---|---|---|---|---|
| bedroom | 38.00% | office |
livingroom |
tallbuilding |
office |
||||
| coast | 49.00% | store |
highway |
suburb |
industrial |
||||
| forest | 92.00% | opencountry |
opencountry |
suburb |
industrial |
||||
| highway | 65.00% | coast |
coast |
suburb |
coast |
||||
| industrial | 21.00% | insidecity |
store |
livingroom |
bedroom |
||||
| insidecity | 51.00% | tallbuilding |
industrial |
industrial |
industrial |
||||
| kitchen | 27.00% | bedroom |
livingroom |
insidecity |
office |
||||
| livingroom | 19.00% | tallbuilding |
kitchen |
office |
bedroom |
||||
| mountain | 44.00% | suburb |
suburb |
store |
highway |
||||
| office | 52.00% | bedroom |
kitchen |
bedroom |
industrial |
||||
| opencountry | 35.00% | coast |
coast |
highway |
industrial |
||||
| store | 25.00% | insidecity |
forest |
bedroom |
industrial |
||||
| street | 24.00% | insidecity |
store |
livingroom |
suburb |
||||
| suburb | 74.00% | industrial |
opencountry |
highway |
insidecity |
||||
| tallbuilding | 22.00% | street |
kitchen |
industrial |
insidecity |
||||
| Category name | Accuracy | Sample training images | Sample true positives | False positives with true label | False negatives with wrong predicted label |


Welcome {{ currentPassanger.name }} (go to plane view)
You are now changing flight {{currentPlane.name}}


|
Spacer
|
This is sample HTML for a very simple utility tag that simply creates a specified amount of vertical and horizontal "white space". The idea is that the tag will allow developers to specify three things:
This tag simply stretches a 1px x 1px transparent gif to the specified size. If the tag is specified to force a line break, the image is placed inside a
 tag. Because the gif is transparent, the image will pick up the background color of whatever its parent container is (e.g., the page, a table cell, etc.). To ensure that screen readers ignore the image, its alt attribute must always be set as follows: alt=""
So if the developer specifies 20px of vertical and a line break, the tag would set down something like this:

If 10 pix of horizontal were specified, the tag would lay down something like this:

Several implementation alternatives were evaluated in prior releases before deciding upon the spacer gif approach. These included the following:
It proved impractical to remove them from the current release and so they remain.


thai peacock
219 sw 9th ave portland,or 97205 |<PHONE_NUMBER><EMAIL_ADDRESS>Home
Recognition
About
Menu+Cater
Gallery
‹
›
Home
Recognition
About
Menu+Cater
Gallery


| Classes Summary | |
|---|---|
| Luminor | Banklink settings for Luminor. For more information, please visit: https://www.luminor.ee/en/e-payment |
| Nordea | Banklink settings for Nordea. For more information, please visit: http://www.nordea.ee/Corporate%20customers/Daily%20banking/Collection%20of%20payment/E-payment/798312.html |
| Liisi | Settings for Liisi payment link. For more information, please visit: https://klient.liisi.ee/static/payment_link_doc/ |
| Swedbank | Banklink settings for Swedbank. For more information, please visit: https://www.swedbank.ee/business/cash/ecommerce/banklink |
| Estcard | Banklink settings for Estcard. For more information, please visit: http://www.estcard.ee/publicweb/files/ecomdevel/e-comDocENG.html |
| Danskebank | Banklink settings for Danske bank. For more information, please visit: https://danskebank.ee/-/media/pdf/danske-bank/ee/ee/ettevottele/elektroonilised-kanalid/bank-link/active/pangalingi-tehniline-spetsifikatsioon-est-.-la=et-ee.pdf |
| SEB | Banklink settings for SEB. For more information, please visit: http://www.seb.ee/eng/business/everyday-banking/collection-payments/collection-payments-internet |
| LHV | Banklink settings for LHV. For more information, please visit: https://www.lhv.ee/en/banking-services/banklink/?l3=en |
| Pocopay | Banklink settings for Pocopay. For more information, please visit: https://pocopay.com/ |
| CoopPank | Banklink settings for Coop Pank. For more information, please visit: https://www.cooppank.ee/en/bank-link |


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
BBlock interface:
Interface for basic block class BBlock.
Data flow analysis and basic control flow analysis are done
based on the graph of basic blocks.
All methods other than static ones are a method used for
BBlock object ("this" is a BBlock instance).
Structure of basic blocks:
Input program represented in HIR or LIR is decomposed into
basic blocks. Control flow of the program can be represented
by a graph of basic blocks connected by predecessor/successor
relation. Information of the basic block is represented by
an object of BBlock class.
Contents of a basic block can be treated as a sequence of subtrees
which may be either HIR subtree or LIR subtree.
Such subtree is called a "top-subtree".
The top-subtree of HIR may represent a part of statement or
expression where some other part of the statement or expression
may be included in different basic blocks. For LIR, on the other hand, an LIR subtree is just a member of the aforementioned sequence, and there are no links or complex relations between LIR subtrees.
An HIR statement attached with label (LabeledStmt)
starts a new basic block.
If an HIR expression has label definition, it starts a new basic block(This may change in the future).
Depth first traversal of HIR tree from left to right represents
a sequence of HIR nodes. In this traversal, if an HIR statement
node is encountered, it starts a new top-subtree.
If a top-subtree is an expression subtree and another
expression subtree or statement subtree without label definition
succeeds immediately after the top-subtree, then the
succeeding subtree is treated as the next top-subtree.
The LIR top-subtree represents an LIR instruction.
In LIR flow analysis, a basic block is composed of a list of
LIR top-subtees (LIR instructions). LIR basic block is based solely on the flow of control. The control flow graph LIR basic blocks form will therefore be "irreducible".
Data flow analysis are done on the graph of basic blocks
and most of data flow information is associated with basic blocks.
The graph of basic blocks can be get from a SubpFlow object, which corresponds to a subprogram.
While HIR flow analysis and optimization can be thought of as utilizing the information supplied by the control flow graph, LIR flow analysis/optimization are done totally based on the control flow graph. An LIR basic block object holds the whole LIR subtree sequence that are associated to the basic block object, while in HIR there is only a link between the the basic block and the LabeledStmt
that signifies the start of the basic block. A SetRefRepr
class that wraps an HIR statement/LIR instruction along with its collection class SetRefReprList
will blur the distinction, however.
Relation between control flow and data flow:
This class provides accessor methods for data flow information for convinience, but actual data flow information is stored in an external object, namely, a FlowResults
object. When there is a modification of code that changes data flow but not control flow, the data flow information the external object holds must be cleared, but the control flow information this class holds will remain valid.
Methods listed here are used after flow analysis to get
information or to modify control flow.
(There may be many methods private to flow analysis
modules other than the methods listed below.)
When control flow is changed, data flow information
may not be consistent because data flow information
is not automatically updated by the control flow
modification. In order to make them consistent,
it is necessary to do data flow analysis again
after a group of control flow modifications are
completed.
| Method Summary | |
void |
addEdge(Exp pConditionalExp,
BBlock pToBlock)
addEdge: Add edge from this block to pToBlock that is to be taken when pConditionalExp is true. |
void |
addToPredList(BBlock pPred)
addToPredList: addToSuccList: Add the basic block pPred/pSucc to the list of predecessors/successors of this basic block, and this block is added to the list of successors/predecessors of pPred/pSucc. |
void |
addToSuccList(BBlock pSucc)
|
BBlockNodeIterator |
bblockNodeIterator()
|
BBlockSubtreeIterator |
bblockSubtreeIterator()
bblockSubtreeIterator: Create an iterator to traverse all top-subtree in this basic block. |
void |
changePredEdge(BBlock pBefore,
BBlock pAfter)
|
void |
changeSuccEdge(BBlock pBefore,
BBlock pAfter)
changeEdge: Change the edge between this block and pBefore to a new edge between this block and pAfter. |
void |
deleteBBlock()
deleteBBlock: Delete this block and add successors of this block to the set of successors of all predecessors of this block. |
void |
deleteEdge(BBlock pToBlock)
deleteEdge: Delete the edge from this block to pToBlock and adjust related addresses and links so as to keep consistency. |
void |
deleteFromPredList(BBlock pPred)
deleteFromPredList: deleteFromSuccList: Delete the basic block pPred/pSucc from to the list of predecessors/successors of this basic block, and this block is deleted from the list of successors/predecessors of pPred/pSucc. |
void |
deleteFromSuccList(BBlock pSucc)
|
void |
fuseSuccessor(BBlock pToBlock)
fuseSuccessor: Fuse the successor pToBlock with this block and make all successors of pToBlock as successors of this block. |
int |
getBBlockNumber()
getBBlockNumber: Get the block number attached to this basic block. |
ExpVector |
getDAvailIn()
getAvailIn: Get bit vector showing AvailIn set of this block. |
ExpVector |
getDAvailOut()
getAvailOut: Get bit vector showing AvailOut set of this block. |
FlowAnalSymVector |
getDDefIn()
getDefIn: Get bit vector showing DefIn set of this block. |
FlowAnalSymVector |
getDDefined()
getDDefined: Get bit vector showing DDefined set of this block. |
FlowAnalSymVector |
getDDefOut()
getDefOut: Get bit vector showing DefOut set of this block. |
ExpVector |
getDEGen()
getEGen: Get bit vector showing DEGen set of this block. |
FlowAnalSymVector |
getDExposed()
getDExposed: Get bit vector showing DExposed set of this block. |
DefVector |
getDKill()
getDKill: Get bit vector showing DKill set of this block. |
java.util.List |
getDomForSubpFlow()
Get the list of BBlock s that dominate this BBlock in the SubpFlow this BBlock belongs to. |
java.util.List |
getDominatedChildrenForSubpFlow()
getDominatedChildren: setDominatedChildren: Get/set the list of basic blocks immediately dominated by this block. |
FlowAnalSymVector |
getDUsed()
getDUsed: //##12 Get bit vector showing DUsed set of this block. |
BBlock |
getImmediateDominatorForSubpFlow()
getImmediateDominator: Get/set a basic block immediately dominating this block. |
BBlock |
getImmediatePostdominatorForSubpFlow()
getImmediatePostDominator: Get a basic block immediately post dominating this block. |
IR |
getIrLink()
getIrLink: Get the top-subtree that starts this basic block. |
Label |
getLabel()
getLabel: Get a label attached to the first top-subtree of this basic block. |
DefVector |
getPDef()
getPDef: Get bit vector showing PDef set of this block. |
FlowAnalSymVector |
getPDefined()
getPDefined: Get bit vector showing PDefined set of this block. |
ExpVector |
getPEKill()
getEKill: Get bit vector showing EKill set of this block. |
FlowAnalSymVector |
getPExposed()
getPExposed: Get bit vector showing PExposed set of this block. |
DefVector |
getPKill()
getPKill: Get bit vector showing PKill set of this block. |
FlowAnalSymVector |
getPLiveIn()
getLiveIn: Get bit vector showing LiveIn set of this block. |
FlowAnalSymVector |
getPLiveOut()
getLiveOut: Get bit vector showing LiveOut set of this block. |
java.util.List |
getPostdomForSubpFlow()
|
java.util.List |
getPostdominatedChildrenForSubpFlow()
getPostDominatedChildren: setPostDominatedChildren: Get/set the list of basic blocks post dominated by this block. |
DefVector |
getPReach()
Returns the PReach. |
Edge |
getPredEdge(BBlock pFromBBlock)
getPredEdge: getSuccEdge: Get the edge corresponding to the predecessor/successor to/from this basic block. |
java.util.List |
getPredList()
getPredList: getSuccList: Get the predecessor/successor list of this basic block. |
FlowAnalSymVector |
getPUsed()
getPUsed: //##12 Get bit vector showing PUsed set of this block. |
SetRefReprList |
getSetRefReprs()
Gets the SetRefReprList object that is the list of SetRefRepr objects, each of which wrap a statement/instruction. |
java.util.List |
getStrictDomForSubpFlow()
Get the strict dominator for this BBlock in the SubpFlow this BBlock belongs to. |
java.util.List |
getStrictPostdomForSubpFlow()
|
SubpFlow |
getSubpFlow()
Returns the SubpFlow object this BBlock belongs to. |
Edge |
getSuccEdge(BBlock pToBBlock)
|
java.util.List |
getSuccList()
|
java.lang.Object |
getWork()
getWork: setWork: get/set information privately used in each phase. |
boolean |
isDAvailIn(FlowExpId pExpId)
isAvailIn: See if the expression represented by pExpId is available (value is always computed) at entry to this block. |
boolean |
isDAvailOut(FlowExpId pExpId)
isAvailOut: See if the expression represented by pExpId is available (value is always computed) at exit from this block. |
boolean |
isDDef(SetRefRepr pSetRefRepr)
isDef: See if definition at position pPos is done in this block. |
boolean |
isDDefIn(Sym pSym)
isDefIn: See if pSym is always defined at entry to this block whichever path may be take. |
boolean |
isDDefined(Sym pSym)
isDefined: See if the value of pSym is defined in this block. |
boolean |
isDDefOut(Sym pSym)
isDefOut: See if pSym is always defined at exit from this block. |
boolean |
isDEGen(FlowExpId pExpId)
isEGen: See if expression designated by pReg is generated (computed in this block and afterwards its operand is not changed) in this block. |
boolean |
isDExposed(Sym pSym)
isExposed: See if the variable of pSym is used in this block without setting its value in this block. |
boolean |
isDKill(SetRefRepr pSetRefRepr)
isKill: See if definition at position pPos is killed in this block. |
boolean |
isDUsed(Sym pSym)
isUsed: //##12 See if the value of pSym is used in this block. |
boolean |
isEntryBBlock()
isEntryBlock: See if this block is the entry block in the graph of basic blocks. |
boolean |
isExitBBlock()
isExitBlock: See if this block is the exit block in the graph of basic blocks. |
boolean |
isPDef(SetRefRepr pSetRefRepr)
|
boolean |
isPDefined(Sym pSym)
isModified: See if the value of pSym is modified in this block. |
boolean |
isPEKill(FlowExpId pExpId)
isEKill: See if expression designated by pReg is killed (its operand is defined) in this block. |
boolean |
isPExposed(Sym pSym)
|
boolean |
isPKill(SetRefRepr pSetRefRepr)
|
boolean |
isPLiveIn(Sym pSym)
isLiveIn: See if pSym is live at entry to this block (value at entry is used in this block or in some successor of this block). |
boolean |
isPLiveOut(Sym pSym)
isLiveOut: See if pSym is live at exit from this block (value at exit is used in some successor of this block). |
boolean |
isPReach(SetRefRepr pSetRefRepr)
isReach0: See if definition at position pPos may reach to the entry point of this block. |
boolean |
isPUsed(Sym pSym)
|
FlowResults |
results()
Returns the FlowResults object that holds data flow information. |
void |
setDAvailIn(ExpVector pVect)
|
void |
setDAvailOut(ExpVector pVect)
|
void |
setDDefIn(FlowAnalSymVector pVect)
|
void |
setDDefined(FlowAnalSymVector pVect)
|
void |
setDDefOut(FlowAnalSymVector pVect)
|
void |
setDEGen(ExpVector pVect)
|
void |
setDExposed(FlowAnalSymVector pVect)
|
void |
setDKill(DefVector pVect)
|
void |
setDomForSubpFlow(java.util.List pDom)
Set the list of BBlock s that dominate this BBlock in the SubpFlow this BBlock belongs to. |
void |
setDominatedChildrenForSubpFlow(java.util.List pDominatedChildren)
|
void |
setDUsed(FlowAnalSymVector pVect)
|
void |
setImmediateDominatorForSubpFlow(BBlock pDominator)
|
void |
setImmediatePostdominatorForSubpFlow(BBlock pPostDominator)
|
void |
setIrLink(IR pIR)
|
void |
setPDef(DefVector pVect)
|
void |
setPDefined(FlowAnalSymVector pVect)
|
void |
setPEKill(ExpVector pVect)
|
void |
setPExposed(FlowAnalSymVector pVect)
|
void |
setPKill(DefVector pVect)
|
void |
setPLiveIn(FlowAnalSymVector pVect)
|
void |
setPLiveOut(FlowAnalSymVector pVect)
|
void |
setPostdomForSubpFlow(java.util.List pPostdom)
|
void |
setPostdominatedChildrenForSubpFlow(java.util.List pPostDominatedChildren)
|
void |
setPReach(DefVector pVect)
|
void |
setPUsed(FlowAnalSymVector pVect)
|
SetRefRepr |
setRefRepr(IR pIR)
Returns the SetRefRepr object enclosing the given IR. |
void |
setSetRefReprs(SetRefReprList pSetRefReprs)
Sets the SetRefReprList object that is the list of SetRefRepr objects, each of which wrap a statement/instruction. |
void |
setWork(java.lang.Object pWork)
|
java.lang.String |
toStringDetail()
toStringDetail: //##10 |
java.lang.String |
toStringShort()
toStringShort: //##10 |
| Method Detail |
public int getBBlockNumber()
public IR getIrLink()
public void setIrLink(IR pIR)
public Label getLabel()
public SubpFlow getSubpFlow()
SubpFlow
object this BBlock
belongs to.
public FlowResults results()
FlowResults
object that holds data flow information.
public SetRefReprList getSetRefReprs()
SetRefReprList
object that is the list of SetRefRepr
objects, each of which wrap a statement/instruction.
public void setSetRefReprs(SetRefReprList pSetRefReprs)
SetRefReprList
object that is the list of SetRefRepr
objects, each of which wrap a statement/instruction.
public java.util.List getPredList()
public java.util.List getSuccList()
public Edge getPredEdge(BBlock pFromBBlock)
public Edge getSuccEdge(BBlock pToBBlock)
public boolean isEntryBBlock()
public boolean isExitBBlock()
public java.util.List getDomForSubpFlow()
BBlock
s that dominate this BBlock
in the SubpFlow
this BBlock
belongs to.
public void setDomForSubpFlow(java.util.List pDom)
BBlock
s that dominate this BBlock
in the SubpFlow
this BBlock
belongs to.
public java.util.List getStrictDomForSubpFlow()
BBlock
in the SubpFlow
this BBlock belongs to. A strict dominator is the dominator list minus the BBlock
itself.
public BBlock getImmediateDominatorForSubpFlow()
public void setImmediateDominatorForSubpFlow(BBlock pDominator)
public java.util.List getDominatedChildrenForSubpFlow()
public void setDominatedChildrenForSubpFlow(java.util.List pDominatedChildren)
public java.util.List getPostdomForSubpFlow()
public void setPostdomForSubpFlow(java.util.List pPostdom)
public java.util.List getStrictPostdomForSubpFlow()
public BBlock getImmediatePostdominatorForSubpFlow()
public void setImmediatePostdominatorForSubpFlow(BBlock pPostDominator)
public java.util.List getPostdominatedChildrenForSubpFlow()
public void setPostdominatedChildrenForSubpFlow(java.util.List pPostDominatedChildren)
public java.lang.Object getWork()
public void setWork(java.lang.Object pWork)
public BBlockSubtreeIterator bblockSubtreeIterator()
SetRefReprIterator
is the preferred method of iterating subtrees.
See SetRefReprIterator
public BBlockNodeIterator bblockNodeIterator()
public java.lang.String toStringShort()
public java.lang.String toStringDetail()
public void fuseSuccessor(BBlock pToBlock)
public void changeSuccEdge(BBlock pBefore, BBlock pAfter)
public void changePredEdge(BBlock pBefore, BBlock pAfter)
public void addEdge(Exp pConditionalExp, BBlock pToBlock)
public void deleteEdge(BBlock pToBlock)
public void deleteBBlock()
public void addToPredList(BBlock pPred)
public void addToSuccList(BBlock pSucc)
public void deleteFromPredList(BBlock pPred)
public void deleteFromSuccList(BBlock pSucc)
public DefVector getPDef()
public void setPDef(DefVector pVect)
public DefVector getDKill()
public void setDKill(DefVector pVect)
public DefVector getPKill()
public void setPKill(DefVector pVect)
public DefVector getPReach()
public void setPReach(DefVector pVect)
public FlowAnalSymVector getDDefined()
FlowAnalSym
s that are definitely defined in this BBlock
.
public void setDDefined(FlowAnalSymVector pVect)
public FlowAnalSymVector getPDefined()
FlowAnalSym
s whose value may have changed in this BBlock
..
public void setPDefined(FlowAnalSymVector pVect)
public FlowAnalSymVector getDUsed()
SetRefRepr
s (specified by SetRefRepr#getUseSyms()).
public void setDUsed(FlowAnalSymVector pVect)
public FlowAnalSymVector getPUsed()
public void setPUsed(FlowAnalSymVector pVect)
public FlowAnalSymVector getDExposed()
public void setDExposed(FlowAnalSymVector pVect)
public FlowAnalSymVector getPExposed()
public void setPExposed(FlowAnalSymVector pVect)
public ExpVector getDEGen()
FlowExpId
s that appear in this BBlock and the result of the computation of the expression of the FlowExpId can definitely be used at the end of this BBlock.
public void setDEGen(ExpVector pVect)
public ExpVector getPEKill()
FlowExpId
s whose operand set (specified by FlowExpId#getOperandSet()) intersects the Modified set of this BBlock
.
public void setPEKill(ExpVector pVect)
public ExpVector getDAvailIn()
public void setDAvailIn(ExpVector pVect)
public ExpVector getDAvailOut()
public void setDAvailOut(ExpVector pVect)
public FlowAnalSymVector getPLiveIn()
public void setPLiveIn(FlowAnalSymVector pVect)
public FlowAnalSymVector getPLiveOut()
public void setPLiveOut(FlowAnalSymVector pVect)
public FlowAnalSymVector getDDefIn()
public void setDDefIn(FlowAnalSymVector pVect)
public FlowAnalSymVector getDDefOut()
public void setDDefOut(FlowAnalSymVector pVect)
public boolean isDDef(SetRefRepr pSetRefRepr)
public boolean isPDef(SetRefRepr pSetRefRepr)
public boolean isDKill(SetRefRepr pSetRefRepr)
public boolean isPKill(SetRefRepr pSetRefRepr)
public boolean isPReach(SetRefRepr pSetRefRepr)
public boolean isDDefined(Sym pSym)
public boolean isPDefined(Sym pSym)
public boolean isDUsed(Sym pSym)
public boolean isPUsed(Sym pSym)
public boolean isDExposed(Sym pSym)
public boolean isPExposed(Sym pSym)
public boolean isDEGen(FlowExpId pExpId)
public boolean isPEKill(FlowExpId pExpId)
public boolean isDAvailIn(FlowExpId pExpId)
public boolean isDAvailOut(FlowExpId pExpId)
public boolean isPLiveIn(Sym pSym)
public boolean isPLiveOut(Sym pSym)
public boolean isDDefIn(Sym pSym)
public boolean isDDefOut(Sym pSym)
public SetRefRepr setRefRepr(IR pIR)
SetRefRepr
object enclosing the given IR.
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Ratios can be written as an optional sign followed by two non-empty sequences of digits separated by a slash; see Figure 2-9. The second sequence may not consist entirely of zeros. Examples of ratios are in the next figure.
2/3 ;This is in canonical form 4/6 ;A non-canonical form for 2/3 -17/23 ;A ratio preceded by a sign -30517578125/32768 ;This is (-5/2)^15 10/5 ;The canonical form for this is 2 #o-101/75 ;Octal notation for -65/61 #3r120/21 ;Ternary notation for 15/7 #Xbc/ad ;Hexadecimal notation for 188/173 #xFADED/FACADE ;Hexadecimal notation for 1027565/16435934
Figure 2-13. Examples of Ratios
For information on how ratios are printed, see Section <IP_ADDRESS>.2 (Printing Ratios).


Copyright © 2009 Marc Worrell Date: 2009-04-09
Behaviours: gen_model.
Authors: Marc Worrell (marc@worrell.nl).
| all/1 | Return the list of all predicates. |
| flush/1 | Flush all cached data about predicates. |
| for_subject/2 | Return the list of predicates that are valid for the given resource id. |
| get/2 | Return the definition of the predicate. |
| id_to_name/2 | Lookup the name of a predicate with an id. |
| insert/2 | Insert a new predicate, sets some defaults. |
| is_predicate/2 | Test if the property is the name of a predicate. |
| m_find_value/3 | Fetch the value for the key from a model source. |
| m_to_list/2 | Transform a model value to a list, used for template loops. |
| m_value/2 | Transform a model value so that it can be formatted or piped through filters. |
| name_to_id/2 | Return the id of the predicate. |
| name_to_id_check/2 | |
| object_category/2 | Return all the valid categories for objects. |
| objects/2 | Return the category ids that are valid as objects. |
| subject_category/2 | Return all the valid categories for subjects. |
| subjects/2 | Return the category ids that are valid as subjects. |
| update_noflush/4 | Update a predicate, save the reversed flag, reset the list of valid subjects and objects. |
all(Context) -> PropList
Return the list of all predicates
flush(Context) -> any()
Flush all cached data about predicates.
for_subject(Id, Context) -> any()
Return the list of predicates that are valid for the given resource id. Append all predicates that have no restrictions.
get(PredId, Context) -> PredicatePropList | undefined
Return the definition of the predicate
id_to_name(Id, Context) -> {ok, atom()} | {error, Reason}
Lookup the name of a predicate with an id
insert(Title, Context) -> {ok, Id} | {error, Reason}
Insert a new predicate, sets some defaults.
is_predicate(Id::Pred, Context) -> bool()
Test if the property is the name of a predicate
m_find_value(Key, M::Source, Context) -> term()
Fetch the value for the key from a model source
m_to_list(M::Source, Context) -> List
Transform a model value to a list, used for template loops
m_value(M::Source, Context) -> term()
Transform a model value so that it can be formatted or piped through filters
name_to_id(Name::Pred, Context) -> {ok, int()} | {error, Reason}
Return the id of the predicate
name_to_id_check(Name, Context) -> any()
object_category(Id, Context) -> List
Return all the valid categories for objects. Return the empty list when there is no constraint. Note that the resulting array is a bit strangely formatted [{id}, {id2}, ...], this is compatible with the category name lookup and prevents mixups with strings (lists of integers).
objects(Id, Context) -> any()
Return the category ids that are valid as objects
subject_category(Id, Context) -> List
Return all the valid categories for subjects. Return the empty list when there is no constraint. Note that the resulting array is a bit strangely formatted [{id}, {id2}, ...], this is compatible with the category name lookup and prevents mixups with strings (lists of integers).
subjects(Id, Context) -> any()
Return the category ids that are valid as subjects
update_noflush(Id, Subjects, Objects, Context) -> void()
Update a predicate, save the reversed flag, reset the list of valid subjects and objects.
Generated by EDoc, Apr 11 2012, 20:41:29.


public class Color
extends java.lang.Object
| Modifier and Type | Field and Description |
|---|---|
static Color |
BLACK
Pure Black.
|
static Color |
WHITE
Pure White.
|
| Constructor and Description |
|---|
Color(double amt)
Creates a new Color with a shade a grey.
|
Color(double red,
double green,
double blue)
Creates a new Color.
|
Color(double red,
double green,
double blue,
double alpha)
Creates a new Color.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
equals(java.lang.Object obj) |
double |
getAlpha()
Get the amount of alpha in this color.
|
static byte |
getARGBComponent(int pixel,
int component)
Gets a component of an ARGB color.
|
double |
getBlue()
Get the amount of blue in this color.
|
double |
getGreen()
Get the amount of green in this color.
|
double |
getRed()
Get the amount of red in this color.
|
int |
hashCode() |
static int |
makeARGB(double r,
double g,
double b)
Creates a 32-bit ARGB color.
|
static int |
makeARGB(double a,
double r,
double g,
double b)
Creates a 32-bit ARGB color.
|
static int |
makeARGB(int r,
int g,
int b)
Creates a 32-bit ARGB color.
|
static int |
makeARGB(int a,
int r,
int g,
int b)
Creates a 32-bit ARGB color.
|
int |
scaleToARGB(double scaleAmt)
Returns a 32-Bit ARGB version of this color, with intensity scaled by
scaleAmt.
|
java.lang.String |
toString() |
public static final Color WHITE
public static final Color BLACK
public Color(double red, double green, double blue)
red
- The amount of red, in the range of (0, 1).green
- The amount of green, in the range of (0, 1).blue
- The amount of blue, in the range of (0, 1).public Color(double red, double green, double blue, double alpha)
red
- The amount of red, in the range of (0, 1).green
- The amount of green, in the range of (0, 1).blue
- The amount of blue, in the range of (0, 1).alpha
- The amount of transparency, in the range of (0, 1). 0 is fully
transparent, and 1 is fully opaque.public Color(double amt)
amt
- The amount of grey, in the range of (0, 1).public static int makeARGB(int a, int r, int g, int b)
a
- The amount of alpha, in range of (0, 255).r
- The amount of red, in range of (0, 255).g
- The amount of green, in range of (0, 255).b
- The amount of blue, in range of (0, 255).public static int makeARGB(int r, int g, int b)
r
- The amount of red, in range of (0, 255).g
- The amount of green, in range of (0, 255).b
- The amount of blue, in range of (0, 255).public static int makeARGB(double a, double r, double g, double b)
a
- The amount of alpha, in range of (0, 1).r
- The amount of red, in range of (0, 1).g
- The amount of green, in range of (0, 1).b
- The amount of blue, in range of (0, 1).public static int makeARGB(double r, double g, double b)
r
- The amount of red, in range of (0, 1).g
- The amount of green, in range of (0, 1).b
- The amount of blue, in range of (0, 1).public static byte getARGBComponent(int pixel, int component)
pixel
- A 32-bit ARGB color.component
- Which component to get, in range of (0, 3). public int scaleToARGB(double scaleAmt)
scaleAmt
- The amount to scale the intensity of this color during
conversion.public double getRed()
public double getGreen()
public double getBlue()
public double getAlpha()
public int hashCode()
hashCode
in class java.lang.Object
public boolean equals(java.lang.Object obj)
equals
in class java.lang.Object
public java.lang.String toString()
toString
in class java.lang.Object


Single-valued:
Multi-valued with a default selection:
Multi-valued with styled suggestions:
Multi-valued without REST call (basic colors only):
Fancy multi-valued and get/setValuesAsString:
Fancy multi-valued with Fancy selected items:


An elf hailing from the land of Nevermore, Papa Dio has been making his classic pizza pies for just a few weeks now. Usually he's busy slaying dragons or making angels weep with his awesome singing voice, but he decided to take a break for awhile to make some pizzas.


Lesson Plan Title: How to Perform Web Service SQL Injection
Concept / Topic To Teach:
Web Services communicate through the use of SOAP requests. These requests are submitted to a web service in an attempt to execute a function defined in the web service definition language (WSDL) file.General Goal(s):
Check the web service description language (WSDL) file and try to obtain multiple customer credit card numbers. You will not see the results returned to this screen. When you believe you have suceeded, refresh the page and look for the 'green star'.


Russia blames fatal plane crash on pilots, including one who lied to get license
by Reuters1 / 3FILE PHOTO: People are seen reflected in a flight information board at Kazan airport, where a Tatarstan Airlines Boeing 737 crashed
MOSCOW (Reuters) - A plane crash that killed all 50 people on board at Russia's Kazan Airport in 2013 was the result of errors made by two pilots, including one who got his license using falsified documents, Russian investigators said on Thursday.
The Boeing 737-500 aircraft was operated by the now-defunct Tatarstan Airlines, which later had its license revoked by Russia's Federal Air Transport Agency, Rosaviatsiya.
The plane from Moscow had been trying to abort its landing when it nose-dived into the runway and burst into flames. All 44 passengers and 6 crew members were killed.
The son of the president of the oil-rich province of Tatarstan and the regional head of the FSB intelligence service were among those killed. The dead also included two foreigners, a Briton and a Ukrainian.
Russia's Investigative Committee said in a statement on Thursday it had concluded its investigation into the crash and said that pilot error was to blame.
It said the aircraft's commander, Rustem Salikhov, did not have sufficient piloting skills and had made a series of errors as had his co-pilot Viktor Gutsul.
It said Salikhov had obtained his pilot's license using falsified documents.
"Salikhov, having no basic knowledge, skills and experience as a pilot, began to carry out passenger air flights as a pilot," it said.
The Investigative Committee said it had charged Valery Portnov, then-deputy general director of Tatarstan Airlines who it said had submitted Salikhov's documents containing false information in 2009.
It said he was being charged with violating air traffic safety rules resulting in the death of two or more people.
The then-regional head of Rosaviatsiya in Tatarstan, Shavkat Umarov, was charged with negligence.
Kazan, which is 800 km (500 miles) east of Moscow, is the capital of the mainly Muslim region of Tatarstan.
(Reporting by Alexander Marrow; Editing by Andrew Osborn and Mike Collett-White)


From the Death Certificate
for Saran Ann Herlan:
Sarah Ann Herlan
Death certificate #27444 was
issued in Noble County, Ohio.
Saran Ann Herlan, married, was born November 20, 1844. She lived 71 years, 4 months, and 18
days. She was a housewife. She was born in Noble Co., Ohio, the
daughter of John Kent Sr. from Pa. and Elizabeth Danford from Noble Co.,
Ohio. G. H. Herlan [her son George
"Homer" Herlan] of Summerfield was the informant. [Her son was also part of the Meek &
Herlan undertakers of Summerfield that are listed on this certificate.] Sarah Ann
died in the Village of
Summerfield on Apr. 7, 1916, from chronic intestinal nephritis; duration, one
year. The contributory cause was listed
as arterio sclerosis which she had for a year as well. The certifying physician was Geo. L.
Nemstein or Wemstein [sic?] She was buried April 9th, 1916 at Summerfield,
Ohio.
Provided by Betty Latta Kitchen
Click here for the Short-Cut Table of Contents


Tests that if a plugin creates an NPObject and releases it on destruction, there's no crash when the plugin goes away.


[1]
good that the hotel like this - wide international grand hotel is.
[2]
it 's a hotel like this - wide international range good quality but nothing outstanding.


Across: 5. Opportunity for Charlie to go to church (6) 8. Mark gets measure of militant (8) 9. Think about aiming east (7) 10. Joint of legend!? (5) 11. Amazed by nude toads! (9) 13. Get up quickly for second cold walk (8) 14. Lizard again seen around university (6) 17. No-one left nuffink! (3) 19. Knock pot! (3) 20. Wear these for summer drinks? (6) 23. Hero, 50, yearns to hold Penny (8) 26. Open to ideas in pamphlet left in Lincoln (9) 28. Rose takes bible study in pub (5) 29. Sailor captivated by composer’s song (7) 30. Tom takes a right turn at waterfall (8) 31. In panic he silently locates bank (6) Down: 1. Run across to get awards (6) 2. Mobile guns surround Queen’s ships (7) 3. Representative comes round about measure in contract (9) 4. Rolf comes back to a student of flowers (6) 5. Secret service hold a doctor and party back in the country (8) 6. Groan about gas! (5) 7. Declares unfit fools can capture 500 men! (8) 12. Use a needle with 3 points? (3) 15. Stellar creature gets to be in a garret (5 4) 16. Hot, upset and coarse, but methodical (8) 18. I get last bun in port (8) 21. I will be sick! (3) 22. Laid arm about Nelson (7) 24. Money a landowner makes (6) 25. I tarry to get unusual item (6) 27. Selects part of scenic Ullswater region (5)


Products - Bath Salts, Plant Food, etc. ('Revitalize Fizz')
[Erowid Note: 'Bath salts' and similar products generally do not list ingredients or dosage on their packaging. Analysis has revealed that ingredients in a single product of this type may vary over time.]
Well I am a nurse and also a nursing student working on getting my RN. I had heard about 'bath salts' from another nursing student who works in the Emergency Room at a local hospital, and have to admit I was a bit curious. I have used cocaine in the past and loved it, however the health care system is not exactly conducive to that type of behavior. So, to kick off my spring break I decided to do a clinical trial of sorts. After a search that took me to a different state (I live on the border of PA) proved worthless, the very nice girl in the smoke shop I originally went to pointed me to a local head shop that I didn't even know existed. I paid $50 for 500mg of 'Revitalize Fizz bath salts'. I went home and did a very small line at about 6:00pm. I sat and read a book, smoked a cigarette and didn't notice any effects. After about 30 minutes I did another small line. In about 20 more minutes I began to notice I felt more energetic.
About 45min to an hour after I snorted the first 2 lines it fully kicked in. I feel absolutely amazing! I wanted very much to dance, so I put some music on and danced by myself in the living room. Then I began to notice that my mouth was very dry. In the past 5 hours I have drank 6 bottles of water and 2 cans of soda. Still have a case of cotton mouth. About 2 hours after the first dose I did another larger line, and boy did I feel it! Was feeling very chatty and didn't have anyone to talk to, so started texting.
It was then time to pick my husband up from work, he noticed that I was very upbeat. He kept asking me why I'm so 'wound up'. I just told him that I was in a great mood. He bought it... not sure why though considering I could not stand still, was talking a mile a minute and smoking like a chimney. Anyhoo. I had to sneak into the bathroom to do about 3 more smaller bumps. Just did my last line about half an hour ago, and am determined to stop here because I really would like to sleep at some point tonight.
I should say that I am also an experienced opiate user, due to some work related injuries I have been prescribed Percocet and Vicoden and have been taking them for approx 2 years. I get withdrawals when I don't have them. I will say that I took about 5 Vicodin 5/325 earlier in the day. Once I did the bath salts I did not have any desire to take any more pills. I don't even miss the opiate high. And this also helps with pain. My injuries haven't been hurting since I started this. I have felt some of the come down effects, but I don't believe they are anywhere near as severe as the cocaine come down. I guess we shall see. However, I don't believe that I will be able to sleep anytime soon, and I hate that feeling. I do not want to feel like a strung-out zombie tomorrow. Am debating taking a 10mg Ambien to see if that will help, but am a bit nervous because I don't know how I will react.
All in all this has been a very enjoyable experience. Definitely more of a cocaine high than any hallucinations. Would love to try it during a night out. If you do decide to take this drug please be safe and do it around people you trust to take care of you and get you prompt medical attention if needed. That's just the nurse in me talking! I hope this substance remains legal, however I'm sure the government will not allow that to happen. Thank you for reading my experience. I hope this helped you out if you are thinking of trying bath salts.
[Reported Dose: 'maybe 15mg total']
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


The section
components are simple layout elements with responsive padding. They are best used as direct children of body
.
---
title: Section
layout: documentation
fullwidth: true
doc-tab: layout
doc-subtab: section
breadcrumb:
- home
- documentation
- layout
- layout-section
---
{% capture section_example %}
Section
A simple container to divide your page into sections, like the one you're currently reading.
Medium section
A simple container to divide your page into sections, like the one you're currently reading.
Large section
A simple container to divide your page into sections, like the one you're currently reading.
The section
components are simple layout elements with responsive padding. They are best used as direct children of body
.
You can use the modifiers is-medium
and is-large
to change the spacing.


Total Number by Categories
Unreviewed Contributions
Search a Moderator or Supervisor
Chart by Total Moderated in the Team
Top Moderators by total_moderated
Top Moderators by total_paid_steem
@utopian-io
Latest Posts from @utopian-io
Your SteemId ID:
Alt + S: (Switch)
Nodes
Additional ID's (Tab General)