Specifications
- Genre: 2D Top-Down Puzzle Adventure
- Duration: 8 Weeks Part-Time, 4h/day
- Engine: TGA2D (developed by The Game Assembly)
- Team: Diamond Eyes Studios, 12 people
My Contributions
- Gameplay (Movable Blocks, Camera System, Ice and Fire Weapon Logic)
- Graphics (Particle System Architecture, Point Light Logic)
- UI (Dialogue System used for Hint Signs, NPC Dialogue and Inventory Lore Text)
- Audio (Audio Manager and Logic)
- Voice Over, Music
Details
Movable Blocks
The main mechanic of this game was to move blocks around, pushing them onto switches that would open up doors and gates. I developed much of the gameplay logic surrounding this feature, creating the components for basic blocks made of rock as well as gliding ice blocks that did not stop moving until they hit something. The grid based system and all the blocking terrain and switches featured made this a bit tricky, but I think it worked out really well in the end.
Camera System
I also developed the camera system, where a bounding box was defined for each room the player character went through. The camera view was constrained within this bounding region, allowing for smooth transitions between the edges of a room where the player character moved around freely and the open spaces of a room where the camera was centered on and following the character. When the player crossed one such bounding box, we would call it a boundary transition, entering a new room and setting a new constraining bounding box for the camera view. We also had level transitions, where the camera would fade out and a different level would be loaded.
Ice and Fire Weapon Logic
Apart from moving the blocks, the player could also change blocks. Using an ice ability, rock blocks could be frozen, transforming them into everything an icy block was. An icy block could also be destroyed by using a fire ability, and the fire ability could also be used light braziers on fire. On the flip side, braziers could also be extinguished using the ice ability. This was done to enable puzzles to be designed where sometimes you needed to extinguish a flame while in others you had to ignite it. I had a major part in designing the components needed for this behaviour.
Particle System Architecture
I designed and implemented the particle system architecture for this game, where all particles were pooled and reinitializable in runtime, enabling the fire and ice effects coming from the player character to change directions depending on the character’s facing. I also designed some of the particle systems used in the final game. Some examples include a sandstorm, a fiery crackling from the braziers as well as an icy glinting coming off of the ice blocks. The particle system was also used in the inventory UI to mark the currently selected item. We also used it for a dust trail coming off of the player, a sparkling coming off of item chests, and dust arising from sliding regular blocks.
Point Light Logic
I set up components for point light lighting used for various effects, such as a fiery glow coming from the braziers, and icy sheen on the ice blocks and the point light centered on the player character. It was important that these lights be togglable, as they had to be disabled when the fires were extinguished, or ice blocks destroyed.
Dialogue System used for Hint Signs, NPC Dialogue and Inventory Lore Text
I developed a dialogue system which saw a lot of use in the game. Using the text rendering already in the engine, I set up a system that subscribed to messages sent by various components,
such as hint signs, the NPC character as well as the inventory system. The Update()
method of this system animated the text, using a buffer to count out
the letters to the screen while keeping the formatting, as well as automatically use line breaks so that they did not have to be added to the text itself. The scrolling text could be sped
up and down by holding and releasing the spacebar, as well as skipped entirely.
Audio Manager and Logic
Finally I implemented an audio manager featuring self-made channel logic, as the TGA2D engine used Bass as its audio API. The channels could be used for grouping sound volumes, as well as ducking channels of lesser priority to those of a higher priority. The audio logic was based on messages to which the manager subscribed, sent from various components of the gameplay system.


Australia PM says allegation of China interference disturbing
by ReutersSYDNEY (Nov 25): Australian Prime Minister Scott Morrison said on Monday that allegations in a media report that China had tried to install an agent in a parliamentary seat in Canberra were "deeply disturbing and troubling".
The Australian Security Intelligence Organisation, in a rare public statement, said it was already investigating the allegations reported by Channel 9 television.
"I find the allegations deeply disturbing and troubling," Morrison said at a media conference, noting that ASIO's investigation was ongoing.


Research and analysis
Report examining the performance of sponsored academies in the attainment of pupils at key stage 4.
Ref: DFE-RR223 PDF , 322KB , 54 pages
This report provides a comprehensive digest of the educational attainment at the end of key stage 4 of pupils who were in academies in 2010 to 2011.
The 2011 secondary school performance tables included results for 274 academies. This is a small proportion of the 1,877 schools that are now academies because the performance tables are based on those schools that had academy status for the entire academic year to which the results refer.
Sponsored academies generally replaced under-performing schools with a history of low attainment, often in more socially-deprived localities and with generally lower than average prior attainment on entry.
Published: 26 June 2012
From: Department for Education
Part of: Academies and free schools


Classifying is something a neural network can do quite well. In this article I will demonstrate how you can set up the evolution process of a neural network that learns to classify colors. Keep in mind: this simulation is far from optimal.
Colors:
Iteration: 0 Best-fitness: 0 Average-fitness: 0
Set sorted by color
Set sorted by NN
How it works
The algorithm to this classification is actually pretty easy. One of my biggest problem was generating the colors, however I stumbled upon this javascript module that allows you to generate colors randomly by name - exactly what I needed (but it also created a problem, read below). So I used it to create a training set:
function createSet(){ var set = []; for(index in COLORS){ var color = COLORS[index]; var randomColors = randomColor({ hue : color, count: PER_COLOR, format: 'rgb'}); for(var random in randomColors){ var rgb = randomColors[random]; random = rgb.substring(4, rgb.length-1).replace(/ /g, '').split(','); for(var y in random) random[y] = random[y]/255; set.push({ input: random, output: [index / (COLORS.length - 1)], color: color, rgb:rgb}); } } return set;
COLORS is an array storing all color names in strings. The possible colors are listed above. Next, we convert this rgb string to an array and normalize the values between 0 and 1. Last of all, we normalize the colors to a number between 0 and 1 as well. Please note that the `color` and `rgb` object attributes are irrelevant for the algorithm.
function createNeat(){ neat = new Neat(3, 1, fitness, { mutation: [ Methods.Mutation.ADD_NODE, Methods.Mutation.ADD_CONN, Methods.Mutation.MOD_WEIGHT, Methods.Mutation.MOD_BIAS, Methods.Mutation.SUB_NODE, Methods.Mutation.MOD_ACTIVATION ], mutationRate: 0.6, elitism: 5, popsize: 100, }); }
Now we creat the built-in genetic algorithm in neataptic.js. We define that we want to use all possible mutation methods (except SUB_CONN) and set the mutation rate higher than normal. Sprinkle in some elitism and double the default population size. Experiment with the parameters yourself, maybe you'll find even better parameters!
function fitness(genome){ var score = 0; for(var item in set){ item = set[item]; score -= Methods.Cost.MSE(item.output, genome.activate(item.input)); } score -= genome.nodes.length * Math.abs(-5 - score) / (PER_COLOR * COLORS.length * 10); return score; }
The fitness function is the most vital part of the algorithm. It basically calculates the Mean Squared Error of the entire set. However, the small line beneath it gives a tiny penalty when networks get bigger. This makes sure the network won't overfit the data. The penalty is still small enough to allow small improvements.
Last but not least, we define the loop. This loop is very simple:
function loop(){ neat.evolve(); if(running) setTimeout(loop, 1); }
And puting together all this code will create a color classifier. There are some slight issues though:
It seems like some colors from the randomColor library overlap, thus colors like purple and pink can't be classified seperately very well.Woops, seems to be fine, read about it here.- The networks tend to stay way too small and they hate forming new connections. Something I may change in the fitness function in the future!


LexicalUnit
interface by Philippe Le Hegaret.-
Nested Class Summary
-
Method Summary
Modifier and TypeMethodDescriptionclone()
Creates a deep copy of this lexical unit and the next ones, unlinked to any previous lexical unit.int
countReplaceBy
(LexicalUnit replacementUnit) Replace this unit in the chain of lexical units (by the unit or sequence of units in the argument) and return the count of replacement units.Get a parsable representation of this unit.short
An integer indicating the type of CSS unit that this lexical value represents.If this unit is aLexicalUnit.LexicalType.DIMENSION
, returns the string representation of the CSS unit returned bygetCssUnit()
.float
Returns the float value represented by this unit.Returns the name of the function.int
Returns the integer value represented by this unit.Gives the type ofLexicalUnit
.The next lexical unit.The function parameters including operators (like the comma).The previous lexical unit.Returns the string value.Returns a sequence of units inside the sub-expression or unicode range.void
insertNextLexicalUnit
(LexicalUnit nextUnit) Insert the given unit as the next lexical unit.boolean
Check if this lexical unit is a parameter that was made available through its parent'sgetParameters()
method.matches
(CSSValueSyntax syntax) Verify whether this value matches the given grammar.remove()
Remove this unit from the chain of lexical units and replace it by the next one, if any.replaceBy
(LexicalUnit replacementUnit) Replace this unit in the chain of lexical units.Creates a shallow copy of this lexical unit, ignoring the next ones, and unlinked to any previous lexical unit.
-
Method Details
-
getLexicalUnitType
LexicalUnit.LexicalType getLexicalUnitType()Gives the type ofLexicalUnit
.- Returns:
- the type of
LexicalUnit
.
-
getCssUnit
short getCssUnit()An integer indicating the type of CSS unit that this lexical value represents.- Returns:
- an integer indicating the type of CSS unit. If this value does not represent a dimension, must return an invalid unit identifier.
-
getNextLexicalUnit
LexicalUnit getNextLexicalUnit()The next lexical unit.Lexical units can form chains of units which can be traversed with
getNextLexicalUnit()
andgetPreviousLexicalUnit()
.- Returns:
- the next lexical unit, or
null
if none.
-
getPreviousLexicalUnit
LexicalUnit getPreviousLexicalUnit()The previous lexical unit.See also
getNextLexicalUnit()
.- Returns:
- the previous lexical unit, or
null
if none.
-
insertNextLexicalUnit
Insert the given unit as the next lexical unit.After the insertion,
nextUnit
shall be the next lexical unit, and the former next lexical unit will be the next one after the last unit in thenextUnit
unit chain.- Parameters:
nextUnit
- the lexical unit to be set as the next one.- Throws:
IllegalArgumentException
- if the argument is a parameter or has a previous unit.
-
remove
LexicalUnit remove()Remove this unit from the chain of lexical units and replace it by the next one, if any.- Returns:
- the next lexical unit, or
null
if there is no next lexical unit.
-
countReplaceBy
Replace this unit in the chain of lexical units (by the unit or sequence of units in the argument) and return the count of replacement units.The replaced unit always returns
null
forgetNextLexicalUnit()
andgetPreviousLexicalUnit()
,false
forisParameter()
.- Parameters:
replacementUnit
- the lexical unit that replaces this one. Ifnull
, this unit is replaced by the next one.- Returns:
- the number of units that replace this one (i.e. the
argument, or
0
if the argument isnull
). - Throws:
IllegalArgumentException
- if the replacement unit is a parameter or has a previous unit.CSSBudgetException
- if the replacement unit has too many chained units (to avoid potential DoS).
-
replaceBy
Replace this unit in the chain of lexical units.The replaced unit always returns
null
forgetNextLexicalUnit()
andgetPreviousLexicalUnit()
,false
forisParameter()
.This method is very similar to
countReplaceBy(LexicalUnit)
which gives important information when you need to replace this unit by an arbitrary (and potentially large) chunk of values.- Parameters:
replacementUnit
- the lexical unit that replaces this one. Ifnull
, this unit is replaced by the next one.- Returns:
- the unit that replaces this one (i.e. the argument, or the
next lexical unit if the argument is
null
). - Throws:
IllegalArgumentException
- if the replacement unit is a parameter or has a previous unit.CSSBudgetException
- if the replacement unit has too many chained units (to avoid potential DoS).- See Also:
-
getIntegerValue
int getIntegerValue()Returns the integer value represented by this unit.- Returns:
- the integer value, or zero if this is not an integer unit.
- See Also:
-
getFloatValue
float getFloatValue()Returns the float value represented by this unit.- Returns:
- the float value, or
NaN
if this value is not a float.
-
getDimensionUnitText
String getDimensionUnitText()If this unit is aLexicalUnit.LexicalType.DIMENSION
, returns the string representation of the CSS unit returned bygetCssUnit()
.- Returns:
- the string representation of the CSS unit, or the empty string if
this lexical unit does not represent a
LexicalUnit.LexicalType.DIMENSION
.
-
getStringValue
String getStringValue()Returns the string value.If the type is
URI
, the return value doesn't containuri(....)
or quotes.If the type is
UNICODE_WILDCARD
, the return value is the wildcard without the preceding "U+".- Returns:
- the string value, or
null
if this unit does not have a string to return. - See Also:
-
getFunctionName
String getFunctionName()Returns the name of the function.- Returns:
- the function name, or
null
if this unit is not a function. - See Also:
-
getParameters
LexicalUnit getParameters()The function parameters including operators (like the comma).A RGB color like
#000
is converted torgb(0, 0, 0)
.May return
null
if type isFUNCTION
.- Returns:
- the parameters of this function, or
null
if this unit is not a function, or an emptyFUNCTION
. - See Also:
-
isParameter
boolean isParameter()Check if this lexical unit is a parameter that was made available through its parent'sgetParameters()
method.- Returns:
true
if this lexical unit is a parameter.
-
getSubValues
LexicalUnit getSubValues()Returns a sequence of units inside the sub-expression or unicode range.- Returns:
- the values in the sub-expression, or
null
if this unit is not a sub-expression nor a unicode range. - See Also:
-
getCssText
String getCssText()Get a parsable representation of this unit.The serialization must only include this lexical unit, ignoring the next units if they exist.
The text should be close to how the value was specified (for example, preserving hex or functional notation in rgb colors) but must parse without errors (except for compatibility values like
COMPAT_IDENT
).- Returns:
- the parsable serialization of this unit.
-
matches
Verify whether this value matches the given grammar.This method is intended to be used for generic sanity checks and, consequently, some corner cases may not be taken into account. For example, when matching
var()
, the implementations are allowed to assume that the property substitution shall not be empty, otherwise values likevar(--data) 1px
would give a non-FALSE
match simultaneously on syntaxes with and without a multiplier (+
or#
), which would probably not be what that use case wants.In the case of
calc()
, if implementations do not perform a full dimensional analysis it is more acceptable to return a bogusTRUE
than aFALSE
.Here are some examples of matching:
Value Syntax Match attr(data-width length, 8%)
<percentage> | <length>
TRUE
<length>
PENDING
<percentage>
PENDING
<length>#
PENDING
<length-percentage>
TRUE
<resolution>
FALSE
*
TRUE
6pt var(--custom) 12.3px
<length>+
PENDING
<length>#
PENDING
1<length>
FALSE
<number>+
FALSE
*
TRUE
- Despite the value containing no commas, the syntax with a
#
multiplier matches asPENDING
because the custom property could have commas and start and end with one.
See also:
SyntaxParser
.- Parameters:
syntax
- the syntax.- Returns:
- the matching for the syntax.
- Despite the value containing no commas, the syntax with a
-
clone
LexicalUnit clone()Creates a deep copy of this lexical unit and the next ones, unlinked to any previous lexical unit.The clone's
getPreviousLexicalUnit()
returnsnull
(andisParameter()
false
) regardless of what the the original object returned.- Returns:
- a copy of this unit.
-
shallowClone
LexicalUnit shallowClone()Creates a shallow copy of this lexical unit, ignoring the next ones, and unlinked to any previous lexical unit.The shallow clone's
getPreviousLexicalUnit()
andgetNextLexicalUnit()
both returnnull
(andisParameter()
false
) regardless of what the the original object returned.- Returns:
- a shallow copy of this unit.
-


This guide discusses how to implement local and push notifications in Corona.
Corona SDK supports two types of notifications: local and push. The purpose of both notification types is to notify the user about something — a message or an upcoming appointment, for example — when the application isn't running in the foreground. The essential difference between local notifications and push notifications is simple:
Local notifications are scheduled by an app locally and are delivered by the same device.
Push notifications are sent by a remote server (its provider) which sends these notifications to devices on which the app is installed.
To use push notifications, remember the following points:
The app has to support a registration process and it must support incoming messages.
You must configure your app and devices so that Apple and/or Google recognizes them. Apple/Google will send the actual messages out to devices.
If using iOS/Apple, your app cannot send push requests directly to their servers.
We recommend that you use a web service to send push requests to Apple or Google, who in turn sends them onward to devices. That web service can be a company like PushWoosh, Urban Airship, or Parse that specializes in push notifications.
Another option to handle push notifications on iOS is EasyAPNS. This is a PHP/MySQL setup that registers devices in your own database and allows you to send push notifications from your own server. Please visit www.easyapns.com for more information.
Google's Cloud Messaging system is REST-based, so a Corona app can technically send push notifications to another app. Please refer to the sample app located in the Corona SDK application directory: CoronaSDK → SampleCode → Notifications → GooglePushNotifications
How an app reacts to notifications depends on its state:
Not running — the app has exited by design, user decision, reboot, etc. In this state, if the user interacts with the notification, the operating system will launch the app. Information about the notification event will be passed to the app using "launch args". The app should watch for these and react accordingly, for example, show a "snooze" button for an alarm or open a native.newWebView() if it has a URL. Note, however, that if the user starts the app by tapping directly on its icon, the notification will not be presented.
Backgrounded — the app is running but it's not the active app. In this state, if the user interacts with the notification by swiping on the unlock screen while the notification is showing or tapping on it in the notification center, the operating system will bring the app to the foreground and make it active. At this time, the app will receive the notification event but not receive launch args.
Foregrounded — the app is active and the user is currently interacting with it. In this state, the app will receive the notification event.
Much of the iOS configuration for push notifications is done within the app provisioning profile in the iOS Dev Center. Please refer to the guide for details.
In addition, you must include a notification
table in the config.lua
file (reference) to enable various features for push notifications. This tells the system which of the alert types you plan to use.
application =
{
content =
{
width = 640,
height = 960,
scale = "letterbox",
xAlign = "center",
yAlign = "center"
},
notification =
{
iphone =
{
types = { "badge", "sound", "alert" }
}
}
}
Android also requires some additional configuration for push notifications. In the config.lua
file (reference), add a notification
table as follows. When you register with the Google GCM service, you'll get the projectNumber
value needed for the google
table.
application =
{
content =
{
width = 320,
height = 570,
scale = "letterbox",
xAlign = "center",
yAlign = "center"
},
notification =
{
google =
{
projectNumber = "3982849975315"
},
}
}
In addition, you must include the following permissions in the build.settings
file (reference). Failure to include these entries will cause your push notifications to fail.
settings
{
android =
{
permissions =
{
{ name = ".permission.C2D_MESSAGE", protectionLevel = "signature" },
},
usesPermissions =
{
"android.permission.INTERNET",
"android.permission.GET_ACCOUNTS",
"android.permission.RECEIVE_BOOT_COMPLETED",
"com.google.android.c2dm.permission.RECEIVE",
".permission.C2D_MESSAGE",
},
},
}
You can set custom notification icons in a Corona project by adding the following files to the root of the project directory, just like custom application icons. Please note that different Android OS versions support different notification icon themes. You must support all of them or the app may get rejected in the review process. Please see Google's official documentation for details on icon sizes and theming.
IconNotificationDefault-ldpi-v11.png IconNotificationDefault-mdpi-v11.png IconNotificationDefault-hdpi-v11.png IconNotificationDefault-xhdpi-v11.png
|
The -v11 set is for Android 3.0 or higher. These icons are expected to be white.
|
|---|---|
IconNotificationDefault-ldpi-v9.png IconNotificationDefault-mdpi-v9.png IconNotificationDefault-hdpi-v9.png IconNotificationDefault-xhdpi-v9.png
|
The -v9 set is for Android 2.3. These icons are expected to be grey.
|
IconNotificationDefault-ldpi.png IconNotificationDefault-mdpi.png IconNotificationDefault-hdpi.png IconNotificationDefault-xhdpi.png
|
This set, without the postfix -v , is for Android 2.2. These icons are expected to be black.
|
If you're a Corona Enterprise developer, please refer to the Enterprise and Android Icons notes below.
To schedule a local notification, use the system.scheduleNotification() function and specify the time of the future event in one of two formats:
The UTC option should be a time table as returned by os.date("!*t")
. A common pitfall is to forget the exclamation point and pass "*t"
instead of "!*t"
— this will return the time structure in local time (your timezone) instead of UTC.
You should also pass an options table containing the following optional parameters:
alert
— string value representing the notification message to be displayed to the user. If the application is not currently running, a system alert will display this message.
badge
(iOS feature) — the badge number to be displayed on the application icon when the scheduled notification triggers. This replaces the last badge number that was applied. Set to 0
to not show a badge number.
sound
— string value representing the sound file in system.ResourceDirectory that will be played when the scheduled notification triggers. This sound is only played if the app is not in the foreground. On iOS, there are limitations on the sounds that can be played (consult Apple's documentation for details).
custom
— a table of custom information that will be delivered with the notification event.
local futureTime = 9 * 60 --9 minute alarm "snooze"
--OR:
local futureTime = os.date( "!*t", os.time() + (9 * 60) )
local options = {
alert = "Wake up!",
badge = native.getProperty( "applicationIconBadgeNumber" ) + 1,
sound = "alarm.caf",
custom = { msg = "Alarm" }
}
local notificationID = system.scheduleNotification( futureTime, options )
To cancel a local notification before it triggers, use the system.cancelNotification() function and pass the ID returned by system.scheduleNotification()
.
system.cancelNotification( notificationID )
In accordance with the Corona event/listener model, if your app is running in either the foreground or background and a notification arrives, you'll receive a notification event. It's your responsibility to initialize the system and set up a listener function to handle these events. Please review the following framework and then read the detailed subsections below.
local function notificationListener( event )
if ( event.type == "remote" ) then
--handle the push notification
elseif ( event.type == "local" ) then
--handle the local notification
end
end
Runtime:addEventListener( "notification", notificationListener )
A notification event returns a table of information which you can use to manage the specific notification. This table includes the following:
event.badge
— number representing the badge count (iOS only).event.type
— string value of "local"
for local notifications or "remote"
for push notifications. event.name
— string value of "notification"
.event.custom
— if this table exists, there may be data from the push service that helps your app react to the data. This is known as deep linking.event.sound
— string value representing a sound file, i.e. "alarm.caf"
.event.alert
— string value consisting of the message to display.event.applicationState
— string value of either "active"
or "inactive"
.When the operating system, as the result of an incoming notification, "cold starts" your app from an inactive (not running) state, the app receives the data as part of launchArgs
instead of triggering a notification event. You can use your notificationListener
function to process the launch args.
local launchArgs = ...
if ( launchArgs and launchArgs.notification ) then
print( "event via launchArgs" )
notificationListener( launchArgs.notification )
end
The launchArgs
processing has to be in your main.lua
since it's the code that receives the data.
Badges are easily recognized by a small circle/number overlaying the app icon. They are available only on iOS. If a notification passes a badge
value, a badge equal to that value will appear over the app icon.
For push notifications, the service can send the string "+1"
as the badge
value. In this case, the badge count will be incremented by 1. The operating system manages this automatically and when the app launches, the badge number will equal the total number of badges that have been set. For example, if you begin with a badge value of 5 and a new push notification comes in with the "+1"
string, the badge number will increment to 6 and the value of event.badge
will likewise be 6.
For local notifications, it's your responsibility to read and set the badge number depending on its previous value. This is accomplished with the native.getProperty() and native.setProperty() functions.
In both cases — local or push — when the user opens/handles the notification, you should decrement the badge number by 1 or clear it entirely.
--decrement the badge number by 1
local function notificationListener( event )
if ( event.type == "local" ) then
--handle the local notification
local badge_num = native.getProperty( "applicationIconBadgeNumber" )
badge_num = badge_num - 1
native.setProperty( "applicationIconBadgeNumber", badge_num )
elseif ( event.type == "remote" ) then
--handle the push notification
if ( event.badge and event.badge > 0 ) then
native.setProperty( "applicationIconBadgeNumber", event.badge - 1 )
end
end
end
--or clear the badge entirely
native.setProperty( "applicationIconBadgeNumber", 0 )
By default, the device will play a sound when a notification comes in. You can specify a custom sound file in your project to play instead of the default sound. For instance, if you have the file notification.wav
inside your app bundle, you can specify the string "notification.wav"
as part of the push bundle (if the sending service supports it) and the operating system will play that custom sound instead of the default. In this case, the event.sound
entry in the event listener will equal this string.
For push notifications, your app must register with the push provider's servers (Apple and Google). Corona handles the registration process for you in the background. Because you'll typically use a service to send push requests to the Apple and Google servers, that service needs to know about your app and device. Once registered, Corona will trigger the "remoteRegistration"
notification event.
To accommodate this, add an additional condition to your notification listener:
local function notificationListener( event )
if ( event.type == "remote" ) then
--handle the push notification
elseif ( event.type == "remoteRegistration" ) then
--code to register your device with the service
end
end
Runtime:addEventListener( "notification", notificationListener )
The code required to register your device varies on the service. The following example illustrates PushWoosh remote registration. PushWoosh is one of several push notification providers and is not necessarily endorsed by Corona Labs. This code is tested as of June 2013 but it is subject to change by PushWoosh and may not be maintained by Corona Labs. Other providers will be different, so please consult your preferred provider's documentation or seek assistance in the Corona Developer Forums.
local function notificationListener( event )
if ( event.type == "remote" or event.type == "local" ) then
--handle the push or local notification
elseif ( event.type == "remoteRegistration" ) then
local deviceToken = event.token
local deviceType = 1 --default to iOS
if ( system.getInfo("platformName") == "Android" ) then
deviceType = 3
end
print( "Setting up with PushWoosh" )
local DeviceID = event.token
local PW_APPLICATION = "B8312-C3DE4" --use your app ID in PushWoosh
local PW_URL = "https://cp.pushwoosh.com/json/1.1/registerDevice"
local function networkListener( event )
if ( event.isError ) then
--error occurred
native.showAlert( "Notification Registration Failed", "An Error Contacting the Server has Occurred.", { "OK" } )
else
--registration successful!
print( "PushWoosh registration successful", system.getInfo("deviceID") )
end
end
local commands_json =
{
["request"] = {
["application"] = PW_APPLICATION,
["device_id"] = DeviceID,
["language"] = "en", --OR: system.getPreference( "ui", "language" ),
["hw_id"] = system.getInfo("deviceID"),
["timezone"] = -3600, --offset in seconds
["device_type"] = deviceType
}
}
local post_body = json.encode( commands_json )
local headers = {}
headers["Content-Type"] = "application/json"
headers["Accept-Language"] = "en-US"
local params = {}
params.headers = headers
params.body = post_body
network.request ( PW_URL, "POST", networkListener, params )
end
end
Runtime:addEventListener( "notification", notificationListener )
When developing natively for Android, Google wants all icons in the project's res
directory. This is important because Google's Android build process generates code, creating a R.java
file containing unique integer IDs to every resource that your project and its libraries contain. The IDs are needed to access these resources, including the notification icons.
First, you should become familiar with how Android handles resources by reading Google's official documentation.
When developing with Corona Enterprise, you need to override Corona's notification icon resources with your own. Before proceeding, inspect the Corona library's resource directory:
./CoronaEnterprise/Corona/android/lib/Corona/res
In this directory, every drawable
directory contains a file named corona_statusbar_icon_default.png
. This is the image file to override. Note that this action should be an "override" and not a replacement. You should not modify the contents of the Corona library directory!
To override these notification image files with your own, you need to set up the Android project with the same drawable
directories under your res
directory. Add each IconNotification*.png
icon to its respective drawable
directory by resolution and version (see Android Icons above). You also must rename these files to corona_statusbar_icon_default.png
.
How this works is as follows: when you do an Android build, it builds the app's libraries first, then it builds the app. If the Android build process finds resources files named identically between your app and its libraries, the app's resource files always take precedence and will be used instead of the library's resources. This is why most 3rd-party libraries prefix their resource file names using the library's name to help avoid conflicts.


WIRES have been serving wildlife and the community for over 30 years
and they are Australia’s largest wildlife rescue organisation.
WIRES is dedicated to the protection and preservation of native animals.
They provide wildlife information and education to the community nationally and
They are licenced to rescue and care for wildlife in NSW.


Movie List
John
email: thoughtworks@com
phone number: 123456
Check personal information
Username
Password
Login
Remember me
Star Wars: Episode I - The Phantom Menace
Star Wars: Episode II - Attack of the Clones
Star Wars: Episode III - Revenge of the Sith
Star Wars
Star Wars: Episode V - The Empire Strikes Back
Star Wars: Episode VI - Return of the Jedi
Star Wars: Episode VII - The Force Awakens
Star Wars: Episode VIII - The Last Jedi
Star Wars: Episode IX - The Rise of Skywalker
Star Wars: Episode IX - The Rise of Skywalker
Cloud Atlas
Checkout:
please select a book


Win32 platform notes
Compiler options for VC++:
- Preprocessor definitions: WIN32, _WINDOWS
- Enable exception handling
- Enable RTTI
- Disable language extensions (actually NO, since <iostream> needs
the language extensions (how strange!)
- Additional include directories: d:\src\BW
- Add "d:\src\BW\[Debug|Release]\BW.lib" to start of library
modules
- Warning level 3 (Recommended)
- Enable incremental compilation (Recommended)


From Brain Drain to Brain Gain
sustainable education foundation
Helping local students connect with industry experts and academics around the world
exploreOur Projects
ScholarX is an exclusive 6-month mentoring program aimed at a selected pool of undergraduate students based in Sri Lanka.
2500+
hours of mentoring provided via our ScholarX program
The International Research Council (IRC) is a community created by SEF to showcase the work in various fields of Sri Lankan researchers.
100+
researchers of Sri Lankan origin representing the world's top universities
"OneLive" is an interactive webinar series done every weekend with the experts in their fields to expand the knowledge of Sri Lankan students.
275 000+
students reached via our Onelive interactive webinar series
AcadeMix aims to curate a collection of free education resources for Sri Lankan students to maximise their learning potential from Primary through to Post Graduate education.
100+
free online resources to learn from home
A 12 week program aimed at creating a non-competitive safe environment to develop English speaking skills for Sri Lankan undergraduates.
09
students improved their English speaking skills
Student Ambassadors (SA) of the Sustainable Education Foundation (SEF) will act as a liaison for SEF while also acting as an Evangelist for the Sustainable Education Foundation.
100+
students trained with soft skills required for the industry
Our Journey So Far
-
2016
We see a problem
Our Founder Dr Akshika Wijesundara notices a gap in the Sri Lankan higher education system where undergraduates lacked mentoring opportunities to achieve their career growth.
-
2017
SEF is born
The Sustainable Education Foundation is launched with the aim of building a connector platform to bring Sri Lankan subject matter experts in academia and industry to build a more sustainable education ecosystem in Sri Lanka.
-
2018
Expanding our reach
Our three flagship programs, ScholarX, International Research Council and OneLive are launched.
-
2019
Solidifying the base
We continue to deliver our flagship programs as we refine our operating rhythm and build our 10-year strategy looking forward to 2029.
-
2020/21
Growth and Expansion
Expand our flagship programs offering to multiple stakeholders and experiment with new programs to address more problems faced by undergraduates in Sri Lanka.
-
2022
Where we are today
Taking our programs mainstream, we launched a digital platform to extend our ScholarX program with minimal intervention from the SEF management. We look forward to expanding the platform to other areas serving more stakeholders.
-
2022/29
Beyond 2022
Our ultimate goals are to- Provide an end-to-end digital solution for the operations of SEF,
- Provide suggestions to educational policymakers in Sri Lanka to improve the educational landscape,
- Develop a STEM research facility in Sri Lanka that can produce high-tech startups with the help of the global Sri Lanka community, and
- Increase the percentage of Sri Lankans going for higher studies, working in world-leading companies, and founding future defining companies.
At SEF, we have something in store for everyone!
Students
Interact directly with a curated list of industry experts and academics across the globe via our host of programs including OneLive, ScholarX and IRC to gain valuable perspectives and insight on how to customise and innovate a new career path for you. Our AcadeMix and Student Ambassador Program offerings will also get you industry ready by your graduation and expose you to postgraduate, internship and job opportunities.
Experts
If you are an expert in the industry, join SEF, for we host mentoring programs, where you can showcase your expertise to the scholars seeking guidance. You will also get a chance to connect with the young talent in Sri Lanka, and make an impact on the Sri Lankan education system with the plethora of knowledge you possess.
Volunteers
Becoming a volunteer at SEF gives you a chance to develop skills that are of cruciality at coming top in the workforce, and to get exposed to startup workspace culture, by getting in touch with as well as managing a diverse intercontinental community.
Become one of the Volunteers!
Join the TeamSEF professionally organized a lecture I held about Advancements in DNA Sequencing, Bioinformatics and Cancer research. I was more than satisfied and amazed, especially about their strong efforts, devotion and philosophy of providing free education to the wide range of population. Hope the idea will be spread world wide.
I believe that education should be free and accessible to everyone! Great to see many initiatives by the SEF community - especially their efforts to encourage the young generation in Sri Lanka to achieve not only in the domestic settings but also in the international level. I wish SEF all the best, keep up the good work!
Its great to work with your team and I wish you good luck. Its a great opportunity for me to share my stories with upcoming entrepreneurs and I believe you will keep your great service to motivate the rest.


--- layout: post title: Computer science books that you must read date: 2012-08-07 08:04:53.000000000 +02:00 type: post published: true status: publish categories: - Development - research tags: - books - ComputerGraphics - ComputerScience meta: _edit_last: '38291848' tagazine-media: a:7:{s:7:"primary";s:0:"";s:6:"images";a:0:{}s:6:"videos";a:0:{}s:11:"image_count";i:0;s:6:"author";s:8:"38291848";s:7:"blog_id";s:8:"38859115";s:9:"mod_stamp";s:19:"2012-08-11 00:57:41";} author: login: virtualminder email<EMAIL_ADDRESS>display_name: AM Albalá first_name: '' last_name: '' ---
These books change the way I feel the Computer Science field or increase my skills dramatically:
Enjoy them!


Before we get into JavaScript’s ways of dealing with styles and classes – here’s an important rule. Hopefully it’s obvious enough, but we still have to mention it.
There are generally two ways to style an element:

style
:

.JavaScript can modify both classes and style
properties.
We should always prefer CSS classes to style
. The latter should only be used if classes “can’t handle it”.
For example, style
is acceptable if we calculate coordinates of an element dynamically and want to set them from JavaScript, like this:
let top = /* complex calculations */;
let left = /* complex calculations */;
elem.style.left = left; // e.g '123px', calculated at run-time
elem.style.top = top; // e.g '456px'
For other cases, like making the text red, adding a background icon – describe that in CSS and then add the class (JavaScript can do that). That’s more flexible and easier to support.
Changing a class is one of the most often used actions in scripts.
In the ancient time, there was a limitation in JavaScript: a reserved word like "class"
could not be an object property. That limitation does not exist now, but at that time it was impossible to have a "class"
property, like elem.class
.
So for classes the similar-looking property "className"
was introduced: the elem.className
corresponds to the "class"
attribute.
For instance:
html run
If we assign something to elem.className
, it replaces the whole string of classes. Sometimes that’s what we need, but often we want to add/remove a single class.
There’s another property for that: elem.classList
.
The elem.classList
is a special object with methods to add/remove/toggle
a single class.
For instance:
```html run```
So we can operate both on the full class string using className
or on individual classes using classList
. What we choose depends on our needs.
Methods of classList
:
elem.classList.add/remove("class")
– adds/removes the class.elem.classList.toggle("class")
– adds the class if it doesn’t exist, otherwise removes it.elem.classList.contains("class")
– checks for the given class, returns true/false
.Besides, classList
is iterable, so we can list all classes with for..of
, like this:
html run
The property elem.style
is an object that corresponds to what’s written in the "style"
attribute. Setting elem.style.width="100px"
works the same as if we had in the attribute style
a string width:100px
.
For multi-word property the camelCase is used:
js no-beautify background-color => elem.style.backgroundColor z-index => elem.style.zIndex border-left-width => elem.style.borderLeftWidth
For instance:
js run document.body.style.backgroundColor = prompt('background color?', 'green');
```smart header="Prefixed properties" Browser-prefixed properties like
-moz-border-radius,
-webkit-border-radius` also follow the same rule: a dash means upper case.
For instance:
````
Sometimes we want to assign a style property, and later remove it.
For instance, to hide an element, we can set elem.style.display = "none"
.
Then later we may want to remove the style.display
as if it were not set. Instead of delete elem.style.display
we should assign an empty string to it: elem.style.display = ""
.
will blink document.body.style.display = “none”; // hide
setTimeout(() => document.body.style.display = "", 1000); // back to normal ```
If we set style.display
to an empty string, then the browser applies CSS classes and its built-in styles normally, as if there were no such style.display
property at all.
```smart header="Full rewrite with
style.cssText" Normally, we use
style.*to assign individual style properties. We can't set the full style like
div.style=“color: red; width: 100px”, because
div.style` is an object, and it’s read-only.
To set the full style as a string, there’s a special property style.cssText
:
This property is rarely used, because such assignment removes all existing styles: it does not add, but replaces them. May occasionally delete something needed. But we can safely use it for new elements, when we know we won't delete an existing style.
The same can be accomplished by setting an attribute: `div.setAttribute('style', 'color: red...')`.
Don’t forget to add CSS units to values.
For instance, we should not set elem.style.top
to 10
, but rather to 10px
. Otherwise it wouldn’t work:
```
Please note: the browser “unpacks” the property style.margin
in the last lines and infers style.marginLeft
and style.marginTop
from it.
So, modifying a style is easy. But how to read it?
For instance, we want to know the size, margins, the color of an element. How to do it?
The style
property operates only on the value of the "style"
attribute, without any CSS cascade.
So we can’t read anything that comes from CSS classes using elem.style
.
For instance, here style
doesn’t see the margin:
```
…But what if we need, say, to increase the margin by 20px
? We would want the current value of it.
There’s another method for that: getComputedStyle
.
The syntax is:
::before
. An empty string or no argument means the element itself.
The result is an object with styles, like elem.style
, but now with respect to all CSS classes.
For instance:
```html run height=100```
```smart header=“Computed and resolved values” There are two concepts in CSS:
height:1em
or font-size:125%
.1em
or 125%
are relative. The browser takes the computed value and makes all units fixed and absolute, for instance: height:20px
or font-size:16px
. For geometry properties resolved values may have a floating point, like width:50.5px
.A long time ago getComputedStyle
was created to get computed values, but it turned out that resolved values are much more convenient, and the standard changed.
So nowadays getComputedStyle
actually returns the resolved value of the property, usually in px
for geometry. ```
```warn header="
getComputedStylerequires the full property name" We should always ask for the exact property that we want, like
paddingLeftor
marginTopor
borderTopWidth`. Otherwise the correct result is not guaranteed.
For instance, if there are properties paddingLeft/paddingTop
, then what should we get for getComputedStyle(elem).padding
? Nothing, or maybe a “generated” value from known paddings? There’s no standard rule here.
There are other inconsistencies. As an example, some browsers (Chrome) show 10px
in the document below, and some of them (Firefox) – do not:
html run <style> body { margin: 10px; } </style> <script> let style = getComputedStyle(document.body); alert(style.margin); // empty string in Firefox </script>
````
``smart header="Styles applied to
:visitedlinks are hidden!" Visited links may be colored using
:visited` CSS pseudoclass.
But getComputedStyle
does not give access to that color, because otherwise an arbitrary page could find out whether the user visited a link by creating it on the page and checking the styles.
JavaScript may not see the styles applied by :visited
. And also, there’s a limitation in CSS that forbids applying geometry-changing styles in :visited
. That’s to guarantee that there’s no side way for an evil page to test if a link was visited and hence to break the privacy. ```
To manage classes, there are two DOM properties:
className
– the string value, good to manage the whole set of classes.classList
– the object with methods add/remove/toggle/contains
, good for individual classes.To change the styles:
The style
property is an object with camelCased styles. Reading and writing to it has the same meaning as modifying individual properties in the "style"
attribute. To see how to apply important
and other rare stuff – there’s a list of methods at MDN.
The style.cssText
property corresponds to the whole "style"
attribute, the full string of styles.
To read the resolved styles (with respect to all classes, after all CSS is applied and final values are calculated):
getComputedStyle(elem, [pseudo])
returns the style-like object with them. Read-only.


Games
Music
Travel
movies
Sports
Bikes
Analytics
Coding
Studied basic electronics, microprocessors, digital and analogue communication, analogue integrated circuits, satellite communication, antennae and wave progression. Deals with electronic devices, circuits, and communications equipment.
PCM means - Physics, Chemistry and Mathematics. PCM is group of subjects can apply Professinal Course during their degree level.
Learning to Design, Develop, Modify and Debug Software code according to technical design specification of a web application Using Java platform.
Learning software development life cycle (SDLC), frontend and backend technologies through various resources available online through w3school, Udemy, and edX. Completed training on HTML/CSS, SQL, Power BI.


Clients subscribe to server-side events by using SQL-type query filtering. The server sends all events that modify the query results. CQ event delivery uses the client/server subscription framework.
With CQ, the client sends a query to the server side for execution and receives the events that satisfy the criteria. For example, in a region storing stock market trade orders, you can retrieve all orders over a certain price by running a CQ with a query like this:
SELECT * FROM /tradeOrder t WHERE t.price > 100.00
When the CQ is running, the server sends the client all new events that affect the results of the query. On the client side, listeners programmed by you receive and process incoming events. For this example query on /tradeOrder
, you might program a listener to push events to a GUI where higher-priced orders are displayed. CQ event delivery uses the client/server subscription framework.
Logical Architecture of Continuous Querying
Your clients can execute any number of CQs, with each CQ assigned any number of listeners.
Data Flow with CQs
CQs do not update the client region. This is in contrast to other server-to-client messaging like the updates sent to satisfy interest registration and responses to get requests from the client’s Pool
. CQs serve as notification tools for the CQ listeners, which can be programmed in any way your application requires.
When a CQ is running against a server region, each entry event is evaluated against the CQ query by the thread that updates the server cache. If either the old or the new entry value satisfies the query, the thread puts a CqEvent
in the client’s queue. The CqEvent
contains information from the original cache event plus information specific to the CQ’s execution. Once received by the client, the CqEvent
is passed to the onEvent
method of all CqListener
s defined for the CQ.
Here is the typical CQ data flow for entries updated in the server cache:
- Entry events come to the server’s cache from the server or its peers, distribution from remote sites, or updates from a client.
- For each event, the server’s CQ executor framework checks for a match with its running CQs.
- If the old or new entry value satisfies a CQ query, a CQ event is sent to the CQ’s listeners on the client side. Each listener for the CQ gets the event.
In the following figure:
- Both the new and old prices for entry X satisfy the CQ query, so that event is sent indicating an update to the query results.
- The old price for entry Y satisfied the query, so it was part of the query results. The invalidation of entry Y makes it not satisfy the query. Because of this, the event is sent indicating that it is destroyed in the query results.
- The price for the newly created entry Z does not satisfy the query, so no event is sent.
CQ Events
CQ events do not change your client cache. They are provided as an event service only.  If you need to persist information from CQ events, program your listener to store the information where it makes the most sense for your application.
The CqEvent
object contains this information:
- Entry key and new value.
- Base operation that triggered the cache event in the server. This is the standard
Operation
class instance used for cache events in GemFire. -
CqQuery
object associated with this CQ event. -
Throwable
object, returned only if an error occurred when theCqQuery
ran for the cache event. This is non-null only forCqListener
onError calls. - Query operation associated with this CQ event. This operation describes the change affected to the query results by the cache event. Possible values are:
-
CREATE
, which corresponds to the standard database -
INSERT
operation -
UPDATE
-
DESTROY
, which corresponds to the standard database DELETE operation
-
Region operations do not translate to specific query operations and query operations do not specifically describe region events. Instead, the query operation describes how the region event affects the query results.
| Query operations based on old and new entry values | New value does not satisfy the query | New value satisfies the query |
|---|---|---|
| Old value does not satisfy the query | no event | CREATE query operation |
| Old value does satisfies the query | DESTROY query operation |
UPDATE query operation |
You can use the query operation to decide what to do with the CqEvent
in your listeners. For example, a CqListener
that displays query results on screen might stop displaying the entry, start displaying the entry, or update the entry display depending on the query operation.
Region Type Restrictions for CQs
You can only create CQs on replicated or partitioned regions. If you attempt to create a CQ on a non-replicated or non-partitioned region, you will receive the following error message:
The region <region name> specified in CQ creation is neither replicated nor partitioned; only replicated or partitioned regions are allowed in CQ creation.
In addition, you cannot create a CQ on a replicated region with eviction setting of local-destroy since this eviction setting changes the region’s data policy. If you attempt to create a CQ on this kind of region, you will receive the following error message:
CQ is not supported for replicated region: <region name> with eviction action: LOCAL_DESTROY
See also Configure Distributed, Replicated, and Preloaded Regions for potential issues with setting local-destroy eviction on replicated regions.


These Terms and Conditions (hereinafter “Terms and Conditions”, “Terms” or “Agreement”) are an electronic agreement between you (hereinafter the “User”) and Kyber Network International Limited (C 87947), a company incorporated in Malta and having its registered address at 66, Old Bakery Street, Valletta VLT 1454 Malta (hereinafter “KYBER”) that applies to your use of this website, all services, products and content provided by KYBER.
The text of this Agreement permanently located at https://files.kyber.network/tac-eu.html contains all the essential conditions of the public offer of KYBER. By signing up to use an account through https://kyber.network/swap or any of our associated websites, APIs, or mobile applications (collectively the "KYBER Site" or “Website”), you agree that you have read, understood, and accept all of the terms and conditions contained in this Agreement and any annexes attached hereto, as well as in our Privacy Policy and Cookie Policy (available at https://files.kyber.network/privacy.html).
References in this Agreement to "KYBER", "we", "our" or "us", are to Kyber Network International Limited, and references to "you" or "your" are to the User with whom KYBER enters into this Agreement.
Your use of the Services is subject to these Terms as may be amended by us from time to time at our sole and absolute discretion. Any changes will be uploaded on the Website and shall take effect from the date of upload. Your continued access or use of the Website and/or the Services from such date shall be deemed to constitute acceptance of the new Terms. It shall be your sole responsibility to check the Website for such changes from time to time.
In these Terms, unless the context otherwise requires:
“Address” means an address on the Ethereum blockchain; “Advanced User” means a User subject to the Advanced User Prescribed Limit; “Advanced User Account” has the meaning ascribed thereto in Clause 3.2.1 of these Terms; “Advanced User Prescribed Limit” has the meaning ascribed thereto in Clause 7.2 of these Terms; “Affiliates” means with respect to any person, any other person directly or indirectly controlling, controlled by or under common control with such person; “Applicable Laws” means all relevant or applicable statutes, laws (including any reporting and/or withholding tax requirements of any government), rules, regulations, directives, circulars, notices, guidelines and practice notes of any Governmental Authority, including any applicable data protection and privacy laws such as Regulation (EU) 2016/679 on the protection of natural persons with regard to the processing of personal data and on the free movement of such data (the “General Data Protection” or “GDPR”); “Business Day” means a day other than a Saturday, Sunday or a gazetted public holiday in Malta; “Completed Token Exchange” in respect of a Token Exchange Order transmitted by a User or Token Exchange in respect thereof, means: such User’s transfer of Offer Token(s) in the Offer Token Quantity (as specified in the Token Exchange Order) from the User Address to the Smart Contract Address, and onward transfer of such Offer Token(s) from the Smart Contract Address to the User Address(es) of the Counterparty User(s); and transfer by Counterparty User(s) of Request Token(s) in such Request Token Quantity (as specified in the Token Exchange Order) to the Smart Contract Address, and onward transfer of such Request Token(s) from the Smart Contract Address to such User Address; and all transfers necessary to affect the above each having at least thirty (30) confirmations thereof on the blockchain applicable to each of such transfer or if each of such transfer satisfies the consensus mechanism of the blockchain applicable to such transfer, whereby such transfer is effectively immutable; “Counterparty User” in relation to a User who has transmitted a Token Exchange Order, means another User who has transmitted another Token Exchange Order and where: (a) the Offer Token(s) subject of the first-mentioned Token Exchange Order is of the same Supported Token type as the Request Token(s) that are subject of the second-mentioned Token Exchange Order; and (b) the Request Token(s) subject of the first-mentioned Token Exchange Order is of the same Supported Token type as the Offer Token(s) that are subject of the second-mentioned Token Exchange Order; “Disqualified Person/Entity” means (a) any person or body corporate seeking to access the Website / use the Services from within the Excluded Countries; (b) any person (being a natural person) who is a citizen of, domiciled in, or resident of, a country whose laws prohibit or conflict with the access of the Website or use of the Services; (c) any body corporate that is incorporated in, domiciled in, or organised in, a country whose laws prohibit or conflict with the access of the Website or use of the Services; and/or(d) any person who has not yet reached eighteen (18) years of age; “Double Spending” means the use, or attempted use, of the same Virtual Financial Asset in more than one transaction or other similar arrangement; “ETH” means Ether, the cryptographic token native to the Ethereum network. For the avoidance of doubt, ETH does not refer to Ethereum Classic; “Ethereum” means the decentralised platform as described in https://www.ethereum.org; “Exchange Services” means the facilitation of Token Exchange by way of KYBER Smart Contract made available by KYBER through the KYBER Platform; “Excluded Countries” Afghanistan, Belarus, Bosnia and Herzegovina, Burundi, Central African Republic, Democratic Republic of the Congo, Egypt, Eritrea, Ethiopia, Iran, Iraq, Libya, Mali, North Korea, Republic of Guinea-Bissau, Republic of Vanuatu, Somalia, South Sudan, Sri Lanka, Sudan, Syria, Trinidad and Tobago, Tunisia, Ukraine, Venezuela, Yemen and Zimbabwe; “Fork” or “Forking” means a change in the existing source code or the creation of new or additional source code for a blockchain; “General User” means a User subject to General User Prescribed Limits; “General User Prescribed Limit” has the meaning ascribed thereto in Clause 7.1 of these Terms; “Governmental Authority” means any nation or government, any state or other political subdivision thereof, any entity exercising legislative, executive, judicial or administrative functions of or pertaining to government, including, without limitation, any government authority, agency, department, board, commission or instrumentality, and any court, tribunal or arbitrator(s) of competent jurisdiction, and any self-regulatory organization. For the avoidance of doubt, Governmental Authority may include private bodies exercising quasigovernmental, regulatory or judicial-like functions to the extent they relate to either you, any Kyber Affiliate (including KYBER), the Supported Tokens and/or the Services; “Indicated Spot Exchange Rate” means the relevant Offer Token to Request Token exchange rate as indicated on the Website in respect of a Token Exchange, which shall be indicative only and subject to change at our sole and absolute discretion at any time; “KNC” means Kyber Network Crystals, the cryptographic token native to the KYBER Platform; “KYBER” has the meaning ascribed thereto in Clause 1.1 of these Terms; “KYBER Smart Contract” means the source code which comprises the basis for the protocols to facilitate a Token Exchange; “KYBER Platform” means the operating systems to facilitate the Services including but not limited to the KYBER Smart Contract; “Kyber Affiliate” refers to legal entities that are wholly owned by Jedha Holdings Pte. Ltd. (but excluding MAW Holdings Private Limited which is the holding company for Kyber International Limited); “Kyber Group” refers to all legal entities wholly owned by Jedha Holdings Pte. Ltd. “Loss” means any and all losses, claims, liabilities, damages, suits, actions, demands, proceedings, costs, charges and/or expenses of whatsoever nature or howsoever arising, including any indirect, special, incidental, consequential or other losses of any kind, in tort, contract or otherwise (including but not limited to loss of revenue and income or profits); “Network Fees” means such transaction cost payable, whether denominated in Virtual Financial Assets or otherwise, for the use of or execution of transactions on a network (including but not limited to the Ethereum network); “Prohibited Uses” has the meaning ascribed thereto in Clause 11.3 of these Terms; “Refund Tokens” has the meaning ascribed thereto in Clause <IP_ADDRESS> of these Terms; “Services” means the services and/or content provided by the Kyber Group on or through the Website, mobile services or otherwise, including but not limited to Exchange Services but shall not include any Third Party Integrated Applications; “Supported Tokens” means the VFAs as set out in Annex A of these Terms or such other Virtual Financial Assets as determined by KYBER in accordance with Clause 6 of these Terms; “Third Party Fees & Charges” has the meaning ascribed thereto in Clause 5.2 of these Terms; “Third Party Integrated Applications” means the third party applications and interfaces which are integrated to the Website, including but not limited to the Status, Token, Metamask, CoinManager and TrustWallet applications; “Token Exchange” means an exchange of Offer Tokens in the Offer Token Quantity for Request Tokens in the Request Token Quantity; “Token Exchange Order” means a transmitted application by a User on the Website to enter into a Token Exchange; “Token Exchange Attempt” means any act by you to affect a Token Exchange, including but not limited to a Token Exchange Order or the transfer of Offer Tokens by you to the Smart Contract Address in connection with such Token Exchange Order; “Smart Contract Address” in respect of Offer Tokens that are subject of a Token Exchange Order or Token Exchange of a User, means the Address for the KYBER Smart Contract as designated by KYBER for such User to transfer such Offer Tokens for purposes of Token Exchange; “User” means a person or body corporate seeking to use the Website / the Services; “User Address” in respect of a User means the Address designated by such User that is in compliance with Clause 3.3 of these Terms; “Exchange Fee” has the meaning ascribed thereto in Clause 5.1 of these Terms; “User Information” or “Account” in respect of a User has the meaning ascribed thereto in Clause 3.1.1 of these Terms; “Offer Token” in respect of a User means the Supported Token that such User is offering in exchange for Request Token in relation to a Token Exchange; “Offer Token Quantity” means the amount of Offer Tokens (excluding Third Party Fees & Charges) which you are seeking to deliver to the Smart Contract Address in exchange for such Request Token Quantity based on the relevant Indicated Spot Exchange Rate pursuant to the KYBER Smart Contract; “Offer Token Refund” has the meaning ascribed thereto in Clause <IP_ADDRESS> of these Terms; “Request Token” means the Supported Token that you are requesting to receive in exchange for Offer Token in relation to a Token Exchange; “Request Token Quantity” means the amount of Request Tokens which you are requesting to receive in exchange for such Offer Token Quantity based on the relevant Indicated Spot Exchange Rate pursuant to the KYBER Smart Contract; “Virtual Financial Asset” or “VFA” means any form of digital medium recordation that is used as a digital medium of exchange, unit of account, or store of value and that is not – (a) electronic money; (b) a financial instrument; or (c) a virtual token; “Whitepaper” means the version of the whitepaper entitled “Kyber Network - A trusted decentralized exchange and payment service”, version number 8 [•] published on 27th August 2017[date], accessible on https://files.kyber.network/KyberNetworkWhitepaper.pdf; and “US$” means the lawful currency of the United States of America.The list of supported tokens are published on https://kyber.network/swap/eth_knc, and may change from time to time.
You should carefully consider and evaluate each of the following risk factors and all other information contained in these Terms before deciding to use any of the Services. To the best of our knowledge and belief, the risk factors which are material to you in making an informed judgement to use the Services have been set out below.
We may experience system failures, unplanned interruptions in our network or services, hardware or software defects, security breaches or other causes that could adversely affect our infrastructure network, and/or the KYBER Platform
We are unable to anticipate when there would be occurrences of hacks, cyber-attacks, mining attacks (including but not limited to double-spend attacks, majority mining power attacks and “selfish-mining” attacks), distributed denials of service or errors, vulnerabilities or defects in the KYBER Platform, the Supported Tokens, the User Address, the Advanced User Account, the Smart Contract Address, the KYBER Smart Contract, or any technology (including but not limited to smart contract technology) on which we, the KYBER Platform, the Supported Tokens, the User Address, the Advanced User Account, the Smart Contract Address, the KYBER Smart Contract, relies or on the Ethereum blockchain or any other blockchain associated with the Supported Tokens. Such events may include, for example, flaws in programming or source code leading to exploitation or abuse thereof. We may not be able to detect such hacks, mining attacks (including but not limited to double-spend attacks, majority mining power attacks and “selfish-mining” attacks), cyber-attacks, distributed denials of service errors vulnerabilities or defects in a timely manner and may not have sufficient resources to efficiently cope with multiple service incidents happening simultaneously or in rapid succession.
Our Services could be disrupted by numerous events, including natural disasters, equipment breakdown, network connectivity downtime, power losses, or even intentional disruptions of our services, such as disruptions caused by software viruses or attacks by unauthorised users, some of which are beyond our control. Although we have taken steps to guard against malicious attacks on our appliances and infrastructure, which are critical for the maintenance of the KYBER Platform and the Services, there can be no assurance that cyber-attacks, such as distributed denials of service, will not be attempted in the future, and that any of our enhanced security measures will be effective. We may be prone to attacks on our infrastructure intended to steal information about technology, financial data or user information or take other actions that would be damaging to us and Users. Any significant breach of our security measures or other disruptions resulting in a compromise of the usability, stability and security of our network or Services (including the KYBER Platform) may adversely affect the public confidence in our network or Services.
We are dependent in part on the location and data centre facilities of third parties
Our infrastructure network is in part established on servers which are owned or housed at the location facilities of third parties, and/or servers that it rents at data centre facilities of third parties. If we are unable to maintain such network on commercially reasonable terms or at all, we may be required to transfer our services to a new data centre facility and may incur significant costs and possible service interruption in connection with the relocation. These facilities are also vulnerable to damage or interruption from, among others, natural disasters, arson, terrorist attacks, power losses, and telecommunication failures. Additionally, the third party providers of such facilities may suffer a breach of security as a result of third party action, employee error, malfeasance or otherwise, and a third party may obtain unauthorised access to the data in such servers. As techniques used to obtain unauthorised access to, or to sabotage systems change frequently and generally are not recognised until launched against a target, the Kyber Group and the providers of such facilities may be unable to anticipate these techniques or to implement adequate preventive measures.
Legality of the Services and/or Supported Tokens may be subject to clarification, implementation or change
The Applicable Laws in relation to the Services and/or the Supported Tokens in various jurisdictions may be uncertain and/or subject to clarification, implementation or change. In the event of such clarification, implementation or change, the availability of the Services and/or the Supported Tokens (in connection with the Services) may be adversely affected, including but not limited to the suspension or deactivation of the Services and/or the availability of the Supported Tokens (in connection with the Services).
We may also have to take measures to comply with such regulations, or have to deal with queries, notices, requests or enforcement actions by regulatory authorities, which may come at a substantial cost and may also require substantial modifications to the KYBER Platform. This may impact the appeal of the KYBER Platform for users and result in decreased usage of the KYBER Platform.
Further, should the costs (financial or otherwise) of complying with such newly implemented regulations exceed a certain threshold, maintaining the KYBER Platform may no longer be commercially viable and we may opt to suspend or deactivate the Services. Further, it is difficult to predict how or whether governments or regulatory authorities may clarify, implement or change any Applicable Laws affecting distributed ledger technology and its applications, including the Services. We may also have to cease operations in a jurisdiction that makes it illegal to operate in such jurisdiction or make it commercially unviable or undesirable to obtain the necessary regulatory approval(s) to operate in such jurisdiction.
Certain parts of our work and processes may risk being disrupted by new technologies that may emerge
New technologies may emerge and have a disruptive effect on certain parts of our work and processes. In particular, blockchain technology is rapidly developing and evolving, and technological advancements may render certain or all parts of our work and processes obsolete and ineffective. This may have an adverse effect on the demand for the Services, the Indicated Spot Exchange Rate of Supported Tokens, and the availability of Supported Tokens from Counterparty User(s).
Negative publicity may materially and adversely affect the Indicated Spot Exchange Rate and/or availability of Supported Tokens
Negative publicity involving the Kyber Group or any Kyber Affiliate (including KYBER), the KYBER Platform, or any of the key personnel of a Kyber Affiliate (including KYBER) may materially and adversely affect the market perception of Kyber Group, whether or not such negative publicity is justified. This may have an adverse effect on the demand for the Services, the Indicated Spot Exchange Rate of Supported Tokens, and the availability of Supported Tokens from Counterparty User(s).
The KYBER Platform, User Address, Advanced User Account and Supported Tokens are exposed to risk of attacks
While we will make every effort to ensure that the Exchange will be securely executed through rigorous security audit of the KYBER Smart Contract, there is no assurance that the KYBER Platform (including the KYBER Smart Contract and the Smart Contract Address) and/or the User Address and the Advanced User Account will not be subject to hacks, mining attacks (including but not limited to double-spend attacks, majority mining power attacks and “selfishmining” attacks), sophisticated cyber-attacks, distributed denials of service or errors, vulnerabilities or defects on the KYBER Platform or any other blockchain, or otherwise. Such events may occur as a result of, for example, flaws in programming or source code leading to exploitation or abuse thereof. In such event(s), the Services may be disrupted, and the Supported Tokens may even be stolen or diverted to a different address. Unless you specifically obtain private insurance to insure Supported Tokens, you may not have any recourse as a result of such loss of Supported Tokens.
There may be unanticipated risks arising from the use of the Services
Decentralised cryptographic token exchanges such as the KYBER Platform are a relatively new and dynamic technology. In addition to the risks included hereto, there are other risks associated with your use of the KYBER Platform, including those that we cannot anticipate. Such risks may further materialise as unanticipated variations or combinations of the risks discussed hereto.
There is no assurance of an active or liquid market for Supported Tokens
There is no assurance that an active or liquid trading market for Supported Tokens will develop or if developed, be sustained after the Supported Tokens have been made available for trading on the KYBER Platform. The Supported Tokens are generally not a currency issued by any central bank or national, supra-national or quasi-national organisation, nor is it backed by any hard assets or other credit. Trading of Supported Tokens depends on the consensus on its value between the relevant market participants, there is no guarantee as to the liquidity or market price of Supported Tokens to any extent at any time. Accordingly, we cannot ensure that there will be any demand or market for Supported Tokens, or that the Indicated Spot Exchange Rate is indicative of the market price of Supported Tokens
The trading price of Supported Tokens may fluctuate
The prices of cryptographic tokens in general tend to be relatively volatile, and can fluctuate significantly over short periods of time. The demand for, and correspondingly the market price of, Supported Tokens may fluctuate significantly and rapidly in response to, among others, the following factors:
Understanding cryptographic token technology requires technical knowledge
Cryptographic tokens are often described in exceedingly technical language that requires a comprehensive understanding of applied cryptography and computer science in order to appreciate the inherent risks. The availability of Supported Tokens on the KYBER Platform do not indicate approval or disapproval of the underlying technology regarding any Supported Token, and should not be used as a substitute for your own understanding of the risks specific to each Supported Token. We give you no undertaking or warranty as to the suitability of the Supported Tokens traded under these Terms and assume no duty in our relations with you. By using the Services, you acknowledge and agree that you have a basic degree of understanding of the operation, functionality, usage, storage, transmission mechanisms, and other material characteristics of cryptocurrencies, blockchain assets, and cryptographic tokens including the Supported Tokens, blockchain-based software systems, cryptocurrency wallets or other related token storage mechanisms, blockchain technology and smart contract technology
None of the information available on the Website or made available to you in relation to the use of Services constitutes advice
None of the information available on the Website or made available to you in relation to the use of Services (including but not limited to the Indicated Spot Exchange Rate provided in respect of a Token Exchange, which is not indicative of the price at which certain Supported Tokens are being traded on the KYBER Platform or other cryptocurrency exchange platforms) constitutes any advice, including but not limited to legal, tax, financial or trading advice. If you are in any doubt as to the action you should take, you should consult your legal, financial, tax or other professional advisors.
A Token Exchange may not be reversible
While the KYBER Platform is designed to execute Offer Token Refund in certain events, transactions which have been signed by the transferor and verified on blockchain networks are generally immutable and effectively irreversible. In the event that you send Offer Tokens to any other destination other than the KYBER Smart Contract, such Offer Tokens may not be returned. None of the Kyber Affiliates (including KYBER) assumes any responsibility or makes any warranties or undertakings and shall have no obligation to you if any of the foregoing events occur, including but not limited to any responsibility to recover, or aid / assist in the recovery, of such Offer Tokens.


Technical skills
Education
MSc. Computer Science from Technical University of Munich (TUM), Germany (2013 - 2015)
B.Eng. Information and Communication System Engineering from NUST-SEECS, Pakistan (2007 - 2011)
Professional experience
- Huawei(Oct, 2019 - current)
-
Lead Partner Engineering
My team’s role at Huawei is to help developers seamlessly integrate our HMS Core Kits and be the ears and eyes of Huawei to continuously improve our technology and developer experience.
My role at Huawei is focused on bringing innovative platforms closer to our partners, and developers to enable mult-device scenarios in real-life. This involves a diverse set of responsibilities like taking lead on topics related to promoting platforms, educating partners' developers, offering necessary tech support and optimizing end-to-end developer experience ✌ Talk to me if you want to partner with us or want to know more about our platforms or just say "Hi" anyway :) I would love to connect!


Preface
I am a male 295lbs, currently taking Zyprexa, Zoloft, & Zanex. When Salvia Divinorum is used, the human perception is opened up to one or more alternate dimensions. More than likely these dimensions occupy the same space. This theory has been discussed by many people. This is what I have picked up. This theory is dependent on the existence of a fourth dimension, geometrically speaking, for lack of a better term.
 Imagine the surface of the wall is a 2-dimensional world. Remember Flatland?  In the 2-dimensional world (the surface of the wall) it would appear that two separate objects (your body and your hand) are occupying the same space. Clearly, in our 3-dimensional world, they are not occupying the same space, a 3rd dimension is added and an infinite number of body parts could be placed one in front of the other on a 3 dimensional plane. But in the 2-dimensional world all of the objects would appear to be occupying the same space.
So if a 2-dimensional world cannot grasp the addition of a third dimension, than doesn't it make sense that our 3-dimensional world cannot grasp the addition of a fourth dimension? And it is almost certain that a fourth dimension exists. And in a similar way to that mentioned before, an infinite number of three dimensional worlds could appear to occupy the same space, when in reality the are merely added to a four dimensional plane.
One might think to travel to these other dimensions would be impossible, and in a physical sense it sort of is. But if an infinite number of alternate dimensions are occupying the same 3-dimensional space, physical travel is unnecessary, we are already there. The only thing left to separate us from these alternate dimensions is our perception. Our human brains natively only perceive the dimension that we are perceptually occupying.
That is where Salvia Divinorum comes in. It is possible to perceive alternate, initially entry, dimensions with the help of Salvinorin A (C23H28O8).
The length of time out of your dimension and into another, and the depth traveled into an alternate dimension, are both dependent on the amount smoked.
The Journey Begins
First experience - Leaves, dried and smoked, 2 bowls, pipe
I physically felt myself being pulled back by my skull. By whom I did, and do not know. I felt strongly disassociated from reality.
Second experience - Leaves, dried and smoked, 1 bowl, bong
I put down the bong (a three footer), it turned into a fantastic musical instrument the likes of which I have never seen or been able to imagine. The sight gave me a scare, the object, once normal, had turned into an object I could hardly fathom. I sat back, anxiety turned into a physical fire that spread throughout my body. Pulled back into flames. Felt a strong female presence, and a male, possibly her right hand man. She said nothing. He only laughed at my ignorance and inexperience. This was my first encounter w/ lady Saliva, and the strong presence of entities gave me a strong impression that I was literally somewhere else. Not like on a shroom trip, or an acid spin, but actually a different reality.
Third experience - Extract 5x, dried and smoked, 1 bowl, pipe
First time with extract. Very unprepared. All I heard were numerous people laughing at me. There was no contact with the lady, but a man asked me why I went into this so unprepared.
Fourth experience - Extract 5x, dried and smoked, 1 bowl, pipe
Very prepared at this point. I had read everything I could get my hands on about Saliva and peoples experience with it. It seems some people actually hinted at the fact that this was a gateway to an alternate dimension. It sounds weird, but paper after paper, all uncanny similarities.
I felt my physical self as a series of connected unzipped zippers. A Lady (initially presumed it was lady Saliva again) began to zip up my body, zipper by zipper, starting with the legs. Slowly moving up the body. She was communicating with me telepathically, I could say or think nothing, only listen. She told me I could learn some of the things I wanted to, but I would have to trust her. She got closer and closer to my head. My claustrophobia kicked in and it occurred to me she could be a ruse, sent to seduce and capture my mind. I somehow pulled myself out of the experience. I was immediately disappointed in myself for not trusting her. 'What could I have learned, what could I have seen?'
Fifth experience - extract 10x, dried and smoked, 1 bowl, pipe
Before I even exhaled, I was hurled deep into the entry dimension of Saliva. My reality was a slice in an infinite series of vertical slices. Each slice was a different reality, all were spinning in circles, I too was spinning. No encounters with lady Saliva or her men. The spinning stopped and falling started. Down, down, felt like forever. No sense of my physical self.
My journey through the entry dimension and beyond is far from over. I share this report incomplete, for the purpose of information. The true explorers out there will love the journey brought about by my ally Saliva. And a warning to those who are still ignorant, tread not on these grounds, for ignorance is not a welcome in the depths of said dimension. There are many other things to do out there that will get you a good time, if thats what you are looking for. This however is just a tinge more profound, intensely profound.
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.


| Ranking |
{{car.ranking}} |
Category ranking |
{{car.categoryPosition}} |
Car No. |
{{car.number}} |
State |
{{car.state}} |
Category |
{{car.category}} |
Team |
{{car.team}} |
Tyre |
{{car.tyre}} |
Driver |
{{car.driver}} |
Car |
{{car.car}} |
Gap |
{{car.gap}} |
Pitstop |
{{car.pitstop}} |
Best lap |
{{car.bestlap}} |
Best Sector 1 |
{{car.bestSector1}} |
Best Sector 2 |
{{car.bestSector2}} |
Best Sector 3 |
{{car.bestSector3}} |
Current sector 1 |
{{car.currentSector1}} |
Current sector 2 |
{{car.currentSector2}} |
Current sector 3 |
{{car.currentSector3}} |


class: center, middle, inverse, title-slide .title[ # Production Project ] .institute[ ### Simple Modern ] --- layout: true background-image: url(logo/logo.png) background-position: 0% 100% background-size: 5% ---  # Goal

 ## Develop model for manufacturing production allocation --- .pull-left[ Current Workflow
] -- .pull-right[ Future Workflow
] --- class: center # Excel File Inputs/Outputs --  --  --- # Features to adjust/model constraints and considerations - Capacity of manufacturer -- Will change based on number of manufacturers and if products are limited to certain manufacturers -- - Product level forecast/estimated -- This is a constraint implemented in the model so that not all a certain product volume is allocated too soon/too late in the year -- - Yearly production/forecast -- This can be changed in the Excel file if the forecast is altertered or more needs to be allocated on a certain week and there is certainty around that. -- - Products --- General timeline --


@Evolving
public interface BatchWrite
The writing procedure is:
createBatchWriterFactory(PhysicalWriteInfo)
, serialize
and send it to all the partitions of the input data(RDD).DataWriter.commit()
. If
exception happens during the writing, call DataWriter.abort()
.commit(WriterCommitMessage[])
. If
some writers are aborted, or the job failed with an unknown reason, call
abort(WriterCommitMessage[])
.While Spark will retry failed writing tasks, Spark won't retry failed writing jobs. Users should do it manually in their Spark applications if they want to retry.
Please refer to the documentation of commit/abort methods for detailed specifications.
| Modifier and Type | Method and Description |
|---|---|
void |
abort(WriterCommitMessage[] messages)
Aborts this writing job because some data writers are failed and keep failing when retry,
or the Spark job fails with some unknown reasons,
or
onDataWriterCommit(WriterCommitMessage) fails,
or commit(WriterCommitMessage[]) fails. |
void |
commit(WriterCommitMessage[] messages)
Commits this writing job with a list of commit messages.
|
DataWriterFactory |
createBatchWriterFactory(PhysicalWriteInfo info)
Creates a writer factory which will be serialized and sent to executors.
|
default void |
onDataWriterCommit(WriterCommitMessage message)
Handles a commit message on receiving from a successful data writer.
|
default boolean |
useCommitCoordinator()
Returns whether Spark should use the commit coordinator to ensure that at most one task for
each partition commits.
|
DataWriterFactory createBatchWriterFactory(PhysicalWriteInfo info)
If this method fails (by throwing an exception), the action will fail and no Spark job will be submitted.
info
- Physical information about the input data that will be written to this table.default boolean useCommitCoordinator()
default void onDataWriterCommit(WriterCommitMessage message)
abort(WriterCommitMessage[])
would be called.void commit(WriterCommitMessage[] messages)
DataWriter.commit()
.
If this method fails (by throwing an exception), this writing job is considered to to have been
failed, and abort(WriterCommitMessage[])
would be called. The state of the destination
is undefined and @abort(WriterCommitMessage[])
may not be able to deal with it.
Note that speculative execution may cause multiple tasks to run for a partition. By default,
Spark uses the commit coordinator to allow at most one task to commit. Implementations can
disable this behavior by overriding useCommitCoordinator()
. If disabled, multiple
tasks may have committed successfully and one successful commit message per task will be
passed to this commit method. The remaining commit messages are ignored by Spark.void abort(WriterCommitMessage[] messages)
onDataWriterCommit(WriterCommitMessage)
fails,
or commit(WriterCommitMessage[])
fails.
If this method fails (by throwing an exception), the underlying data source may require manual
cleanup.
Unless the abort is triggered by the failure of commit, the given messages should have some
null slots as there maybe only a few data writers that are committed before the abort
happens, or some data writers were committed but their commit messages haven't reached the
driver when the abort is triggered. So this is just a "best effort" for data sources to
clean up the data left by data writers.


Rebelo\SaftPt\AuditFile\TaxAccountingBasis
TaxAccountingBasis
 Shall be filled in with the type of program, indicating the applicable data (including the transport documents, conference documents and issued receipts, if any):
 “C” - Accounting;
 “E” - Invoices issued by third parties;
 “F” - Invoicing;
 “I” - Invoicing and accounting integrated data;
 “P” - Invoicing partial data.
 “R” - Receipts (a);
 “S” - Self-billing;
 “T” - Transport documents (a).
 (a) Type of program should be indicated, in case only this type of documents are issued. If not, fill in with type “C”, “F” or “I”.

<xs:element name="TaxAccountingBasis">
<xs:simpleType>
<xs:restriction base="xs:string">
<xs:enumeration value="C"/>
<xs:enumeration value="E"/>
<xs:enumeration value="F"/>
<xs:enumeration value="I"/>
<xs:enumeration value="P"/>
<xs:enumeration value="R"/>
<xs:enumeration value="S"/>
<xs:enumeration value="T"/>
</xs:restriction>
</xs:simpleType>

- Author: João Rebelo
Synopsis
class TaxAccountingBasis
extends AEnum
{
- // constants
- const CONTABILIDADE = "C";
- const FACT_POR_TERC = "E";
- const FACTURACAO = "F";
- const CONTAB_FACTURACAO = "I";
- const FACT_PARCIAL = "P";
- const RECEIBOS = "R";
- const AUTOFATURACAO = "S";
- const TRANSPORTE = "S";
- const DOC_TRANSP = "T";
- // methods
- public void __construct()
- public string get()
Hierarchy
Extends
- Rebelo\Enum\AEnum
Constants
| Name | Value |
|---|---|
| CONTABILIDADE | "C" |
| FACT_POR_TERC | "E" |
| FACTURACAO | "F" |
| CONTAB_FACTURACAO | "I" |
| FACT_PARCIAL | "P" |
| RECEIBOS | "R" |
| AUTOFATURACAO | "S" |
| TRANSPORTE | "S" |
| DOC_TRANSP | "T" |
Methods
public
- __construct()
- get() — Get the value as string


|
Bosch XDK110 Solace MQTT App
2.0.1
MQTT Reference Application for the Bosch XDK110
|
Structure to represent the MQTT connect features. More...
#include <AppXDK_MQTT.h>
Data Fields | |
| const char * | clientId |
| const char * | brokerUrl |
| uint16_t | brokerPort |
| const char * | username |
| const char * | password |
| bool | isCleanSession |
| uint32_t | keepAliveIntervalSecs |
Structure to represent the MQTT connect features.
| uint16_t brokerPort |
The port number of the MQTT broker
| const char* brokerUrl |
The URL pointing to the MQTT broker
| const char* clientId |
The client id to connect with. must be unique across the universe. best to use the device id.
| bool isCleanSession |
The clean session flag indicates to the broker whether the client wants to establish a clean session or a persistent session where all subscriptions and messages (QoS 1 & 2) are stored for the client.
| uint32_t keepAliveIntervalSecs |
The keep alive interval (in seconds) is the time the client commits to for when sending regular pings to the broker. The broker responds to the pings enabling both sides to determine if the other one is still alive and reachable
| const char* password |
password for connecting
| const char* username |
username for connecting


We can't wait to hear about your big idea for us, please get in touch.
3 Birrel avenue, Sabo, Yaba, Lagos.hotels.ng
01-2345-6789
<EMAIL_ADDRESS>or connect with us on social media


Schedule every {{serviceType.frequency}} miles
Next service due at {{serviceType.nextServiceDueMileage}} miles


{% extends "source/base.html" %}
{% block slides %}
{% include "source/title.html" %}
{% include "source/why_git/why_git.md" %}
{% include "source/why_git/git_can_do.md" %}
{% include "source/why_git/not_just_for_groups.md" %}
{% include "source/why_git/git_awesome.md" %}
{% include "source/why_github/why_github.md" %}
{% include "source/why_github/github_importance.md" %}
{% include "source/git_basics/title.md" %}
{% include "source/git_basics/git_commit.md" %}
{% include "source/git_basics/git_commit_names.md" %}
{% include "source/git_basics/git_is_distributed.md" %}
{% include "source/git_basics/git_fetch.md" %}
{% include "source/git_basics/git_merge.md" %}
{% include "source/git_tips/title.md" %}
{% include "source/git_tips/gitconfig_basic.md" %}
{% include "source/git_tips/gitconfig_log.md" %}
{% include "source/git_tips/gitconfig_external_cmd.md" %}
{% include "source/git_tips/shell_integration.md" %}
{% include "source/github_tips/title.md" %}
{% include "source/github_tips/workflow_alternatives.md" %}
{% include "source/github_tips/typical_workflow.md" %}
{% include "source/github_tips/references.md" %}
{% include "source/github_tips/gists.md" %}
{% include "source/github_tips/whitespace.md" %}
{% include "source/github_tips/small_branches.md" %}
{% include "source/github_tips/dependent_branches.md" %}
{% include "source/github_tips/more_resources.md" %}
{% include "source/more_topics/more_topics.md" %}
{% endblock %}