Maintenance Tracker App is an application that provides users with the ability to reach out to operations or repairs department regarding repair or maintenance requests and monitor the status of their request.
You can sign up a user by providing a username, email and password.
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"email"<EMAIL_ADDRESS>"password": "123abc",
"confirm_password": "123abc"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Sign Up Successful"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"email"<EMAIL_ADDRESS>"password": "123abc",
"confirm_password": "123abc"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Missing JSON in request"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"email"<EMAIL_ADDRESS>"password": "123abc",
"confirm_password": "123abc"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "All Fields Required"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"email"<EMAIL_ADDRESS>"password": "123abc",
"confirm_password": "123abc"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Input Must be a String"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"email"<EMAIL_ADDRESS>"password": "123abc",
"confirm_password": "123abc"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Your Passwords Don't Match"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"email"<EMAIL_ADDRESS>"password": "123abc",
"confirm_password": "123abc"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "User already exists"
}
You can sign in a registered user with their username and password. Please take note of the auth token for you will need it for all user requests.
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"password": "123abc",
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Sign in Successful!",
"token": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0eXBlIjoiYWNjZXNzIiwiaWF0IjoxNTI4NjM3MzI1LCJleHAiOjE1Mjg2MzgyMjUsIm5iZiI6MTUyODYzNzMyNSwiaWRlbnRpdHkiOjUsImp0aSI6IjY3MzNkZGM5LThhYWYtNDVlOC05NGU4LTJkNDU0YzAwZjkzNSIsImZyZXNoIjpmYWxzZX0.atjGqkdHfRso4HQz5jyIo5tIUeOuDtYFCUftkxWOn54"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"password": "123abc",
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Missing JSON in request"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"password": "123abc",
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Wrong username or password"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"username": "name",
"password": "123abc",
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "User Not Found. Create an Account to Sign In"
}
You can create, view, update and delete requests once logged in. NOTE: You must include the access token in the header else a 401 or 404 response will be returned.
You can view a list of all the requests you made. You cannot view another user’s requests.
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"requests": [
{
"area": "block b",
"category": "fixes",
"description": "big crack",
"id": 2,
"status": "pending",
"title": "cracked wall",
"type": "repair",
"user_id": 1
},
{
"area": "block b",
"category": "fixes",
"description": "big crack",
"id": 1,
"status": "resolved",
"title": "cracked wall",
"type": "repair",
"user_id": 1
},
{
"area": "block f",
"category": "floor/wall",
"description": "deep cracks",
"id": 4,
"status": "pending",
"title": "cracked wall",
"type": "repair",
"user_id": 5
}
]
}
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "You have no requests. Create a request"
}
You can create a new request. The default status is pending.
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"title": "damaged pipe",
"description": "Leaking pipe",
"type": "repair",
"category": "fix",
"area": "block D"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Request Created Successfully",
"requests": [
{
"area": "block d",
"category": "fix",
"description": "leaking pipe",
"id": 3,
"status": "pending",
"title": "damaged pipe",
"type": "repair",
"user_id": 5
}
]
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"title": "damaged pipe",
"description": "Leaking pipe",
"type": "repair",
"category": "fix",
"area": "block D"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Missing JSON in request"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"title": "damaged pipe",
"description": "Leaking pipe",
"type": "repair",
"category": "fix",
"area": "block D"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "All Fields Required"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"title": "damaged pipe",
"description": "Leaking pipe",
"type": "repair",
"category": "fix",
"area": "block D"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Input Must be a String"
}
You get a single request by its specific Id.
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"requests": [
{
"area": "block d",
"category": "fix",
"description": "leaking pipe",
"id": 3,
"status": "pending",
"title": "damaged pipe",
"type": "repair",
"user_id": 5
}
]
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Request Not Found"
}
You can edit details of an existing request. NOTE: You can only edit a request if the status is pending.
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
application/json
{
"category": "plumbing",
"description": "broken tap"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Request Updated Successfully",
"requests": [
{
"area": "block d",
"category": "plumbing",
"description": "broken tap",
"id": 3,
"status": "pending",
"title": "damaged pipe",
"type": "repair",
"user_id": 5
}
]
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
application/json
{
"category": "plumbing",
"description": "broken tap"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Cannot Update, Your Request is Already"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
application/json
{
"category": "plumbing",
"description": "broken tap"
}
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Request Not Found"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Request Deleted Successfully"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Request Not Found"
}
As an admin, you have added capabilities such as approving, disapproving and resolving a request. NOTE: - You must include the access token in the header else a 401 or 404 response will be returned. - You must be registered as an admin
You can view all requests made by users.
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"requests": [
{
"area": "block b",
"category": "fixes",
"description": "big crack",
"id": 2,
"status": "pending",
"title": "cracked wall",
"type": "repair",
"user_id": 1
},
{
"area": "block b",
"category": "fixes",
"description": "big crack",
"id": 1,
"status": "resolved",
"title": "cracked wall",
"type": "repair",
"user_id": 1
},
{
"area": "block f",
"category": "floor/wall",
"description": "deep cracks",
"id": 4,
"status": "pending",
"title": "cracked wall",
"type": "repair",
"user_id": 5
}
]
}
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "No requests to display"
}
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Sorry, Only Admin can Access"
}
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "User Not Found. Sign up to create an account"
}
You can only approve a pending request
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Request Successfully approved"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Failed, The request has been resolved"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Sorry, Only Admin can Access"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "User Not Found. Sign up to create an account"
}
You can only disapprove a pending request
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Request Successfully disapproved"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Failed, The request has been approved"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Sorry, Only Admin can Access"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "User Not Found. Sign up to create an account"
}
You can only resove an approved request
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Request Successfully resolved"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Failed, The request has been disapproved"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "Sorry, Only Admin can Access"
}
| Parameters | |||
|---|---|---|---|
request_id |
number
|
Id of the request to be returned |
| Headers | |
|---|---|
| Content-Type | application/json |
| Authorization | Bearer JWT Token |
| Headers | |
|---|---|
| Content-Type | application/json |
application/json
{
"message": "User Not Found. Sign up to create an account"
}


Class ArucoObjectsTracker
Inheritance
System.Object
UnityEngine.Object
UnityEngine.Component
UnityEngine.Behaviour
UnityEngine.MonoBehaviour
ArucoObjectsTracker
Assembly: Assembly-CSharp.dll
Syntax
public class ArucoObjectsTracker : ArucoObjectsController, IArucoObjectsTracker, IArucoCameraController, IConfigurableController, IArucoObjectsController, IHasDetectorParameter
Fields
|
Improve this Doc
View Source
additionalTrackers
Declaration
protected Dictionary<Type, ArucoObjectTracker> additionalTrackers
Field Value
|
Improve this Doc
View Source
trackingThread
Declaration
protected ArucoCameraSeparateThread trackingThread
Field Value
Properties
|
Improve this Doc
View Source
ArucoCameraDisplay
Declaration
public IArucoCameraDisplay ArucoCameraDisplay { get; set; }
Property Value
|
Improve this Doc
View Source
DrawAxes
Declaration
public bool DrawAxes { get; set; }
Property Value
| Type |
Description |
| System.Boolean |
|
|
Improve this Doc
View Source
DrawDetectedCharucoMarkers
Declaration
public bool DrawDetectedCharucoMarkers { get; set; }
Property Value
| Type |
Description |
| System.Boolean |
|
|
Improve this Doc
View Source
DrawDetectedDiamonds
Declaration
public bool DrawDetectedDiamonds { get; set; }
Property Value
| Type |
Description |
| System.Boolean |
|
|
Improve this Doc
View Source
DrawDetectedMarkers
Declaration
public bool DrawDetectedMarkers { get; set; }
Property Value
| Type |
Description |
| System.Boolean |
|
|
Improve this Doc
View Source
DrawRejectedCandidates
Declaration
public bool DrawRejectedCandidates { get; set; }
Property Value
| Type |
Description |
| System.Boolean |
|
|
Improve this Doc
View Source
MarkerTracker
Declaration
public ArucoMarkerTracker MarkerTracker { get; protected set; }
Property Value
|
Improve this Doc
View Source
RefineDetectedMarkers
Declaration
public bool RefineDetectedMarkers { get; set; }
Property Value
| Type |
Description |
| System.Boolean |
|
Methods
|
Improve this Doc
View Source
ArucoCamera_ImagesUpdated()
Declaration
protected void ArucoCamera_ImagesUpdated()
|
Improve this Doc
View Source
ArucoObjectsController_ArucoObjectAdded(ArucoObject)
Activates the tracker associated with the arucoObject
and configure its gameObject.
Declaration
protected virtual void ArucoObjectsController_ArucoObjectAdded(ArucoObject arucoObject)
Parameters
| Type |
Name |
Description |
| ArucoObject |
arucoObject |
The added ArUco object.
|
|
Improve this Doc
View Source
ArucoObjectsController_ArucoObjectRemoved(ArucoObject)
Deactivates the tracker associated with the arucoObject
if it was the last one of this type.
Declaration
protected virtual void ArucoObjectsController_ArucoObjectRemoved(ArucoObject arucoObject)
Parameters
| Type |
Name |
Description |
| ArucoObject |
arucoObject |
The removed
|
|
Improve this Doc
View Source
Awake()
Declaration
protected override void Awake()
Overrides
|
Improve this Doc
View Source
Configuring()
Declaration
protected override void Configuring()
Overrides
|
Improve this Doc
View Source
DeactivateArucoObjects()
Declaration
public void DeactivateArucoObjects()
|
Improve this Doc
View Source
Detect()
Declaration
|
Improve this Doc
View Source
Detect(Cv.Mat[])
Declaration
public void Detect(Cv.Mat[] images)
Parameters
| Type |
Name |
Description |
| Cv.Mat[] |
images |
|
|
Improve this Doc
View Source
Draw()
Declaration
|
Improve this Doc
View Source
Draw(Cv.Mat[])
Declaration
public void Draw(Cv.Mat[] images)
Parameters
| Type |
Name |
Description |
| Cv.Mat[] |
images |
|
|
Improve this Doc
View Source
Declaration
public void EstimateTransforms()
|
Improve this Doc
View Source
ExecuteOnActivatedTrackers(Action<ArucoObjectTracker, Int32, Aruco.Dictionary>)
Declaration
protected void ExecuteOnActivatedTrackers(Action<ArucoObjectTracker, int, Aruco.Dictionary> actionOnTracker)
Parameters
|
Improve this Doc
View Source
Starting()
Initializes the tracking, activates the trackers, susbcribes to the and
events and starts the tracking thread.
Declaration
protected override void Starting()
Overrides
|
Improve this Doc
View Source
Stopping()
Unsuscribes from ArucoObjectController events, deactivates the trackers and abort the tracking thread and stops the tracking thread.
Declaration
protected override void Stopping()
Overrides
|
Improve this Doc
View Source
TrackArucoObjects(Cv.Mat[])
Detects and estimates the transforms of the detected ArUco objects. Executed on a separated tracking thread.
Declaration
protected void TrackArucoObjects(Cv.Mat[] images)
Parameters
| Type |
Name |
Description |
| Cv.Mat[] |
images |
|
|
Improve this Doc
View Source
Declaration
public void UpdateTransforms()
Implements


--- layout: post title: The SysAdmin's Creed date: 2010-03-30 15:23:00.000000000 -07:00 type: post published: true status: publish categories: [] tags: [] meta: _publicize_pending: '1' author: login: phoneboy email<EMAIL_ADDRESS>display_name: Dameon Welch first_name: '' last_name: '' ---
A poem that needs no explanation to those who understand it.
This is my network. There are many like it, but this one is mine. My network is my best friend.   My network, without me, is useless. Without my network, I am useless. I must send my packets true. I must block packets faster than my enemy who is trying to pwn me. I must pwn him before he pwns me. I will....
My network is human, even as I, because it is my life. Thus, I will learn it as a brother. I will learn its weakness, its strength, its clients, its servers, its switches, its routers and firewalls. I will keep my network clean and ready, even as I am clean and ready. We will become part of each other. We will...
Before God I swear this creed. My network and myself are the defenders of the world. We are the masters of our enemy. We are the saviors of our data. So be it, until there is no enemy, but Peace.
Amen.


Instructions for Restrict Quantity: 1) Copy the code example into a new web page e.g. mals.html 2) Download and save the mals-scripts.js file into the same folder (note: can be in another) 3) Change the product information in the form to your product using productpr TIP! - Include the product name in both value and text of option to make it clear to customer in cart too - For more information about productpr see https://www.mals-e.com/tpv.php?tp=2 4) Add the quantity options in the productpr select add an attribute mals-qty. For example mals-qty="1..3,4..6,7+" .. = to i.e. 1 to 3 items, 4 to 6 items i) You can add as many options as you want separated by a comma. ii) For the last option use + symbol e.g. 7+ = seven and more items 5) Ensure your wwX and userid are the same as Mals (TIP! enter your details at the top before copying example) 6) Open the web page in a browser e.g. Chrome and test it --- Calling Script --- The script is very versatile. You can activate it on one or more forms (or links) easily. Note: if you don't know jQuery selectors visit https://www.w3schools.com/jquery/jquery_selectors.asp - Example 1 = specific form by id MalsScripts.restrictQty('#form1'); This will activate the script on the form with id="form1" - Example 2 = not enough quantity callback function MalsScripts.restrictQty('#form1',function(){ // Called when not enough qty }); - Example 3 = callback function when form submitted MalsScripts.restrictQty('#form1',function(){ // Called when form submitted }); --- General Notes --- - Add class .mals-ignore to any forms you don't want transformed e.g.


Paito
Message
View All
Compose
John Doe
March 21, 2018
It is a long established fact that a reader...
John Doe
March 21, 2018
It is a long established fact that a reader...
John Doe
March 21, 2018
It is a long established fact that a reader...
John Doe
March 21, 2018
It is a long established fact that a reader...
John Doe
March 21, 2018
It is a long established fact that a reader...
You have 10 notifications
5 new members joined today
Very long description here that may not fit into the page and may cause design problems
5 new members joined
25 sales made
You changed your username
View all
Action
Another action
Something else
John Doe
Profile
Setting
Help
Logout
Main
首页面板
Trading
Marketcap
ICO
Buy and Sell Crypto
My Wallet
Currency Exchange
Extra Main Page
UI Elements
Grids
Buttons
Tables
Tabs
Forms
Tabs
Charts
Pagination
Register
Login
Recover Password
Reset Password
Error
FAQ
{block name="content"}{/block}


Current
Watch
Clear
latitude:
longitude:
altitude:
accuracy:
altitudeAccuracy:
heading:
speed:
timestamp:


Category:Reference Manual
reference
Type expressions relate to type declarations much like function calls
relate to function and value definitions. Type declarations define ways
of constructing types and type expressions define actual types.
Types are both static and dynamic characterization of values. The static
type of expression depends on its building blocks and is defined in the
paragraph describing given expression. The dynamic (runtime) type is
bound to the value at the moment it is created, and remains there until
the value is garbage collected.
The type system is modeled after .NET Generics design, except for tuple
and function types, which are new, but can be easily simulated using
generics.
primary_type =
Expressions_(ref):qualified_identifier [ '[' type { ',' type } ']' ]
A type constructor (defined with type declaration) can be applied to
zero or more arguments forming a type expression. The number of type
arguments in type application must match the number of type arguments in
definition. Moreover, actual type arguments must solve where constraints
imposed on formal type arguments.
primary_type =
Lexical_structure_(ref):IDENTIFIER
Refer to the type substituted to a given type variable. The type variable
has to be defined (bound, quantified) before it is used. A type variable
can be defined in type arguments or method header (of a global or local
function).
primary_type =
'(' type ')'
This construct has no semantic meaning -- it exists only to enforce
particular syntax decomposition.
This is mostly an alias for System.Void
-- a type with exactly one
inhibiting value. It is, however, a first class value -- it can be passed
as a function parameter as well as returned from functions.
The name comes from System.Void
, but should be in fact unit.
primary_type =
'ref' primary_type
| 'out' primary_type
These are for parameters passed by reference.
primary_type =
'array' '[' [ Lexical_structure_(ref):NUMBER_LITERAL ',' ] type ']'
Define array type. The number is the rank. It defaults to one.
type =
primary_type '*' primary_type { '*' primary_type }
Construct product (tuple) type. This operator is not associative, which
means that each two of following types are different:
int * int * int
(int * int) * int
int * (int * int)
Construct function type with a specified argument and return types
respectively. The ->
operator is right associative, which means that
the following types are equivalent:
int -> int -> int
int -> (int -> int)
Multi-argument function types are written using tuple notation, for
example after local declaration:
def some_function (a : int, b : string) : float { ... }
the expression some_function
has type int * string -> float
.


所有类
AudioParams
AudioRecordDevice
CameraParams
CountPeopleTimer
LetvPublisher
LetvPublisher.Request
Log
RecorderSkin
VideoRecordDevice


flibs/binarytree - Linked lists
The binarytree.f90 source file allows you to implement binary trees of any (derived) type without having to edit the supplied source code. (The resulting binary tree is not balanced, that would require a method of ordering the data.) To achieve genericty, a simple technique is used, which is best illustrated by an example:
module MYDATA_MODULE type MYDATA character(len=20) :: string end type MYDATA end module module MYDATA_BTREES use MYDATA_MODULE, TREE_DATA => MYDATA include "binarytree.f90" end module MYDATA_BTREES
The above code defines a module MYDATA_MODULE with the derived type that is to be stored in the binary trees. The name of that derived type can be anything.
It also defines a module MYDATA_BTREES which will be the module that holds the functionality to use binary trees:
The module MYDATA_MODULE is used, but the derived type MYDATA is renamed to the (fixed) name LIST_DATA. (This is the name used in the generic source file.)
The source code for the actual routines is simply included via the INCLUDE statement.
Nothing more is required, we can close the source text for the module.
To use a single type of binary trees in a program, we can just use the MYDATA_BTREES module. If you need more than one type of data in binary trees, then apply the same renaming trick on using the specific binary trees modules.
In fact the example in the source file "two_lists.f90" shows the general technique of how to accomplish this for linked lists. The same applies to binary trees.
The source file binarytree.f90 provides the following routines:
Create a new tree with the given data associated to the root. The data are copied and stored in that root.
The variable that will be used for accessing the tree's root
The data to be stored in the root
Destroy the tree. All nodes contained in it will be destroyed as well.
The list to be destroyed
Function to return the number of nodes in the tree.
The tree in question
Function to return the left or right child node of a given node in the tree. As each node is itself a tree, you can traverse the tree by repeatedly using this function on the result.
Note: it returns a pointer to the child node, so you must use =>.
The (parent) node in a tree or the root of a tree
Whether to return the right (.true.) or the left (.false.) child node.
Append a new node to the left or right to the given node. (Note that no balancing is taken care of). If the node already has a child node, nothing is done.
The node in the tree that should get a child node
The data to be stored in the child node
Whether to append on the right (.true.) or the left (.false.) side.
Append a subtree to the left or right to the given node. If the node already has a child node, nothing is done. (Note: the subtree is referred to, not copied!)
The node in the tree that should get a child node
The tree to be appended as the child node
Whether to append on the right (.true.) or the left (.false.) side.
Remove a subtree to the left or right to the given node. A pointer to the subtree is returned in the "subtree" argument, so that this can be destroyed or used independently of the original tree.
The element in the list after which to insert a new one.
The subtree that was removeds the child node
Whether to remove on the right (.true.) or the left (.false.) side.
Return the data belonging to a node
The node of the tree in question
Put new data at a given node
The node of the tree in question
The data to be stored in the node
Notes:
The binary trees can only store data of the same derived type. In that sense the code is not generic.
Currently, the trees can only store derived types that do not require an explicit destruction. If you want to store a derived type with pointers to allocated memory, you can do that however, by supplying an assignment operator. This would lead to a memory leak though. It is best to wait for a next version that will allow such derived types to be stored.
Copyright © 2005 Arjen Markus <arjenmarkus@sourceforge.net>


2.6
domestic | fire | spread to neighbouring buildings | 2010
Every
building
must be designed and
constructed
in such a way that
in the event of an outbreak of fire within the
building
, the spread of
fire to neighbouring
buildings
is inhibited.
2.6.0 Introduction
In order to reduce the danger to the occupants of other
buildings
, one
building
should be isolated from another by either
construction
or distance.
amount of heat that is likely to be generated in the event of fire. This will be
influenced by the extent of openings, or other unprotected areas in the
external wall
of the
building
.
The guidance for fire spread to neighbouring
buildings
should not be
assessed in isolation and reference should be made to the guidance to
standard 2.4 for fire spread in cavities and the guidance to standard 2.7 for
fire spread on
external walls
.
In the case of
conversions
, as specified in regulation 4, the
building
as
converted
shall meet the requirements of this standard in so far as is
reasonably practicable
, and in no case be worse than before the
conversion
(regulation 12, schedule 6).
2.6
—
2.6.0
domestic | fire | spread to neighbouring buildings | 2010
2.6.1 Fire resistance of
external walls
Apart from unprotected areas, as described in clause 2.6.2,
external walls
should have:
•
short fire resistance duration, if more than 1 m from the
boundary
; or
•
medium fire resistance duration, if not more than 1 m from the
boundary
.
However short fire resistance duration is sufficient even if not more than 1 m
from the
boundary
, for the following:
•
•
a
conservatory
or
porch
attached to a
dwelling
; or
•
a garage wall.
Fire resistance duration need not be provided for a
building
ancillary to a
dwelling
, comprising a
carport
,
covered area
,
greenhouse
, summerhouse, or
swimming pool enclosure unless the
building
contains oil or liquefied
petroleum gas fuel storage (see section 3 and section 4).
2.6.2 Unprotected area
An unprotected area means any part of an
external wall
(including a door or
window opening), which does not attain the appropriate fire resistance
duration as recommended in clause 2.6.1.
An unprotected area does not include a fixed unopenable window where the
frame and
glazing
has the appropriate fire resistance duration. Any wallhead
fascia, soffit or barge board, or any cavity vents or solum vents may also be
excluded from the unprotected area calculation.
Up to 500 mm from
Where the
external wall
of a
building
is not more than 500 mm from the
boundary
there should be no unprotected area, other than any wallhead
fascia, soffit or barge board, or any cavity vents or solum vents.
500 mm to 1 m from
Where the
external wall
of a
building
is more than 500 mm but not more than
1 m from the
boundary
, the level of unprotected area is limited to:
a. the
external wall
of a
protected zone
;
b. an area of not more than 0.1 m
2
, which are at least 1.5 m from any other
unprotected area in the same wall;
c. an area of not more than 1 m
2
, which are at least 4 m from any other
unprotected area in the same wall (this 1 m
2
unprotected area may consist
of 2 or more smaller areas which when combined do not exceed an
aggregate area of 1 m
2
).
More than 1 m from
Where the
external wall
of a
building
is more than 1 m from the
boundary
the
amount of unprotected area (in square metres) may be equivalent to six
times the distance (in metres) to the
boundary
. Therefore if the distance to
and so on.
Where the
external wall
of a
building
is more than 6 m from the
boundary
, the
amount of unprotected area is unlimited.
The use of the simple geometry method described above is limited to
2.6.1
—
2.6.3
domestic | fire | spread to neighbouring buildings | 2010
more than 24 m. Any external side of a
building
which makes an angle of
more than 80
0
with the plane of reference can be ignored in the calculation of
unprotected area. The diagram below provides a typical example of a
conservatory
attached to a
house
.
Where a
domestic building
exceeds these limits, reference could be made to
the Enclosing Rectangle Method (Table B) contained in the non-domestic
guidance document or the Building Research Establishment Report ‘External
these cases, for the purpose of calculating the enclosing rectangle, a
separating wall
or
separating floor
should be regarded as a
compartment wall
or
compartment floor
.
2.6.4
External wall
cladding
External wall
cladding includes all non load-bearing
external wall
cladding
systems attached to the structure, for example, clay or concrete tiles, slates,
pre-cast concrete panels, stone panels, masonry, profiled metal sheeting
including sandwich panels, weather boarding, thermally insulated
external
systems.
External wall
cladding not more than 1 m from a
boundary
should have a
non-combustible
classification.
Fire within the
building
may break out through a window or door opening and
as a consequence, the cladding, once ignited, would contribute to the heat
generated from the fire. Therefore where the cladding is more than 1 m from
the
boundary
and is
constructed
from combustible material more than 1 mm
thick that has a low, medium, high or very high risk, (as described in annex
2.B), the cladding should be included in the calculation of unprotected area.
However combustible cladding need not be included in the calculation of
unprotected area where:
•
the combustible cladding is attached to the structure of the
building
and
the
external wall
contains no openings other than the small openings
described in clause 2.6.2b; and
•
the wall behind the cladding (or the cladding itself) has the appropriate fire
resistance duration from the inside.
2.6.3
—
2.6.4
domestic | fire | spread to neighbouring buildings | 2010
In addition, a cavity formed by
external wall
cladding should be protected in
accordance with the guidance to standard 2.4 and fire spread on
external
walls
in accordance with the guidance to standard 2.7.
2.6.5 Combustibility
Every part of an
external wall
including
external wall
cladding (see clause
2.6.4) not more than 1 m from a
boundary
or the
external wall
of a
high rise
domestic building
, should be
constructed
of
non-combustible
products. This
does not apply to insulation exposed in a cavity that is between 2 leaves of
masonry or concrete at least 75 mm thick, and which has a
cavity barrier
around all openings in the wall and at the top of the wall-head.
However a structural frame which is low, medium, high or very high risk (see
annex 2.B) may be used not more than 1 m from a
boundary
provided:
•
no
storey
height is more than 18 m; and
•
the recommendations in clauses 2.6.1 and 2.6.2 have been followed; and
•
any
external wall
cladding is
constructed
from
non-combustible
products.
See the guidance to standard 2.7 for additional recommendations on
external
wall
cladding and the alternative to the need for
non-combustibility
mentioned
above.
2.6.6 Supporting structure
Where an
element of structure
provides support to an
external wall
(including
external wall
cladding) which has a fire resistance duration (as recommended
in the guidance to clauses 2.6.1 and 2.6.2) the supporting
element of
structure
should also have at least the same fire resistance duration.
2.6.4
—
2.6.6


CLICK ME!!
pics of places i have been to or want to visit.
Waimanalo beach
Kaneohe bay
Sandy beach park
Shibuya at night
Tokyo art
Thailand islands
Great wall of china
Singapore view of Marina Sands casino/resort
Viva Las Vegas!
Seattle my new home 😃


It saddens me to report that weedy poet Dennis Beerpint has been caught red-handed in an act of plagiarism. His verse “The Fountainhead : Homage à Ayn Rand” from his well-received recent collection A Series Of Homages To Female Right-Wing Russo-American Postage Stamp Collectors was, it seems, lifted word for word from this paragraph in Compound Words : A Study Of The Principles Of Compounding, The Components Of Compounds, And The Use Of The Hyphen by Frederick W. Hamilton, LL. D., published in 1918 by the Committee on Education of the United Typothetae Of America:
“41. Following is a list of words of everyday occurrence which should be hyphenated, and which do not fall under any of the above classifications.
after-years food-stuff sea-level
bas-relief guinea-pig sense-perception
birth-rate horse-power son-in-law
blood-relations loan-word subject-matter
common-sense man-of-war thought-process
cross-examine object-lesson title-page
cross-reference page-proof wave-length
cross-section pay-roll well-being
death-rate poor-law well-nigh
folk-song post-office will-power
fountain-head
These rules are the consensus of opinion of a considerable number of good authorities from DeVinne (1901) to Manly and Powell (1913).”
The only change Dennis Beerpint makes is to add an exclamation mark after “fountain-head”, presumably to remind himself to shout the word, triumphantly, at recitals.


Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.
The system is browser based so can be accessed from any device with an internet connection. the data entered by the teachers like attendance, homework assignment, the comments attributed to the students are presented to the parents in a daily report.
Request a demo account 🠒
100% web-based. Apps for students, parents and teachers. Zoom & Google Classroom integration. Education & administration at a glance
The system is browser based so can be accessed from any device with an internet connection. the data entered by the teachers like attendance, homework assignment, the comments attributed to the students are presented to the parents in a daily report.
The system is browser based so can be accessed from any device with an internet connection. the data entered by the teachers like attendance, homework assignment, the comments attributed to the students are presented to the parents in a daily report.


Lesson 6: CronTrigger
CronTrigger is often more useful than SimpleTrigger, if you need a job-firing schedule that recurs based on calendar-like notions, rather than on the exactly specified intervals of SimpleTrigger.
With CronTrigger, you can specify firing-schedules such as “every Friday at noon”, or “every weekday and 9:30 am”, or even “every 5 minutes between 9:00 am and 10:00 am on every Monday, Wednesday and Friday during January”.
Even so, like SimpleTrigger, CronTrigger has a startTime which specifies when the schedule is in force, and an (optional) endTime that specifies when the schedule should be discontinued.
Cron Expressions
Cron-Expressions are used to configure instances of CronTrigger. Cron-Expressions are strings that are actually made up of seven sub-expressions, that describe individual details of the schedule. These sub-expression are separated with white-space, and represent:
- Seconds
- Minutes
- Hours
- Day-of-Month
- Month
- Day-of-Week
- Year (optional field)
An example of a complete cron-expression is the string “0 0 12 ? * WED” - which means “every Wednesday at 12:00:00 pm”.
Individual sub-expressions can contain ranges and/or lists. For example, the day of week field in the previous (which reads “WED”) example could be replaced with “MON-FRI”, “MON,WED,FRI”, or even “MON-WED,SAT”.
Wild-cards (the ‘’ character) can be used to say “every” possible value of this field. Therefore the ‘’ character in the “Month” field of the previous example simply means “every month”. A ‘*’ in the Day-Of-Week field would therefore obviously mean “every day of the week”.
All of the fields have a set of valid values that can be specified. These values should be fairly obvious - such as the numbers 0 to 59 for seconds and minutes, and the values 0 to 23 for hours. Day-of-Month can be any value 1-31, but you need to be careful about how many days are in a given month! Months can be specified as values between 0 and 11, or by using the strings JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV and DEC. Days-of-Week can be specified as values between 1 and 7 (1 = Sunday) or by using the strings SUN, MON, TUE, WED, THU, FRI and SAT.
The ‘/’ character can be used to specify increments to values. For example, if you put ‘0/15’ in the Minutes field, it means ‘every 15th minute of the hour, starting at minute zero’. If you used ‘3/20’ in the Minutes field, it would mean ‘every 20th minute of the hour, starting at minute three’ - or in other words it is the same as specifying ‘3,23,43’ in the Minutes field. Note the subtlety that “/35” does *not mean “every 35 minutes” - it mean “every 35th minute of the hour, starting at minute zero” - or in other words the same as specifying ‘0,35’.
The ‘?’ character is allowed for the day-of-month and day-of-week fields. It is used to specify “no specific value”. This is useful when you need to specify something in one of the two fields, but not the other. See the examples below (and CronTrigger JavaDoc) for clarification.
The ‘L’ character is allowed for the day-of-month and day-of-week fields. This character is short-hand for “last”, but it has different meaning in each of the two fields. For example, the value “L” in the day-of-month field means “the last day of the month” - day 31 for January, day 28 for February on non-leap years. If used in the day-of-week field by itself, it simply means “7” or “SAT”. But if used in the day-of-week field after another value, it means “the last xxx day of the month” - for example “6L” or “FRIL” both mean “the last friday of the month”. You can also specify an offset from the last day of the month, such as “L-3” which would mean the third-to-last day of the calendar month. When using the ‘L’ option, it is important not to specify lists, or ranges of values, as you’ll get confusing/unexpected results.
The ‘W’ is used to specify the weekday (Monday-Friday) nearest the given day. As an example, if you were to specify “15W” as the value for the day-of-month field, the meaning is: “the nearest weekday to the 15th of the month”.
The ‘#’ is used to specify “the nth” XXX weekday of the month. For example, the value of “6#3” or “FRI#3” in the day-of-week field means “the third Friday of the month”.
Here are a few more examples of expressions and their meanings - you can find even more in the JavaDoc for org.quartz.CronExpression
Example Cron Expressions
CronTrigger Example 1 - an expression to create a trigger that simply fires every 5 minutes
“0 0/5 * * * ?”
CronTrigger Example 2 - an expression to create a trigger that fires every 5 minutes, at 10 seconds after the minute (i.e. 10:00:10 am, 10:05:10 am, etc.).
“10 0/5 * * * ?”
CronTrigger Example 3 - an expression to create a trigger that fires at 10:30, 11:30, 12:30, and 13:30, on every Wednesday and Friday.
“0 30 10-13 ? * WED,FRI”
CronTrigger Example 4 - an expression to create a trigger that fires every half hour between the hours of 8 am and 10 am on the 5th and 20th of every month. Note that the trigger will NOT fire at 10:00 am, just at 8:00, 8:30, 9:00 and 9:30
“0 0/30 8-9 5,20 * ?”
Note that some scheduling requirements are too complicated to express with a single trigger - such as “every 5 minutes between 9:00 am and 10:00 am, and every 20 minutes between 1:00 pm and 10:00 pm”. The solution in this scenario is to simply create two triggers, and register both of them to run the same job.
Building CronTriggers
CronTrigger instances are built using TriggerBuilder (for the trigger’s main properties) and CronScheduleBuilder (for the CronTrigger-specific properties). To use these builders in a DSL-style, use static imports:
import static org.quartz.TriggerBuilder.*;
import static org.quartz.CronScheduleBuilder.*;
import static org.quartz.DateBuilder.*;
Build a trigger that will fire every other minute, between 8am and 5pm, every day:
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0 0/2 8-17 * * ?"))
.forJob("myJob", "group1")
.build();
Build a trigger that will fire daily at 10:42 am:
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(dailyAtHourAndMinute(10, 42))
.forJob(myJobKey)
.build();
or -
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0 42 10 * * ?"))
.forJob(myJobKey)
.build();
Build a trigger that will fire on Wednesdays at 10:42 am, in a TimeZone other than the system’s default:
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(weeklyOnDayAndHourAndMinute(DateBuilder.WEDNESDAY, 10, 42))
.forJob(myJobKey)
.inTimeZone(TimeZone.getTimeZone("America/Los_Angeles"))
.build();
or -
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0 42 10 ? * WED"))
.inTimeZone(TimeZone.getTimeZone("America/Los_Angeles"))
.forJob(myJobKey)
.build();
CronTrigger Misfire Instructions
The following instructions can be used to inform Quartz what it should do when a misfire occurs for CronTrigger. (Misfire situations were introduced in the More About Triggers section of this tutorial). These instructions are defined as constants on CronTrigger itself (including JavaDoc describing their behavior). The instructions include:
Misfire Instruction Constants of CronTrigger
MISFIRE_INSTRUCTION_IGNORE_MISFIRE_POLICY
MISFIRE_INSTRUCTION_DO_NOTHING
MISFIRE_INSTRUCTION_FIRE_NOW
All triggers also have the Trigger.MISFIRE_INSTRUCTION_SMART_POLICY instruction available for use, and this instruction is also the default for all trigger types. The ‘smart policy’ instruction is interpreted by CronTrigger as MISFIRE_INSTRUCTION_FIRE_NOW. The JavaDoc for the CronTrigger.updateAfterMisfire() method explains the exact details of this behavior.
When building CronTriggers, you specify the misfire instruction as part of the simple schedule (via CronSchedulerBuilder):
trigger = newTrigger()
.withIdentity("trigger3", "group1")
.withSchedule(cronSchedule("0 0/2 8-17 * * ?")
..withMisfireHandlingInstructionFireAndProceed())
.forJob("myJob", "group1")
.build();


INTRO
As you may know, Erlang has its own binary encoding BERT inside its virtual machine, called BEAM. For enterprise RPC usually, you use protobuf or MessagePack or Thrift or ASN.1 binary parser generators. However, as you may know Erlang is not so fast in any tasks except moving binaries between sockets. So we at Synrc usually use native Erlang BERT encoding on all clients with zero encoding/decoding on server side.
The encoders/decoders could be of two types: strict (with checking the model for particular type signature with Sums and Products) and general which encode/decode anything that can be translated into correct encoding. For example, JavaScript encoder/decode generator presented in this repo is just like that (it doesn’t check types and constants, given in Erlang HRL files). However, Swift version has the ability to check encoded/decoded term to comply the Erlang Type Specification.
Samples
First, you can choose the language which is not presented in this repo and try to implement your own BERT enc/dec generator for this language using Swift (Type Spec precise) and JavaScript (open relay) generator as examples.
The aim of this contest is to create encoders/decoders for each language and make bridges to other protocol descriptive formats like Can’n’Proto or protobuf!
Erlang HRL
Swift Model
Swift Spec
JavaScript
Protobuf Sample
Erlang BERT/HRL (source):
Proto V3 (target):
Run
Credits
- Yuri Maslovsky — ERLANG
- Maxim Sokhatsky — GOOGLE, JAVASCRIPT
- Dmytro Boiko — ERLANG, JAVASCRIPT
- Anton Makarov — SWIFT
- Viacheslav Katsuba — JAVASCRIPT


USFM Grammar
USFM
${usfm_val}
${selectedTab}
${selectedScripture}
${selectedType}
All
Scripture
Normal
Relaxed
JSON
USFM
Please wait...
JSON
${usfm_val}
CSV
${usfm_val}
TSV
${json_val}
${csv_val}
${tsv_val}
ERROR
${lhs_error}
ERROR
${rhs_error}


{% extends 'bootstrap/base.html' %} {% block title %} {% if title %}{{ title }} - EDI Dashboard{% endif %} {% endblock %} {% block navbar %} Toggle navigation EDI Dashboard About Health Health at a glance Reports No Public Access (admin) Offline Data (admin) DOI Report (admin) Package Tracker Recent Uploads (1 day) Recent Uploads (7 days) Recent Uploads (30 days) Upload Report Site Report PASTA+ Reservations Working On Embargo Management (admin) User Management Create User (admin) Delete User (admin) List Users (admin) Update User Change Password Reset Password EDI Portals Production Staging Development {% if current_user.is_anonymous %} Login {% else %} Logout {% endif %} {% if current_user.is_authenticated %} Active user: {{ current_user.get_username() }} {% endif %} {% endblock %} {% block content %}


abhishekkr
code
not(code)
blog
about
opensource projects
gmail-helper
(python cli)
: helpful GMail tasks over OAuth2 like delete mails by filter
weeproxy
(go svc)
: minimalist http proxy based on url path with graceful stop
dory
(go svc)
: secret sharing service with auto-expiry/persistent data; no accounts needed
webaudio-samples
(w3c)
: Web Audio examples drum kit, do-re-mi and guitar tabs
http200
(go svc)
: use as placeholder service with dynamic routes addition
ficklepickle
(go lib)
: struct pickling library with compression and encryption
goshare
(go lib)
: a TimeSeries/NameSpace/KeyVal DataStore (using leveldb) over HTTP &/or ZeroMQ
raguel
(bash dsl)
: It's here to be the friend of Bourne Shell Gods to create minion scripts to serve the SYSTEMS.
n00bRAT
(C svc)
: a Remote Admin Toolkit (or Trojan) for POSiX (Linux) system working as HTTP Service
rss-motor
(rubygem)
: an RSS Motor for your application to get rolling on using RSS Feeds
irc-qik-bot
(rubygem)
: its a babbling IRC Bot very quick to setup and act ;) aiming to be intelligent
yaga
(flutter)
: yet another gaming app, currently just tic-tac-toe
playlist
(w3c)
:
play maah list
an attempt at static site with searchable playlist
tyson
(go cli)
: to hammer-in data load at HTTP, Redis
...these and more projects at github
snippets
dotfiles
collection of shell functions for cli shortcuts
drop-a-bomb
using Web Audio to mimic a bomb drop sound
node-version
to manage Nodejs distribution using binary distribution
go-version
to manage Golang distribution using binary distribution
md2html.sh
to convert Markdown to HTML online
editor bookmarklet
code to have text editor from Bookmarklet
raguel example
of using DSL for Bash Scripting
ddl-rss-media
shell function to download RSS media given URL
...all gists at github
tutorials
tech notes in a repo
Programming Languages and Runtimes
Virtualization (Containers & Cloud)
Configuration Management
W3C
DataCenters
Data Engines
Data Stores
Data Visualization
Frameworks
How "It" Works
Editors
Machine Learning
Metric
Network
Operating System
Reference
SCM
Secure
slides
TimeSeries Database (2015)


Pune
Mumbai
Singapore
Pune
Pune is a city in Maharashtra
Mumbai
Mumbai is a city in Maharashtra
Singapore
Singapore is a country in Asia


The basic technology that underpins XMF-Mosaic is a programming language called XOCL. The programming language is very similar to standard object-oriented languages such as Java or C#. In addition, XOCL is a meta-programming language meaning that it provides facilities for inspecting and controlling its own behaviour. This is the key to supporting flexible tool development. Tools defined in XOCL can inspect and interpret other tools defined in XOCL. Tools defined in XOCL can generate other tools defined in XOCL, and can generate tools defined in other languages such as Java.
This document is a technical description of XOCL. It defines all aspects of the language and provides a complete definition of the programming constructs and what they do. This document is not a description of how to use XOCL. For that you should read the example Walkthroughs in the Bluebook.
The document is structured as follows: the basic architecture of XOCL is describes in terms of what it does and how programs are represented at the lowest level; the basic data types provided by XOCL are defined; XOCL program structure is defined including conditional constructs, binding constructs, errors and looping. Finally, the interface of each basic data type is defined.
XOCL is a programming language that is intended to support powerful programming over meta-data. In achieving this aim, the following objectives have been addressed:
Efficiency. XOCL provides a programming language that is used on primarily data intensive applications (as opposed to real-time applications, safety critical applications or applications that require intensive numeric processing). XOCL will process large data sets (several tens of thousands of objects) using average memory and average processor resources.
Extensibility. XOCL is designed to be highly extensible. New language features can be added to XOCL by defining an XBNF grammar for the new feature and the rule to process the new syntax structures. In many cases, new syntax structures can be translated to basic XOCL; this provides a powerful macro-facility for defining declarative language constructs.
Dynamic. XOCL is designed to be highly configurable and easy to modify at run-time. Although XOCL is a compiled language, new definitions can be introduced at any time during execution and existing definitions can be modified at run-time.
Meta-circularity. XOCL is designed to allow existing language features to be extended and modified. XOCL understands its own rules of execution. New tools can introduce modification to these rules. XOCL can process its own syntax; the XOCL compiler and interpreter is written in XOCL.
Standards. XMF-Mosaic aims to make standards available wherever these are appropriate. The environment provides a MOF-like meta-modelling language and a UML-like modeling language. The XML facilities of XMF can be used to import and export XMI encoded data. The language XOCL is based on the UML Object Constraint Language.
Conventional. XOCL aims to provide a language that is as familiar to users as possible whilst achieving the aim of being a powerful basis for tool generation. The basic language features of XOCL will be familiar to users of standard object-oriented programming languages such as Java.
Complete. XOCL provides a complete solution to tool construction. XOCL is not a scripting language (i.e. a lightweight language used as glue for programs written in other languages). XOCL provides features that support the implementation of industrial strength tools, including sophisticated data structures, error handling and a variety of input/output mechanisms.
XOCL programs consist of a collection of units (text files). Each unit can be compiled and loaded separately; however, there are restrictions on the order of compilation and loading multiple units that must be followed; these are explained in this section. A unit is processed by loading and then evaluating it. Loading involves syntax analysis.
A unit has entries in the following order:
Parser declarations. A parser declaration is processed by the syntax analysis phase. Typically a declaration imports a collection of grammars that define new language constructs. Each language construct in the rest of the unit must be declared before it is used. Basic XOCL is imported by default.
NameSpace imports. Global variables must be imported before they can be used. Each global variable is defined in a name space. Importing the name space makes all the names it defines available in the rest of the unit. The names in Root and XCore are imported by default.
Commands and definitions. The rest of the unit is a sequence of any valid XOCL syntax as defined in terms of the parser declarations and imports that precede it. Definitions take the form of the keyword context followed by a name and then an expression whose value is a named element. The name must reference a name space. The effect of a definition is to add the named element to the named name space. Commands take the form of XOCL syntax followed by a semi-colon (;).
A typical unit has the form shown on the right. All components are optional but, if present, must occur in the order shown.
// Comments at the head of the file…. parserImport <PATH>; // More parser imports… // Comments here…. import <PATH>; // More imports…. // Comments here…. context <PATH> <NAMEDELEMENT> // More defs…. <COMMAND> // More commands….
When a unit is loaded, its syntax is analysed with respect to the parser declarations. If the syntax is legal then the unit is evaluated. Evaluation processes each name space import in turn. Each import is performed in the context of all preceding imports. If the imports are successful then the rest of the unit is evaluated in the context of the imported names. Definitions are evaluated by constructing the named element, referencing the name space and adding the named element to the name space. Commands are evaluated; any result produced by the commands is discarded.
The effect of evaluating a unit is the result of adding all definitions to their name spaces and any side-effects produced by the commands.
Note that although the basic unit of execution is the text file, XOCL is a meta-language and can be used to process definitions and expressions at run-time. This makes XOCL ideal for handling expressions typed at a command interpreter and definitions typed in forms as part of a user interface.
XOCL is a textual language. When a unit is loaded its syntax is processed prior to evaluation. The first stage of syntax analysis if to recognize lexical tokens. A lexical token is a sequence of characters read from the input starting with a non-whitespace character. This section provides an overview of the token types:
Integer tokens start with a numeric character and continue up to, but not including, the first non-numeric character.
Parentheses ( and ).
Braces { and }.
Dot .
At @.
Comma ,.
Special tokens are those that do not consist of an alpha-numeric character and are not listed elsewhere. Examples of special tokens are infix operators such as * and +, arrow -> and quasi-quotes [| and |].
Name tokens start with an alpha-character and continue up to, but not including, the first non-alpha-numeric character.
Symbol tokens start with a ‘ and end with the following ‘.
String tokens start with a “ and end with the following “. Within strings the following escape characters are useful:
Newline \n
Tab \t
Return \r
String quote \”


--- layout: article title: "Announcing Lunch Bug!" author: matt tags: [lunchbug] ---
Today Geoff and I are very excited to announce our first major game in almost 2 years, Lunch Bug, a free-to-play, strategy puzzle game built using HTML5.
Lunch Bug is available to play now on Pokki, the Chrome Web Store, and the open web. It even works in mobile browsers like Mobile Safari and the Android browser! For more information, please see the landing page and media kit.
As always, we're dying to know what you think! Please play the game and tell us your thoughts on Twitter, Facebook, or via email. Thanks!


Before Change
// this data_layer is at the last batch with few more elements, cutting
if total_samples[worker_id] > dl_sizes[worker_id]:
last_batch_size = dl_sizes[worker_id] % batch_size
inputs["source_tensors"] = model.clip_last_batch(
inputs["source_tensors"], last_batch_size,
)
if "target_tensors" in inputs:
inputs["target_tensors"] = model.clip_last_batch(
inputs["target_tensors"], last_batch_size,
)
outputs = model.clip_last_batch(outputs, last_batch_size)
if compute_loss:
total_loss += loss * batch_size
After Change
// this data_layer is at the last batch with few more elements, cutting
if total_samples[worker_id] > dl_sizes[worker_id]:
last_batch_size = dl_sizes[worker_id] % batch_size
for key, value in inputs.items():
inputs[key] = model.clip_last_batch(value, last_batch_size)
outputs = model.clip_last_batch(outputs, last_batch_size)
if compute_loss:
total_loss += loss * batch_size


@import fr.gospeak.core.domain.User @import fr.gospeak.core.domain.UserRequest.PasswordResetRequest @import fr.gospeak.web.auth.routes.AuthCtrl @import fr.gospeak.web.utils.UserAwareReq @(user: User, passwordReset: PasswordResetRequest)(implicit req: UserAwareReq[AnyContent])
Hello @user.firstName,
Oops, your password seems completely lost :(
Fortunately, here is your reset password link to keep using gospeak \o/
We hope you are enjoying it and make amazing talks or events
The Gospeak team


Ticket ID: 409788
Name:
Parker Seidel
No Active Support
Email:
<EMAIL_ADDRESS>Response Time:
72hours, 60hours left
Last Action:
Never been locked.
Link to piblic post
Status:
Not answered


This is the second Apache release of DistributedLog and the first release as a sub-project of Apache BookKeeper!
The 0.5.0 release upgrades BookKeeper from Twitter 4.3.7-TWTTR-OSS
version to the official Apache 4.5.0
version.
It is a big milestone in Apache BookKeeper & DistributedLog community, converging the development efforts for
both communities and moving the DistributedLog development on the official Apache bookkeeper release.
Apache DistributedLog users are encouraged to upgrade to 0.5.0. The technical details of this release are summarized below.
The main change in 0.5.0 is BookKeeper version upgrade. We upgraded the BookKeeper version from Twitter’s 4.3.7-TWTTR-OSS
to the official Apache BookKeeper 4.5.0
version. This upgrade brings in BookKeeper security feature and performance improvement (such as netty 4 upgrade).
The upgrade should be straightforward, because there isn’t any backward compatible issue.
Prior to 0.5.0, the DistributedLog API heavily depends on Twitter Future library and other scala dependency. In 0.5.0, we change the twitter future API to a separate module and replace the core API with Java8 CompletableFuture. It reduces the dependencies introduced by Scala and also avoid maintaining multiple versions for different scala versions.
After upgrading to BookKeeper 4.5.0, we update the buffer and memory management in DistributedLog to leverage netty’s buffer management. It reduces object allocation, memory copies and improves the latency because less jvm garbage is produced.
####Sub-task
####Bug
####Improvement
####Task


sherlock.cl_utils (module) ∞
# SHERLOCK # : INFERING TRANSIENT-SOURCE CLASSIFICATIONS FROM SPATIALLY CROSS-MATCHED CATALOGUED SOURCES : =============================================================================================
Documentation for sherlock can be found here: http://sherlock.readthedocs.org/en/stable
Todo
- docuument cl_utils module
- tidy usage text
- Usage:
- sherlock init sherlock info [-s <pathToSettingsFile>] sherlock [-NA] dbmatch [-f –update] [-s <pathToSettingsFile>] sherlock [-vN] match – <ra> <dec> [<pathToSettingsFile>] sherlock clean [-s <pathToSettingsFile>] sherlock wiki [-s <pathToSettingsFile>] sherlock import ned <ra> <dec> <radiusArcsec> [-s <pathToSettingsFile>] sherlock import cat <cat_name> <pathToDataFile> <cat_version> [-s <pathToSettingsFile>] sherlock import stream <stream_name> [-s <pathToSettingsFile>]
- Options:
init setup the sherlock settings file for the first time match XXXX dbmatch database match clean XXXX wiki XXXX import XXXX ned use the online NED database as the source catalogue cat import a static catalogue into the crossmatch catalogues database stream download/stream new data from a give source catalogue into the sherlock crossmatch catalogues database info print an overview of the current catalogues, views and streams in the sherlock database ready for crossmatching
ra the right-ascension coordinate with which to perform a conesearch (sexegesimal or decimal degrees) dec the declination coordinate with which to perform a conesearch (sexegesimal or decimal degrees) radiusArcsec radius in arcsec of the footprint to download from the online NED database cat_name name of the catalogue being imported (veron|milliquas|ned_d) stream_name name of the stream to import into the crossmatch catalogues database (ifs)
-N, --skipNedUpdate do not update the NED database before classification -A, --skipAnnotation do not update the peak magnitudes and human readable text annotations of objects (can eat up some time) -f, --fast faster but errors in crossmatch table ingest my be misses -h, --help show this help message -s, --settings the settings file -v, --verbose print more details to stdout -l, --transientlistId the id of the transient list to classify -u, --update update the transient database with new classifications and crossmatches
Functions
main ([arguments]) |
The main function used when cl_utils.py is run as a single script from the cl, or when installed as a cl command |


Notebooks
Story: Blank pages in Bleek's Book XVIII
Blank pages in Bleek's Book XVIII
Title
Blank pages in Bleek's Book XVIII
Collection
Summary
Blank pages in the notebook.
Keywords
blank pages (in Bleek's Book XVIII) , pages (blank, in Bleek's Book XVIII)
Story Pages
1759-1777


This library module is an interface to the Berkeley DB toolset to support persistent storage of Prolog terms. Some of the notions of Berkeley DB are directly inherited, e.g. the environment.
The interface uses the Concurrent Access Methods product of Berkeley DB. This means that multiple processes can open the same databas, but transactions and disaster recovery are not supported.
The environment and the database files are ordinary Berkeley DB entities
which means that the standard support utilities (e.g. db_stat
)
will work.


Version History
| Version | Changes |
|---|---|
v10.2.0 |
has added. |
v9.5.0 |
Rewrites added. |
Rewrites allow you to map an incoming request path to a different destination path.
Rewrites act as a URL proxy and mask the destination path, making it appear the user hasn’t changed their location on the site. In contrast, redirects will reroute to a new page and show the URL changes.
To use rewrites you can use the rewrites
key in
next.config.js
:
Rewrites are applied to client-side routing, a
<Link href="/about">
will have the rewrite applied in
the above example.
rewrites
is an async function that expects an array to be
returned holding objects with source
and
destination
properties:
source
: String
- is the incoming request path
pattern.
destination
: String
is the path you want to
route to.
basePath
: false
or undefined
- if
false the basePath won’t be included when matching, can be used for
external rewrites only.
locale
: false
or undefined
-
whether the locale should not be included when matching.
has
is an array of
has objects with the
type
, key
and value
properties.
Rewrites are applied after checking the filesystem (pages and
/public
files) and before dynamic routes by default. This
behavior can be changed by instead returning an object instead of an array
from the rewrites
function since v10.1
of
Next.js:
module.exports = {
async rewrites() {
return {
beforeFiles: [
// These rewrites are checked after headers/redirects
// and before all files including _next/public files which
// allows overriding page files
{
source: '/some-page',
destination: '/somewhere-else',
has: [{ type: 'query', key: 'overrideMe' }],
},
],
afterFiles: [
// These rewrites are checked after pages/public files
// are checked but before dynamic routes
{
source: '/non-existent',
destination: '/somewhere-else',
},
],
fallback: [
// These rewrites are checked after both pages/public files
// and dynamic routes are checked
{
source: '/:path*',
destination: `https://my-old-site.com/:path*`,
},
],
}
},
}
When using parameters in a rewrite the parameters will be passed in the
query by default when none of the parameters are used in the
destination
.
module.exports = {
async rewrites() {
return [
{
source: '/old-about/:path*',
destination: '/about', // The :path parameter isn't used here so will be automatically passed in the query
},
]
},
}
If a parameter is used in the destination none of the parameters will be automatically passed in the query.
module.exports = {
async rewrites() {
return [
{
source: '/docs/:path*',
destination: '/:path*', // The :path parameter is used here so will not be automatically passed in the query
},
]
},
}
You can still pass the parameters manually in the query if one is already
used in the destination by specifying the query in the
destination
.
module.exports = {
async rewrites() {
return [
{
source: '/:first/:second',
destination: '/:first?second=:second',
// Since the :first parameter is used in the destination the :second parameter
// will not automatically be added in the query although we can manually add it
// as shown above
},
]
},
}
Path matches are allowed, for example /blog/:slug
will match
/blog/hello-world
(no nested paths):
module.exports = {
async rewrites() {
return [
{
source: '/blog/:slug',
destination: '/news/:slug', // Matched parameters can be used in the destination
},
]
},
}
To match a wildcard path you can use *
after a parameter, for
example /blog/:slug*
will match
/blog/a/b/c/d/hello-world
:
module.exports = {
async rewrites() {
return [
{
source: '/blog/:slug*',
destination: '/news/:slug*', // Matched parameters can be used in the destination
},
]
},
}
To match a regex path you can wrap the regex in parenthesis after a
parameter, for example /blog/:slug(\\d{1,})
will match
/blog/123
but not /blog/abc
:
module.exports = {
async rewrites() {
return [
{
source: '/old-blog/:post(\\d{1,})',
destination: '/blog/:post', // Matched parameters can be used in the destination
},
]
},
}
The following characters (
, )
, {
,
}
, :
, *
, +
,
?
are used for regex path matching, so when used in the
source
as non-special values they must be escaped by adding
\\
before them:
module.exports = {
async redirects() {
return [
{
// this will match `/english(default)/something` being requested
source: '/english\\(default\\)/:slug',
destination: '/en-us/:slug',
permanent: false,
},
]
},
}
To only match a rewrite when header, cookie, or query values also match
the has
field can be used. Both the source
and
all has
items must match for the rewrite to be applied.
has
items have the following fields:
type
: String
- must be either
header
, cookie
, host
, or
query
.
key
: String
- the key from the selected type
to match against.
value
: String
or undefined
- the
value to check for, if undefined any value will match. A regex like
string can be used to capture a specific part of the value, e.g. if the
value first-(?<paramName>.*)
is used for
first-second
then second
will be usable in the
destination with :paramName
.
module.exports = {
async rewrites() {
return [
// if the header `x-rewrite-me` is present,
// this rewrite will be applied
{
source: '/:path*',
has: [
{
type: 'header',
key: 'x-rewrite-me',
},
],
destination: '/another-page',
},
// if the source, query, and cookie are matched,
// this rewrite will be applied
{
source: '/specific/:path*',
has: [
{
type: 'query',
key: 'page',
// the page value will not be available in the
// destination since value is provided and doesn't
// use a named capture group e.g. (?<page>home)
value: 'home',
},
{
type: 'cookie',
key: 'authorized',
value: 'true',
},
],
destination: '/:path*/home',
},
// if the header `x-authorized` is present and
// contains a matching value, this rewrite will be applied
{
source: '/:path*',
has: [
{
type: 'header',
key: 'x-authorized',
value: '(?<authorized>yes|true)',
},
],
destination: '/home?authorized=:authorized',
},
// if the host is `example.com`,
// this rewrite will be applied
{
source: '/:path*',
has: [
{
type: 'host',
value: 'example.com',
},
],
destination: '/another-page',
},
]
},
}
Rewrites allow you to rewrite to an external url. This is especially useful for incrementally adopting Next.js.
module.exports = {
async rewrites() {
return [
{
source: '/blog/:slug',
destination: 'https://example.com/blog/:slug', // Matched parameters can be used in the destination
},
]
},
}
You can also have Next.js fall back to proxying to an existing website after checking all Next.js routes.
This way you don’t have to change the rewrites configuration when migrating more pages to Next.js
module.exports = {
async rewrites() {
return {
fallback: [
{
source: '/:path*',
destination: `https://custom-routes-proxying-endpoint.vercel.app/:path*`,
},
],
}
},
}
See additional information on incremental adoption in the docs here.
When leveraging
basePath
support
with rewrites each source
and destination
is
automatically prefixed with the basePath
unless you add
basePath: false
to the rewrite:
module.exports = {
basePath: '/docs',
async rewrites() {
return [
{
source: '/with-basePath', // automatically becomes /docs/with-basePath
destination: '/another', // automatically becomes /docs/another
},
{
// does not add /docs to /without-basePath since basePath: false is set
// Note: this can not be used for internal rewrites e.g. `destination: '/another'`
source: '/without-basePath',
destination: 'https://example.com',
basePath: false,
},
]
},
}
When leveraging
i18n
support
with rewrites each source
and destination
is
automatically prefixed to handle the configured
locales
unless you add locale: false
to the
rewrite. If locale: false
is used you must prefix the
source
and destination
with a locale for it to
be matched correctly.
module.exports = {
i18n: {
locales: ['en', 'fr', 'de'],
defaultLocale: 'en',
},
async rewrites() {
return [
{
source: '/with-locale', // automatically handles all locales
destination: '/another', // automatically passes the locale on
},
{
// does not handle locales automatically since locale: false is set
source: '/nl/with-locale-manual',
destination: '/nl/another',
locale: false,
},
{
// this matches '/' since `en` is the defaultLocale
source: '/en',
destination: '/en/another',
locale: false,
},
{
// this gets converted to /(en|fr|de)/(.*) so will not match the top-level
// `/` or `/fr` routes like /:path* would
source: '/(.*)',
destination: '/another',
},
]
},
}


Akan names are derived from Ghanian culture. Frequently in Ghana, children are given their first name as a 'day name' which corresponds to the day in the week they were born. Here are Ghanian day names. The table below shows a display of the seven days in a week and the corresponding names assigned to them.
| # | Male | Female |
|---|---|---|
| Sunday | Kwasi | Akosua |
| Monday | Kwadwo | Adwoa |
| Tuesday | Kwabena | Abenaa |
| Wednesday | Kwaku | Akua |
| Thursday | Yaw | Yaa |
| Friday | Kofi | Afua |
| Saturday | Kwame | Ama |
Your Akan name is;


Hello there. You've landed on this website. How impressive. Any reason for you to be here?
You must've clicked on a link like this one. Oh well. Since your here I better talk about my self.
Anyways I'm iop3. (duh). I live in [REDACTED]. (duh). I had a python class in October 2020. There was only like 5 or 6 classes. I didn't learn much.
Later on I discovered replit. (yay). A few months later I found github.
I started to learn html/css/js. Html was easy. Css wasn't my thing. Js isn't my thing either.
Contant me at<EMAIL_ADDRESS>.
That's it. Literally.
Just go here.


Sentry Roselyn:
Jasmine, you just wait!
I feel ashamed, but this is what happened to me a long time ago. How could she say that about her sister!
Sounds like she had some words for you, too, the condescending blabbermouth. It's time for us to correct her. Even I can't stay indifferent after hearing that.
Please take this note to Magister Harne. It has some great gossip about Jasmine he'd love to hear.


Vegans Sue Burger King Over 'Meat Contaminated' Whopper - Reports
Burger King's Impossible Whopper, which quickly became the fast-food chain's most successful launch and has been positively received by vegans and vegetarians alike, will see the release of three more sandwiches using the plant-based patties in 2019.
A group of vegans launched a lawsuit against Burger King for an alleged blunder by the fast food company in their manufacture of their new Impossible Whopper, according to Fox News on Monday.
The suit was launched by Phillip Williams over allegations that the restaurant's cooking methods use the same equipment to cook the vegetarian burger that is used for the meat-based burgers.
Williams, a self-described vegan, claimed that the plant-based Impossible Whopper is contaminated by meat byproducts due to the practice of cooking it on the same grill as beef sandwiches, TMZ reported.
According to Williams, a consistent customer of the vegan Whopper in Atlanta, Georgia, vegans are outraged by any practice which leads to the meat contamination of a vegetarian burger.
Some Twitter users accused "whiny protestors" of attempting to stop the production of the Impossible Whopper.
Others suggested that it was inconsistent for vegetarians to demand food options and then to sue the chain.
Some asked why a vegan would want to eat at a Burger King.
Burger King has warned customers that the 'vegan' label does not carry over into how the burger is cooked, in this case, an "open kitchen environment". The fast-food company noted that customers can request their burgers be cooked in an oven, separate from meat-based products.
Burger King previously faced a backlash after customers noted that they had been served beef patties instead of the vegetarian impossible burger.


Provides a small framework and several implementations of ICP, the Internet Cache Protocol (RFC2186, RFC2187).


Files CCore/inc/sys/SysLog.h CCore/src/sys/SysLog.cpp
XCore uses SysLog to log some operations, like synchronization object operations. You may use it to log your own messages. By default, SysLog is disabled. To enable it you have to uncomment the following line in the SysLog.h files and rebuild CCore:
//#define CCORE_SYS_LOG_ENABLE
SysLog can be used in any context, including interrupt context, but you must be aware of the log message argument types: they must be lightweight types, there should be no memory allocation or other resource allocation operations in constructors, destructors, copy constructors, etc.
To log a message use the function Sys::Log:
template <LogableType ... TT>
void Sys::Log(Sys::LogCategory cat,const char *format,const TT & ... tt);
This function does nothing, if SysLog is disabled.
The following software entities are located in the Sys namespace. You can use them to access SysLog features, even if you disable SysLog. "Disabling" does not mean the complete SysLog removal, it just make the function Sys::Log doing nothing.
This enum describe a log message source. There are reserved values for system sources and other can be used by user.
enum LogSource
{
LogSourceCRT,
LogSourceTask,
LogSourceMutex,
LogSourceSem,
LogSourceEvent,
LogSourceAntiSem,
LogSourceResSem,
LogSourceMultiSem,
LogSourceMultiEvent,
LogSourceUserMin = 10,
LogSourceUserMax = 31
};
const char * GetTextDesc(LogSource src);
This enum describe a log message type. There are four common types: LogDebug, LogEvent, LogError, LogAlert. Other can be used by user.
enum LogType
{
LogDebug,
LogEvent,
LogError,
LogAlert,
LogTypeUserMin = 10,
LogTypeUserMax = 31
};
const char * GetTextDesc(LogType type);
LogCategory and LogFilter are built on LogSource and LogType. To create a LogCategory value you can use the operator |.
using LogCategory = LogCategory_enum<LogSource,LogType> ; using LogFilter = LogFilter_enum<LogSource,LogType> ; /* functions */ inline LogCategory operator | (LogSource src,LogType type) { return LogCategory(src,type); }
LogAccess is used to add a new message to the log.
class LogAccess : FastMutexBase::Lock
{
void *mem;
public:
LogAccess(LogCategory cat,ulen msg_len);
~LogAccess();
operator void * () const { return mem; }
void commit(LogMsgBase<LogCategory,LogStamp> *msg);
};
Below is an example how to add a message.
template <LogableType ... TT> void Log(LogCategory cat,const char *format,const TT & ... tt) { using MsgType = LogMsg<LogCategory,LogStamp,TT...> ; LogAccess access(cat,sizeof (MsgType)); if( access ) { MsgType *msg=new(PlaceAt(access)) MsgType(cat,format,tt...); access.commit(msg); } }
LogFilterAccess can be used to access the internal input SysLog message filter.
class LogFilterAccess : FastMutexBase::Lock
{
LogFilter *filter;
public:
LogFilterAccess();
~LogFilterAccess() {}
LogFilter * getPtr() const { return filter; }
LogFilter & operator * () const { return *getPtr(); }
LogFilter * operator -> () const { return getPtr(); }
};
The object of this class must be a local object with a short life-time.
*Sys::LogFilterAccess()=filter; filter=*Sys::LogFilterAccess(); Sys::LogFilterAccess()->disable(Sys::LogDebug);
LogCursor can be used to iterate over the SysLog content. It iterates the last count messages. LogCursor implements the Cursor interface.
class LogCursor : NoCopy
{
const LogMsgBase<LogCategory,LogStamp> *cur;
ulen count;
public:
explicit LogCursor(ulen count);
~LogCursor();
// object ptr
bool operator + () const { return cur!=0; }
bool operator ! () const { return cur==0; }
const LogMsgBase<LogCategory,LogStamp> * getPtr() const { return cur; }
const LogMsgBase<LogCategory,LogStamp> & operator * () const { return *cur; }
const LogMsgBase<LogCategory,LogStamp> * operator -> () const { return cur; }
// cursor
void operator ++ ();
};
PrintLog can be used to print the SysLog content. It prints the last count messages. You can provide a filter to exclude messages from the printing.
class PrintLog
{
ulen count;
LogFilter filter;
public:
explicit PrintLog(ulen count_,LogFilter filter_=LogFilter()) : count(count_),filter(filter_) {}
void print(PrintBase &out) const;
};
SysLog is created on an earlier stage of the system initialization. It uses IntLock to serialize the log access. SysLog stores messages in the reserved memory region, provided by the target. The function AllocLogSpace(), declared in the target header SysMemSpace.h, is called once during the SysLog initialization.
/* functions */
// one-time call , aligned
Space AllocHeapSpace();
Space AllocHeapSpace_int();
Space AllocHeapSpace_shared();
Space AllocLogSpace();
Space AllocVideoSpace();


The Tech Stack
Tech Stack
Over the past few weeks, I have been working hard to develop the groundwork for the Cupcake Physics site. Although I have had experience developing web apps in the past, this is the first time that I have coordinated all of the parts of a full stack app at one time; I have to think about everything from developing the app to managing deployment to monitoring the status of the servers (and much more). It has been challenging to learn about all of the details of managing an application, and I am sure I will learn plenty more in the future!
I want to write a blog post that outlines some of the progress that I have made in the past few weeks. I have experimented with a variety of technologies and written a number of toy applications in preparation for my actual project. This is a good time to reflect on some of my experiences. At the very least, this post will help me organize some of my thoughts for future development. Ideally, this reflection might help other developers in their own work. Instead of talking about every detail of my experimentation, I will dive into three different technologies in order to make sure that this post does not become a novel!
The Frontend - Elm
I have experience coding the backends of a variety of applications at my current job and during my research. These apps range from legacy enterprise systems to more modern APIs and use a variety of languages - Java, PHP, Ruby, etc. I am generally comfortable with backend development and enjoy the challenge of implementing business logic in an elegant way.
However, frontend development has frustrated me in the past. Although I do have a fair amount of experience in this area, I have found the act of writing code for the frontend quite tedious. Javascript libraries and frameworks do help make the experience better, but I feel like I can never trust that browsers will do what I want them to do. No matter how many tests I write or no matter how simple I make my functions, I do not have a high degree of confidence in the code that is shipped out to the user’s browser. There is too much variability in everything from the version of the browser to the device on which the page is viewed.
I heard about the Elm language from a co-worker and grew quite curious about it. It is frontend development as I have never experienced - I have never used a statically typed, functional langage (let alone one on the frontend!). After a few tutorials, I fell in love with the language. After writing some well-tested Elm code, I am confident that it does what I expect it to do. As an added bonus, Elm is remarkably similar to Elixir (see below), so the frontend and backend feel very similar - even though they are written in two different languages.
The Backend - Elixir/Phoenix
Ruby on Rails was my original choice for the backend of Cupcake Physics. I have enjoyed working with the framework in the past due to the fact that I can develop code very quickly and iterate efficiently. However, I have found issue with some aspects of the framework (e.g. it has a tendency to produce monolithic apps, it couples data persistence very tightly to your business logic, etc.). Since the functional style of programming drew me to the Elm language, I decided to try something new for the backend as well.
I had some experience writing Elixir apps before coming into this project. My experience with Elixir and Rails made the Phoenix framework seem very natural to me. Phoenix addresses many of the concerns that I had about the Rails framework, and it uses powerful elements of the Elixir language (like pattern matching) to create very simple and readable code.
Infrastructure - Ansible
A few weeks ago, I had little experience with the operations side of running an app. Thus, a large amount of my time was spent learning how to run and monitor an app. I tried out a few different technologies during the past few weeks such as Chef and Puppet. However, I found that Ansible to have the right mixture of ease of use and power for IT automation. I especially like the fact that Ansible uses simple Yaml files rather than a domain speicific language to specify and run tasks.
Final Thoughts
These past few weeks have been a great learning experience for me. I know I will definitely have to keep learning about these technologies (and others) as I build this app.
Until next time!


PopMenu is a jQuery plugin that lets you add right-click context menu (popup menu) to any HTML element on your web page! Not only for desktop users, PopMenu can also provide context menu for mobile users with touch screen by long-tapping.
Using PopMenu is easy. But before we begin, PopMenu requires several JS and CSS files to work. Therefore, load the following files in the HEAD section of the page.
<script type="text/javascript" src="js/jquery-1.7.1.min.js"></script> <script type="text/javascript" src="js/jquery.popmenu.js"></script> <link type="text/css" rel="stylesheet" href="css/jquery.popmenu.css" /> <link type="text/css" rel="stylesheet" href="css/jquery.popmenu.icons.css" />
Once the files are loaded, we could assign PopMenu to any HTML elements. Let's say we want to assign a context menu to a button. To assign a separator, add an item without label. Each menu item consists of an ID and options. Please note that the ID of all menu items, including submenu items in a single context menu group must be unique.
<input type="button" id="MyButton" value="Right Click Here" /> <script type="text/javascript"> $(function() { $('#MyButton').popmenu({ itemId1: {label: 'Item One', action: eventHandler}, separator: {}, itemId2: {label: 'Item Two', action: eventHandler}, }); }); function eventHandler() { /* Function to be executed when an item is selected */ } </script>
Please refer to Examples for more advanced usages of PopMenu.
Calling $(elm).popmenu() without any parameters will return you an instance of PopMenu object. With this object, you could add, remove, and access menu items. Each menu item is an instance of PopMenuItem. Consult these two classes for more information regarding available methods and options.
// To access PopMenu instance $(elm).popmenu(); // To access menu item $(elm).popmenu().find('item_id'); // To add a new item $(elm).popmenu().append('item_id', {label: 'Item Label'}); // To remove an item $(elm).popmenu().remove('item_id');


What do you want to tell us about?
We'll get it fixed as soon as we can, and let you know.
Chrome plugin
Bookmarklet
Website
Firefox plugin
EmbedOA (a search widget for external sites)
OAsheet
DeliverOA
InstantILL
Shareourpaper.org
Facebook Messenger Bot
I don't understand what I'm being asked
I don’t know or trust the Open Access Button
I don’t want to share my data or article
Yes
No
We apologize that we didn’t give you the content you were looking for. Linking to the correct version can be difficult sometimes. Please let us know your issue and we’ll work to resolve it:
The Button searched for the wrong paper
A copy I know is available wasn't shown
The article wasn't actually available
I didn't get sent directly to the full-text
We're constantly trying to improve the Button, can you help by giving us some quick feedback?
Check all that apply:
It didn't find what I needed
It's hard to use
I don't want to make requests
It didn't work
I found a better tool
I don't have the time
I don't want to
I can't find the right version
I have already shared it
We spend day (and night) making the Open Access Button the best it can be. If you have any feedback or ideas we'd love to hear them.
Thanks for your response.


Pod5 was a fun summer experiment by @dblockdotorg and @orta. Summer has come to a close, and so has pod5. There's a million good podcasts out there, though not as many corny ones. Fork this repo and make your own.


Chorley man who was caught by online paedophile hunters is sentenced
by Stef HallA man who was reported to police by a self styled ‘paedophile hunters’ group after they posed as a teenager has been ordered to sign the Sex Offender’s Register for five years.
Liam Matthew Griffin, of Stratford Road, Chorley, was involved in an online conversation with a person he thought was a 13-year-old girl on February 4, and later admitted attempting to engage in sexual activity with a child.

READ MORE: Chorley man exchanged sexual messages with paedophile hunters posing as teenage girl
Griffin, who suffers from Aspergers and learning difficulties, was committed to Preston Crown Court for sentencing.
Recorder Wright QC imposed a two year community order with a curfew and 10 rehabilitation activity days.
He was also given a five year sexual harm prevention order, and must pay a £90 victim surcharge.
A previous hearing at the magistrates’ court was told the defendant became involved in exchanging messages with a girl he believed to be 13.
He admitted in interview that although she gave different ages he did eventually believe her to be 13.
But the person he was messaging were adults involved in a paedophile hunting network.
During the course of the conversation Griffin had asked for pictures of her naked breasts and some pictures were sent to him.
At the same hearing his defence lawyer, Laura Walmsley said the “pseudo person” had appeared in the ‘people you may know’ section of Facebook and he had not deliberately sought out a 13-year-old girl.
She also said it was a very “juvenile conversation” that went on, but acknowledged it did become criminal.
Judges need to consider a number of factors when imposing a sentence to ensure the sentence is one of punishment, rehabilitation, reparation and public protection.
The Sentencing Council states that a mental illness or learning disability can be a mitigating factor when considering a suitable punishment.
In addition, judges or magistrates have to take the abilities and support needs of individual offenders into consideration, in order to avoid unreasonable or unrealistic expectations being imposed on them when sentenced.