This menu allows you to change commonly configured Apache options. OverviewThe Uniform Server Zero's default installation configures the main server with the values shown at right. Apache > Edit Basic and Modules > Edit Basic Configuration
Server NameServer Name sets the hostname of your server. (This is used when creating redirection URLs). UniServer Zero XIII does not directly change the server name in configuration files. It first sets the environment variable US_SERVERNAME which is picked-up by configuration files using ${US_SERVERNAME}. Both the main configuration file httpd.conf and httpd-vhosts.conf use this variable. It is the default host in the Vhost configuration file. To test your web site without being connected to the Internet and to prevent your browser complaining that the "Server cannot be found", you need to use one of the following options. UniServer Zero XIII by default uses both option 1 and option2. Option 1: To test your web site without being connected to the Internet Uniform Server Zero XIII uses a PAC file. For the above example, the following line is automatically added to this file:
Option 2: To test your web site without being connected to the Internet Uniform Server Zero XIII adds an entry to your PC’s hosts file. For the above example, the following line is automatically added to this file: Note: This option is not portable for portability use option 1. However before changing Server Name or creating a Vhost disable option 2 as follows:
General note:
Host Name Resolution OrderThe following is a general sequence for host name resolution:
Server Admin EmailThe Server Admin Email address is included with some automatically generated error pages sent to a client (user). Use a real e-mail address for users to contact you in case problems are encountered. Note: To eliminate common typing errors the e-mail address format is checked. The following are examples of correct format<EMAIL_ADDRESS><EMAIL_ADDRESS>and<EMAIL_ADDRESS>Error checking is a complex procedure and it is possible your valid e-mail address will be rejected. In this situation you need to edit the configuration files UniServerZ\core\apache2\conf\httpd.conf and or UniServerZ\core\apache2\conf\extra\httpd-vhosts.conf as appropriate. Directory Index FilesWhen a client requests an index page without explicitly specifying it (for example www.fred.com) the list of index pages specified in Direct Index Files is searched in the order left to right. If a match is found, that index page is served. The first one that matches is served and any others that may be in the same folder are ignored. Default list: index.html index.shtml index.html.var index.htm index.php3 index.php index.pl index.cgi The Uniform Server’s default installation uses index.php, which is found in the root folder www. If you insert your own index.html page, this will be picked up first, overriding index.php Server Side IncludesSSI is a server side scripting language allowing you to include the contents of a file into another using SSI commands. To insert these commands, a special comment tag is used; for example:
You can insert these into an html file, but in order to process them, Apache needs to know which files types to use. The standard file extensions are:
You can specify any file extension you like, even .htm and .html, but there is a small processing hit for each file accessed. Server SignatureThis allows Apache to add a footer line for server-generated documents. It contains the server version number, server name, and creates a "mailto:" reference to ServerAdmin. For security reasons, this information is normally not displayed except for testing and the default is set to off. Listen PortThis tells Apache to listen to a specific port and to accept incoming requests only on that port. Web page servers and all web browsers default to this standard port (80), which is reserverd for World Wide Web traffic (WWW). When a user types an address into a browser, the port is automatically assumed unless overridden, as explained later. Similar to the server name UniServer Zero XIII does not directly change the server port in configuration files. It first sets the environment variable AP_PORT which is picked-up by configuration files using ${AP_PORT}. Both the main configuration file httpd.conf and httpd-vhosts.conf use this variable. Port 80 already in use If another program is using port 80, you will want to change the listening port to avoid conflicts, or your Apache server will not start. Before changing the Apache port, be aware that this makes the server non-standard. A preferable solution is to change the port of the conflicting program. Apache already running You can change the port while the server is running, but you must restart the servers after making any changes. The new settings will then be picked up by Apache. General Note After changing Apache's listing port, in order to display a file you must include this port number in the host name. For example suppose you have changed the port to 8080. To view your home page you enter the following address http://localhost:8080/ into your browser address bar. Likewise to view any other page in your root folder www you would enter http://localhost:8080/mypage.html to display that page. Note 1: Note 2: --oOo--
|


Cosmic relations is an ideology that everything in the universe is somehow connected with one another. The biggest theory surrounding this is the similarities between the human brain and the universe.
Click to see the similarities
between the brain and the universe.
Not only are the complexities of
the brain and cosmic web actually
similar, but so are their structures.
Cosmic relations is an ideology that everything in the universe is somehow connected with one another. The biggest theory surrounding this is the similarities between the human brain and the universe.
The total number of neurons
in the human brain falls in the
same ballpark of the number
of galaxies in the observable
universe.
Hover over the image to explore.
The distribution of fluctuations in the cerebellum at 0.1-1 mm scales is reminiscent of the galaxy distribution on
of light-years. At the smallest scales available to microscopic observation (about 10 µm), it is the morphology of the cortex that more closely matches the one of galaxies, on scales of a few hundreds of thousands of light-years.
It is truly a remarkable fact that the cosmic web is more similar to the human brain than it is to the interior of a galaxy; or that the neuronal network is more similar to the cosmic web than it is to the interior of a neuronal body. Despite extraordinary differences in substrate, physical mechanisms, and size, the human neuronal network and the cosmos of galaxies, when considered with the tools of information theory, are strikingly similar.


--- title: Blog description: Jocelyn Lee blogs about her intimate life journey through spirituality, sexuality and artistry. image: "/uploads/Blog-Marquee.jpg" --- Blog An intimate journey into a woman's body, mind, heart & spirit read on ▼ ✎ Add Post {% for post in paginator.posts %} {% include post.html %} {% endfor %} {% if paginator.total_pages > 1 %} ← Newer posts Page {{ paginator.page }} of {{ paginator.total_pages }} Older posts → {% endif %}
An intimate journey into a woman's body, mind, heart & spirit
✎ Add Post


This is a picture of one of our single prints. As you can see they are hand painted to match as closely as possible to your loved one. We take pride and care in what we do.
This is another one of our single prints. We also try and match your picture background, if desired.
However if you choose not to keep the original background we'll choose a corresponding color to best match the print.
This is an example of a Mobile. We can create a mobile design of up to 4 separate pieces.
As you can see in our example we have 3 separate prints hanging on one platform.
This is a Diorama scene. We try and recreate an atmosphere in one of their favorite spots as best we can.
As you can see here in our example, we decided to showcase an outdoors theme.
This is the beginning of our journey where you get to decide what type of keepsake you would like to have. We have several options which include a single print, a mobile structure, or a diorama.
This is the next iteration of the journey where we gather usable pictures for printing. We want you to give us your favorite pictures of ane we'll help you decide which ones will be best for printing.
We'll do our best to keep your most favorite ones, but sometimes the digital version of your loved ones won't necessarily print properly.
First we convert your picture to an .stl using a website; https://imagetostl.com/.
This is the beginning process of turning your digital print into a 3D file.
Next we use a program called Chitubox to scale, adjust, and slice your image into a usable printing file.
There are 3 stages to creating a print.
First, we create our 3D print using a Photon resin 3D printer. There are many different types of 3D printers. We decided to go with a resin (liquid) based printer. There were many factors in why we decided to purchase this type of 3D printer, but ultimately it was due to the accuracy of the prints we're able to create.
Second, we clean the prints using an ultrasonic cleaner. There are several methods in which we could utilize in cleaning the prints. The main reason we clean the prints is to remove any resin residue prior to the curing process. We went with an ultrasonic cleaner as research suggested this was one of the best methods in cleaning prints.
Third, we cure the print using UV technology. We have a DIY curing station in which the cleaned print sits in a solar powered turntable and is cured by UV light. We normally leave the prints in the curing station for about 20 minutes.
First, we prime the sculpture using a grey based primer.
Our next step is to apply the individual paint. As you can see here this is a very time consuming process and a very delicate one due to the size of the prints we deal with.
Our final step is to apply a clear coat to the prints for a final look.
This is our final step in our process where we deliver our product to you. We hope you enjoy it as much as we have enjoyed making it.
Thanks for contacting us. We'll get back to you as soon as possible.
Albuquerque, NM 87123
(303) 880-6448
chavezbiz2843@gmail.com


Profiles¶
Overview¶
A waflz “profile” is configuration that builds on top of an existing ruleset. Beyond the basic ruleset/engine configuration, it adds “access control lists” (ACL’s) for various use-cases we’ve found useful (eg url’s/user-agents/ip’s etc). ACL’s can of course be expressed in ModSecurity rules as well, but we’ve found it convenient to add ACL’s into the profile json. A profile just extends a ruleset, however, and a profile w/o a ruleset isn’t useful for much other than outright blocking with ACL’s.
Example Profile json¶
{
"name": "Koala Blocking Profile",
"id": "WAF Test 13",
"created_date": "12/02/2018 1:39:46 PM",
"access_settings": {
"ip": {
"blacklist": [
"2607:f8b0:4007:801::200e"
],
"whitelist": []
},
"country": {
"blacklist": [
"AU"
],
"whitelist": []
},
"url": {
"blacklist": [
"/login/login.jsp"
],
"whitelist": []
},
"user-agent": {
"blacklist": [
"cerl/7.58.0"
],
"whitelist": []
},
"referer": {
"blacklist": [
"http://www.hotzone.com/"
],
"whitelist": []
},
"ignore_header": [
"(?i)(benign-header)",
"^D"
],
"ignore_cookie": [
"(?i)(crazy_cookie)",
"^[0-9_].*$"
],
"ignore_query_args": [
"ignore",
"this"
]
},
"general_settings": {
"allowed_http_methods": [
"GET",
"POST"
],
"disallowed_extensions": [
".bat",
".db",
".dll",
".sql",
".sys"
],
"allowed_request_content_types": [
"application/x-www-form-urlencoded",
"multipart/form-data",
"text/xml",
"application/xml",
"application/json"
],
"disallowed_headers": [
"Bad-Header"
],
"arg_name_length": 1024,
"arg_length": 8000,
"max_num_args": 4,
"total_arg_length": 64000,
"combined_file_sizes": 6291456,
"max_file_size": 6291456,
"validate_utf8_encoding": true,
"xml_parser": true,
"anomaly_threshold" : 1,
},
"ruleset_id": "OWASP-CRS-2.2.9",
"ruleset_version": "2017-08-01",
"policies" : [
"modsecurity_crs_20_protocol_violations.conf",
"modsecurity_crs_21_protocol_anomalies.conf",
"modsecurity_crs_22_custom_ec_rules.conf",
"modsecurity_crs_23_request_limits.conf",
"modsecurity_crs_30_http_policy.conf",
"modsecurity_crs_35_bad_robots.conf",
"modsecurity_crs_40_generic_attacks.conf",
"modsecurity_crs_41_sql_injection_attacks.conf",
"modsecurity_crs_41_xss_attacks.conf",
"modsecurity_crs_42_tight_security.conf",
"modsecurity_crs_45_trojans.conf",
"modsecurity_crs_47_common_exceptions.conf",
"modsecurity_crs_49_inbound_blocking.conf",
"modsecurity_crs_50_outbound.conf",
"modsecurity_crs_59_outbound_blocking.conf",
"modsecurity_crs_60_correlation.conf"
]
}
Access Control Lists¶
Access control lists (ACL’s) for various facets of an http client request are listed below. ACL’s are processed first before ruleset processing; whitelists followed by blacklists. Whitelists are explicit call out to features if found in the client http request, all waflz processing is bypassed. Blacklists are simple binary conditions, whereby if a feature matches, waflz creates and alert and ceases further processing. It’s a current legacy quirk that some fields that are not access control lists are included in the "access_settings"
group and as well that some configuration that is an access control is in the "general_settings"
group.
The following features are included in ACL’s:
* "ip"
: IPv4/IPv6 address (w/ CIDR support)
* "country"
: 2 letter country code
* "user_agent"
: "User-Agent"
header from client http request (w/ regex support)
* "referer"
: "Referer"
header from client http request (w/ regex support)
Block Example¶
- IP addresses with “2001:db8::/32” ipv6 prefix or “<IP_ADDRESS>/24” ipv4 prefix
- IP addresses from Virgin Islands or Sweden
- curl or wget clients…
- traffic coming from google or yahoo (via referer)
{
"access_settings": {
"ip": {
"blacklist": ["2001:db8::/32", "<IP_ADDRESS>/24"],
"whitelist": []
},
"country": {
"blacklist": ["VI", "SE"],
"whitelist": []
},
"user_agent": {
"blacklist": ["curl*", "wget*"],
"whitelist": []
},
"referer": {
"blacklist": ["http://google.com", "http://yahoo.com"],
"whitelist": []
},
}
Ignore Fields¶
The following features are included in ACL’s:
* "ignore_header"
: Headers from the client http request (w/ regex support)
* "ignore_cookie"
: Field names from the parsed "Cookie"
header in the client http request (w/ regex support)
* "ignore_query_args"
: Fields names from the parsed query string in the url from the client http request line (w/ regex support)
Ignore Example¶
Benign-Header
(case insensitive), and any headers starting with numbers.crazy_cookie
cookies, and cookies starting with charactersa
,``b``, orc
.- query string arguments named
ignore
orthis
.
{
"ignore_header": [
"(?i)(benign-header)",
"^\d"
],
"ignore_cookie": [
"(?i)(crazy_cookie)",
"^[a-c]"
],
"ignore_query_args": [
"ignore",
"this"
]
}
General Settings¶
Allowed Settings¶
{
"allowed_http_methods": [
"GET",
"POST"
],
"disallowed_extensions": [
".bat",
".db",
".dll",
".sql",
".sys"
],
"allowed_request_content_types": [
"application/x-www-form-urlencoded",
"multipart/form-data",
"text/xml",
"application/xml",
"application/json"
],
"disallowed_headers": [
"Bad-Header"
]
}
Anomaly Settings¶
"anomaly_threshold" : 1
WAF Ruleset¶
Specify the WAF ruleset and “version” to use.
Ruleset Configuration¶
It’s been useful to have a top level directory of rulesets that were versioned (usually by date), so
waflz expects the WAF ruleset directory containing ModSecurity rule files organized as: <"ruleset_id">/version/<"ruleset_version">/...
So in the example below if
{
"ruleset_id": "OWASP-CRS-2.2.9",
"ruleset_version": "2017-08-01",
}
The contents of ruleset directory would look like:
OWASP-CRS-2.2.9/
version/
2017-08-01/
modsecurity_crs_20_protocol_violations.conf
...
Policy Configuration¶
Within a given ruleset/version directory, the policies to be included are specified in the "policies"
array.
{
"policies" : [
"modsecurity_crs_20_protocol_violations.conf",
"modsecurity_crs_21_protocol_anomalies.conf",
"modsecurity_crs_22_custom_ec_rules.conf",
"modsecurity_crs_23_request_limits.conf",
"modsecurity_crs_30_http_policy.conf",
"modsecurity_crs_35_bad_robots.conf",
"modsecurity_crs_40_generic_attacks.conf",
"modsecurity_crs_41_sql_injection_attacks.conf",
"modsecurity_crs_41_xss_attacks.conf",
"modsecurity_crs_42_tight_security.conf",
"modsecurity_crs_45_trojans.conf",
"modsecurity_crs_47_common_exceptions.conf",
"modsecurity_crs_49_inbound_blocking.conf",
"modsecurity_crs_60_correlation.conf"
]
}


{% extends 'base.html' %} {% block content %} {{block.super}}
location: {{hood.location|capfirst}}, Kenya
occupants: {{hood.occupants.count}}
businesses: {{hood.business.count}}
{{hood.description}}
{{occupant.user.username}}
{{occupant.user.email}}


I feel I should drop a brief line on dissociatives. My first experiences with dissociatives were with tobacco cigarettes dipped in large amounts of PCP (estimated 100-150 mg per cigarette.) My friends and I were smoking fully anaesthetic 'P-hole' ;) doses of PCP daily for a few weeks. I would smoke small doses at work and found that it considerably enhanced my performance, especially my short-term memory. At night we would rocket into the void, spending millenia in the worlds of the imagination. It was truly indescribable and I really wont even try, but let me say that anything seemed possible, indeed was, we could travel bodyless to countless times, places, dimensions.
I never noticed the least side effect and felt wonderfull for weeks after stopping when I moved to the Carribean. I was actually stiil quite high for maybe 4 weeks after discontinuation. After this I was obsessed with dissociatives for years, but they remained unavailable until a friend showed up with some Ketamine some 3-4 years later. I snorted 200 mg and had a mild dissaciative experience, just a tease really, and tease me it did. I WANT MORE! A week later the same friend gave me another 200 mg line at a rave when I was already rolling. Fairly good high, but not enough.
A week later the same friend and I bought several grams of chemical supply house Ketamine and I snorted it from morning till night, even doing 100mg rails at work, for a couple of weeks. I started slipping into the worst addiction of my life, and that's saying alot considering that i have been very addicted to heroin, methamphetamine, opium, benzos and alcohol at various times, and when I say addicted, I mean ADDICTED. This was far more addictive than any of those substances, mentally at least. Nothing mattered but K.  Eventually my K supply dried up and I really felt like I was dead. I quit my jobs and became very depressed and suicidal. I developed a belief that death would be just like the K-hole and became obssessed with the idea of killing myself just to get high. Extremely bizarre, huh?
I became a weekly user of DXM, it didn't compare to K or PCP but it did the trick.  I never stopped looking but luckily never found any. On my last DXM journey I was flying through a labyrinth of caves when I suddenly met a cyclops entity that told me in no uncertain terms to STOP! this madness and then he kicked me right out of my dissociative state. I snapped instantly back into this world with a very differnt view. Over the next 2 years I struggled to make the doomed relationship I had begun on K work and failed, but I got really into plant teachers like harmala, trichocereus, mushrooms, and yopo. With their help I was able to come around to a much healthier state.
Recently I was able to get some more K and use it with some moderation, and had an important experience in which I was looking at this fascinating world full of awe-inspiring beauty from inside the K-hole, and wanted more than anything to get back to my body and my world, a feeling I had never felt before. I had finally developed a healthier attitude towards dissociatives, and now respectfully treat them as what they are - incredibly powerful tools that are far too dangerous for the inexperienced (think chemical chainsaw.) I am afraid to think what could have happened if I had not had so much practice withdrawing from a variety of addictive substances.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


This section will show you how to browse among the projects stored in VOEIS, explore the sites within a given project, and investigate the data types and variables associated with individual sites.
The Project_Browse page (shown below) lists all of the projects stored within VOEIS. The list can be sorted alphabetically by clicking the header box at the top labeled “Project”. To browse data within a single project, simply click the magnifying glass icon located to the left of the project name.
You will be directed to the Project_Show page for the project you selected. A map of all of the project sites will appear on the left side of the screen, and a site list will appear on the right side of the map. The site list can be sorted alphabetically by clicking on the header box. Clicking on a site location on the project map or on a site name in the site list will open a callout that displays some of the metadata associated with that site.
To see a more complete list of metadata, click on “Site Details” in the callout. A new (Site_Name) tab for the selected site will open in the map window (see below). This tab displays site location metadata, a list of variables associated with the site, and an option for exporting all of the data values associated with the site.
Clicking on individual variable names displayed in the (Site_Name) tab will create a new tab for that variable. This (Variable_Name) tab displays the metadata associated with the selected variable.
You can also browse among sites by opening the “Data Summary” tab. This tab provides a list of site names, IDs, Codes, the state where the site is located, the number of variables associated with the site, the number of data points saved to the site, and the date of the earliest and latest record. This list can be sorted by clicking on the table header boxes.
Another option for sorting the site list is to apply custom filters. To do this, click the small button with the yellow arrow located in the upper left. This button calls the pop-out window below. Custom filtering rules are described using Boolean logic and applied to either a single column or multiple columns.
When you return to the site list, you can click the magnifying glass icon next to a site name to open a new (Site_Name) tab containing the site metadata. Repeating this process for multiple sites simply adds new (Site_Name) tabs to the window.
Copyright © 2011, Montana State University
Created with the Freeware Edition of HelpNDoc: Easily create CHM Help documents


Would you rather...

Screen reader support enabled.


Scala Days 2013
by Hung Lin @hunglin
Scala the **** out of NYC
Hot Topics
Keynote: Scala with Style
by Martin Odersky, creator of scala
What is OOP good for?
OOP v.s. FP
Guideline #1
Keep it simple
Guideline #2
Don't pack too much in one expression
find meaningful names for the intermediate results. It's not easy but it's important
Guideline #3
Prefer Functional
Guideline #4
But, don't diabolize local state
vars v.s. vals
var interfaces = parseClassHeader()...
if (isAnnotation) interfaces += ClassFileAnnotation
val parsedIfaces = parseClassHeader()...
val interfaces =
if (isAnnotation) parsedIfaces + ClassFileAnnotation
else parsedIfaces
loops v.s. combinators
val totalPrice = items.map(_.price).sum
val totalDiscount = items.map(_.discount).sum
val (totalPrice, totalDiscount) =
items.foldLeft((0.0, 0.0)) {
case ((tprice, tdiscount), item) => (tprice + item.price, tdiscount + item.discount)
}
var totalPrice, totalDiscount = 0.0
for (item <- items) {
totalPrice += item.price
totalDiscount += item.discount
}
Guideline #5
Careful with mutable objects
val m = ArrayBuffer[Int]()
Guideline #6
Don't stop improving too early
Choice #1
Infix v.s. "."
Choice #2
Alphabetic v.s. Symbolic
val xs = List("apples", "oranges", "pears")
xs.foldLeft("")((result, i) => result + i)
("" /: xs)((result, i) => result + i)
Choice #3
Loop, recursion or combinators
Choice #4
Procedures or "="
DON'T use procedure syntax
def method: Unit = {
// operations
}
Choice #5
Private v.s. nested
Choice #6
pattern matching v.s. dynamic dispatch
the expression problem, check out scala class @ coursera, lecture 4.5 and 4.6
Choice #7
type parameters v.s. abstract type members
a good article by Bill Venners
Keynote: Scala in 2018
by Rod Johnson, creator of Spring
in 2018
myths / points
Any fool can write code that a computer can understand. Good programmers write code that human can understand.
- Martin Fowler
Debugging is twice as hard as writing the code in the first place. Therefore, if you write the code as cleverly as possible, you are, by definition, not smart enough to debug it.
- Brian Kernighan
Asynchronous Programming
asynchronous v.s. parallel
asynchronous v.s. batching
pitfall: thread pool?
for tomcat, one thread handles one request
pitfall: back pressure
pitfall: performance v.s. scaling issue
pitfall: theory v.s. reality
Some thoughts about our system
Upgrade to scala 2.10
Use akka
Use case class for data model
Use finagle for service modules
Questions?


hardware operations, while the staff moved away from Lucasfilm’s premises to new offices in Point Richmond — not far from a Chevron oil refinery. From then on, they would have to focus only on their boss’s new vision: Steve thought that RenderMan was going to become the next PostScript, an open standard adopted by the masses to make 3D renderings at home, just like PostScript had made desktop publishing possible. He was denying the reality of how hard it was to master three-dimensional animation.
If costs were indeed cut a little by this move, it didn’t make Pixar more profitable. The startup was still relying on Steve Jobs’ line of credit, and in 1990 alone, its net operating loss was over $8 million.
In March 1991, Steve went further in his drastic moves to make Pixar survive. He declared he would continue to keep funding it only if he were given back all of the employees’ stock shares.


Project Name
Awesomeeeee subtitle!!!
Details
This project is built during Orbital 2014.
It won best project
Installation
download this project and open it in your browser
Creators
2 wonderful students from NUS created this
- Me
- You
Awesomeeeee subtitle!!!
This project is built during Orbital 2014.
It won best project
download this project and open it in your browser
2 wonderful students from NUS created this


- AbstractBinaryTree<E> - Class in net.datastructures
-
An abstract base class providing some functionality of the BinaryTree interface.
- AbstractBinaryTree() - Constructor for class net.datastructures.AbstractBinaryTree
-
- AbstractTree<E> - Class in net.datastructures
-
An abstract base class providing some functionality of the Tree interface.
- AbstractTree() - Constructor for class net.datastructures.AbstractTree
-
- addFirst(E) - Method in class net.datastructures.SinglyLinkedList
-
Adds an element to the front of the list.
- addLast(E) - Method in class net.datastructures.SinglyLinkedList
-
Adds an element to the end of the list.
- addLeft(Position<E>, E) - Method in class net.datastructures.LinkedBinaryTree
-
Creates a new left child of Position p storing element e and returns its Position.
- addRight(Position<E>, E) - Method in class net.datastructures.LinkedBinaryTree
-
Creates a new right child of Position p storing element e and returns its Position.
- addRoot(E) - Method in class net.datastructures.LinkedBinaryTree
-
Places element e at the root of an empty tree and returns its new Position.
- attach(Position<E>, LinkedBinaryTree<E>, LinkedBinaryTree<E>) - Method in class net.datastructures.LinkedBinaryTree
-
Attaches trees t1 and t2, respectively, as the left and right subtree of the
leaf Position p.


The Akan people of Ghana and the Ivory Coast frequently name their children after the day of the week
they were born and the order in which they were born. These "day names" have further meanings concerning
the soul and character of the person. Middle names have considerably more variety and can refer to their
birth order, twin status, or an ancestor's middle name.


Hello visitor and welcome to my personal About-Me page. My name is Pat Lathrop and my personal life education and experience is a sordid affair. I first learned to distill moonshine with my grand pappy at the young age of 12 and later began distilling all sorts of fine whiskey and brandy.
During my moonshining apprenticeship, it was important to keep our still locations private, which led to me having extensive knowledge of the foothills and trails all around the Pacific Northwest. This knowledge helped me become a volunteer forestry ranger and later a search and rescue volunteer.
Through this I developed a familiarity with the fauna of the Pacific Northwest; however, not even this prepared me for the events of March 2000 along the Pacific Coast Trail, near Packwood Lake. Not to get into too much detail, but those events led me onto a lifelong study in cryptozoology, particularly the search for Bigfoot.
I spent nearly three years living in the woods and tracking every possible bigfoot sighting available, many of the same ones reported to the Bigfoot Field Researchers Organization (BFRO) website. For more information on the BFRO, check out https://www.bfro.net.


I am currently enrolled at University of North Carolina at Wilmington.
I plan on graduating in December of 2018 with a BA in Marketing Strategy with a minor in Digital Arts.
Projects
Service Name
Lorem ipsum dolor sit amet, consectetur adipisicing elit.


Open IO Is Always Looking For New
We would love to see you contribute! If interested, please don't hesitate to email<EMAIL_ADDRESS>We will make sure to invite you to our Mattermost or Discord channels, direct you to helpful resources, and help you get involved in the Open IO community.


Allows you to retrieve information from the 'Google Knowledge Graph' API <https://www.google.com/intl/bn/insidesearch/features/search/knowledge.html> and process it in R in various forms. The 'Knowledge Graph Search' API lets you find entities in the 'Google Knowledge Graph'. The API uses standard 'schema.org' types and is compliant with the 'JSON-LD' specification.
| Version: | 0.1.0 |
| Depends: | jsonlite, curl |
| Published: | 2018-01-15 |
| Author: | Daniel Schmeh |
| Maintainer: | Daniel Schmeh <danielschmeh at gmail.com> |
| License: | MIT + file LICENSE |
| NeedsCompilation: | no |
| CRAN checks: | GoogleKnowledgeGraphR results |
| Reference manual: | GoogleKnowledgeGraphR.pdf |
| Package source: | GoogleKnowledgeGraphR_0.1.0.tar.gz |
| Windows binaries: | r-devel: GoogleKnowledgeGraphR_0.1.0.zip, r-release: GoogleKnowledgeGraphR_0.1.0.zip, r-oldrel: GoogleKnowledgeGraphR_0.1.0.zip |
| OS X binaries: | r-release: GoogleKnowledgeGraphR_0.1.0.tgz, r-oldrel: GoogleKnowledgeGraphR_0.1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=GoogleKnowledgeGraphR to link to this page.


PostgreSQL and NodeJS
Today we’re going to build a CRUD todo single page application with Node, Express, Angular, and PostgreSQL.
Updates:
- 09/25/2016:
- 10/05/2015: Refactored connection handling to fix this issue. For more, view the pull request.
Contents
- Project Setup
- Postgres Setup
- Server-Side: Routes
- Refactoring
- Client-Side: Angular
- View (round four)
- Refactoring (for real)
- Conclusion and next steps
Project Setup
Start by installing the Express generator:
$ npm install -g<EMAIL_ADDRESS>Then create a new project and install the dependencies:
$ express node-postgres-todo
$ cd node-postgres-todo && npm install
Add Supervisor to watch for code changes:
$ npm install<EMAIL_ADDRESS>-g
Update the start
script in the package.json file:
"scripts": {
"start": "supervisor ./bin/www"
},
Run the app:
$ npm start
Then navigate to http://localhost:3000/ in your browser. You should see the “Welcome to Express” text.
Postgres Setup
Need to setup Postgres? On a Mac? Check out Postgres.app.
With your Postgres server up and running on port 5432, making a database connection is easy with the pg library:
$ npm install<EMAIL_ADDRESS>--save
Now let’s set up a simple table creation script:
const pg = require('pg');
const connectionString = process.env.DATABASE_URL || 'postgres://localhost:5432/todo';
const client = new pg.Client(connectionString);
client.connect();
const query = client.query(
'CREATE TABLE items(id SERIAL PRIMARY KEY, text VARCHAR(40) not null, complete BOOLEAN)');
query.on('end', () => { client.end(); });
Save this as database.js in a new folder called “models”.
Here we create a new instance of Client
to interact with the database and then establish communication with it via the connect()
method. We then run a SQL query via the query()
method. Finally, communication is closed via the end()
method. Be sure to check out the documentation for more info.
Make sure you have a database called “todo” created, and then run the script to set up the table and subsequent fields:
$ node models/database.js
Verify the table/schema creation in psql:
$ psql
#\c todo
You are now connected to database "todo" as user "michaelherman".
todo=# \d items
Table "public.items"
Column | Type | Modifiers
----------+-----------------------+----------------------------------------------------
id | integer | not null default nextval('items_id_seq'::regclass)
text | character varying(40) | not null
complete | boolean |
Indexes:
"items_pkey" PRIMARY KEY, btree (id)
todo=#
With the database connection setup along with the “items” table, we can now configure the CRUD portion of our app.
Server-Side: Routes
Let’s keep it simple by adding all endpoints to the index.js file within the “routes” folder. Make sure to update the imports:
const express = require('express');
const router = express.Router();
const pg = require('pg');
const path = require('path');
const connectionString = process.env.DATABASE_URL || 'postgres://localhost:5432/todo';
Now, let’s add each endpoint.
| Function | URL | Action |
|---|---|---|
| CREATE | /api/v1/todos | Create a single todo |
| READ | /api/v1/todos | Get all todos |
| UPDATE | /api/v1/todos/:todo_id | Update a single todo |
| DELETE | /api/v1/todos/:todo_id | Delete a single todo |
Follow along with the inline comments below for an explanation of what’s happening. Also, be sure to check out the pg documentation to learn about connection pooling. How does that differ from pg.Client
?
Create
router.post('/api/v1/todos', (req, res, next) => {
const results = [];
// Grab data from http request
const data = {text: req.body.text, complete: false};
// Get a Postgres client from the connection pool
pg.connect(connectionString, (err, client, done) => {
// Handle connection errors
if(err) {
done();
console.log(err);
return res.status(500).json({success: false, data: err});
}
// SQL Query > Insert Data
client.query('INSERT INTO items(text, complete) values($1, $2)',
[data.text, data.complete]);
// SQL Query > Select Data
const query = client.query('SELECT * FROM items ORDER BY id ASC');
// Stream results back one row at a time
query.on('row', (row) => {
results.push(row);
});
// After all data is returned, close connection and return results
query.on('end', () => {
done();
return res.json(results);
});
});
});
Test this out via Curl in a new terminal window:
$ curl --data "text=test&complete=false" http://<IP_ADDRESS>:3000/api/v1/todos
Then confirm that the data was INSERTed correctly into the database via psql:
todo=# SELECT * FROM items ORDER BY id ASC;
id | text | complete
----+-------+----------
1 | test | f
(1 row)
Read
router.get('/api/v1/todos', (req, res, next) => {
const results = [];
// Get a Postgres client from the connection pool
pg.connect(connectionString, (err, client, done) => {
// Handle connection errors
if(err) {
done();
console.log(err);
return res.status(500).json({success: false, data: err});
}
// SQL Query > Select Data
const query = client.query('SELECT * FROM items ORDER BY id ASC;');
// Stream results back one row at a time
query.on('row', (row) => {
results.push(row);
});
// After all data is returned, close connection and return results
query.on('end', () => {
done();
return res.json(results);
});
});
});
Add a few more rows of data via Curl, and then test the endpoint out in your browser at http://localhost:3000/api/v1/todos. You should see an array of JSON objects:
[
{
id: 1,
text: "test",
complete: false
},
{
id: 2,
text: "test2",
complete: false
},
{
id: 3,
text: "test3",
complete: false
}
]
Update
router.put('/api/v1/todos/:todo_id', (req, res, next) => {
const results = [];
// Grab data from the URL parameters
const id = req.params.todo_id;
// Grab data from http request
const data = {text: req.body.text, complete: req.body.complete};
// Get a Postgres client from the connection pool
pg.connect(connectionString, (err, client, done) => {
// Handle connection errors
if(err) {
done();
console.log(err);
return res.status(500).json({success: false, data: err});
}
// SQL Query > Update Data
client.query('UPDATE items SET text=($1), complete=($2) WHERE id=($3)',
[data.text, data.complete, id]);
// SQL Query > Select Data
const query = client.query("SELECT * FROM items ORDER BY id ASC");
// Stream results back one row at a time
query.on('row', (row) => {
results.push(row);
});
// After all data is returned, close connection and return results
query.on('end', function() {
done();
return res.json(results);
});
});
});
Again, test via Curl:
$ curl -X PUT --data "text=test&complete=true" http://<IP_ADDRESS>:3000/api/v1/todos/1
Navigate to http://localhost:3000/api/v1/todos to make sure the data has been updated correctly.
[
{
id: 1,
text: "test",
complete: true
},
{
id: 2,
text: "test2",
complete: false
},
{
id: 3,
text: "test3",
complete: false
}
]
Delete
router.delete('/api/v1/todos/:todo_id', (req, res, next) => {
const results = [];
// Grab data from the URL parameters
const id = req.params.todo_id;
// Get a Postgres client from the connection pool
pg.connect(connectionString, (err, client, done) => {
// Handle connection errors
if(err) {
done();
console.log(err);
return res.status(500).json({success: false, data: err});
}
// SQL Query > Delete Data
client.query('DELETE FROM items WHERE id=($1)', [id]);
// SQL Query > Select Data
var query = client.query('SELECT * FROM items ORDER BY id ASC');
// Stream results back one row at a time
query.on('row', (row) => {
results.push(row);
});
// After all data is returned, close connection and return results
query.on('end', () => {
done();
return res.json(results);
});
});
});
Final Curl test:
$ curl -X DELETE http://<IP_ADDRESS>:3000/api/v1/todos/3
And you should now have:
[
{
id: 1,
text: "test",
complete: true
},
{
id: 2,
text: "test2",
complete: false
}
]
Refactoring
Before we jump to the client-side to add Angular, be aware that our code should be refactored to address a few issues. We’ll handle this later on in this tutorial, but this is an excellent opportunity to refactor the code on your own. Good luck!
Client-Side: Angular
Let’s dive right in to Angular.
Keep in mind that this is not meant to be an exhaustive tutorial. If you’re new to Angular I suggest following my “AngularJS by Example” tutorial - Building a Bitcoin Investment Calculator.
Module
Create a file called app.js in the “public/javascripts” folder. This file will house our Angular module and controller:
angular.module('nodeTodo', [])
.controller('mainController', ($scope, $http) => {
$scope.formData = {};
$scope.todoData = {};
// Get all todos
$http.get('/api/v1/todos')
.success((data) => {
$scope.todoData = data;
console.log(data);
})
.error((error) => {
console.log('Error: ' + error);
});
});
Here we define our module as well as the controller. Within the controller we are using the $http service to make an AJAX request to the '/api/v1/todos'
endpoint and then updating the scope accordingly.
What else is going on?
Well, we’re injecting the $scope
and $http
services. Also, we’re defining and updating $scope
to handle binding.
Update Main Route
Let’s update the main route in index.js within the “routes” folder:
router.get('/', (req, res, next) => {
res.sendFile('index.html');
});
So when the user hits the main endpoint, we send the index.html file. This file will contain our HTML and Angular templates.
Make sure to add the following dependency as well:
const path = require('path');
View
Now, let’s add our basic Angular view within index.html:
<!DOCTYPE html>

<title>Todo App - with Node + Express + Angular + PostgreSQL</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet" media="screen">

{{ todo.text }}

Add this to the “public” folder.
This should all be straightforward. We bootstrap Angular - ng-app="nodeTodo"
, define the scope of the controller - ng-controller="mainController"
- and then use ng-repeat
to loop through the todoData
object, adding each individual todo to the page.
Module (round two)
Next, let’s update the module to handle the create and delete functions:
// Create a new todo
$scope.createTodo = () => {
$http.post('/api/v1/todos', $scope.formData)
.success((data) => {
$scope.formData = {};
$scope.todoData = data;
console.log(data);
})
.error((error) => {
console.log('Error: ' + error);
});
};
// Delete a todo
$scope.deleteTodo = (todoID) => {
$http.delete('/api/v1/todos/' + todoID)
.success((data) => {
$scope.todoData = data;
console.log(data);
})
.error((data) => {
console.log('Error: ' + data);
});
};
Now, let’s update our view…
View (round two)
Simply update the list item like so:

<input type="checkbox" ng-click="deleteTodo(todo.id)"> {{ todo.text }}

This uses the ng-click
directive to call the deleteTodo()
function that takes a unique id
associated with each todo as an argument.
Test this out. Make sure that when you click a check box the todo is removed.
View (round three)
To handle the creation of a new todo, we need to add an HTML form:

<form>

<input type="text" class="form-control input-lg" placeholder="Add a todo..." ng-model="formData.text">

<button type="submit" class="btn btn-primary btn-lg" ng-click="createTodo()">Add Todo</button>
</form>

<input type="checkbox" ng-click="deleteTodo(todo.id)"> {{ todo.text }}

Again, we use ng-click
to call the createTodo()
function in the controller. Test this out!
View (round four)
With the main functionality done, let’s update the front-end to make it look a bit more presentable.
HTML:
<!DOCTYPE html>

<title>Todo App - with Node + Express + Angular + PostgreSQL</title>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<link href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" rel="stylesheet" media="screen">
<link rel="stylesheet" href="/stylesheets/style.css" media="screen">

Todo App

Node + Express + Angular + PostgreSQL

<form>

<input type="text" class="form-control input-lg" placeholder="Enter text..." ng-model="formData.text">

<button type="submit" class="btn btn-primary btn-lg btn-block" ng-click="createTodo()">Add Todo</button>
</form>

<input class="lead" type="checkbox" ng-click="deleteTodo(todo.id)"> {{ todo.text }}

CSS:
body {
padding: 50px;
font: 14px "Lucida Grande", Helvetica, Arial, sans-serif;
}
a {
color: #00B7FF;
}
ul {
list-style-type: none;
padding-left: 10px;
}
.container {
max-width: 400px;
background-color: #eeeeee;
border: 1px solid black;
}
.header {
text-align: center;
}
How’s that? Not up to par? Continue working on it on your end.
Refactoring (for real)
Now that we added the front-end functionality, let’s update the app structure and refactor parts of the code.
Structure
Since our application is logically split between the client and server, let’s do the same for our project structure. So, make the following changes to your folder structure:
├── app.js
├── bin
│ └── www
├── client
│ ├── javascripts
│ │ └── app.js
│ ├── stylesheets
│ │ └── style.css
│ └── views
│ └── index.html
├── package.json
└── server
├── models
│ └── database.js
└── routes
└── index.js
Now we need to make a few updates to the code:
server/routes/index.js:
router.get('/', (req, res, next) => {
res.sendFile(path.join(
__dirname, '..', '..', 'client', 'views', 'index.html'));
});
app.js:
const express = require('express');
const path = require('path');
const favicon = require('serve-favicon');
const logger = require('morgan');
const cookieParser = require('cookie-parser');
const bodyParser = require('body-parser');
const routes = require('./server/routes/index');
// var users = require('./routes/users');
const app = express();
// view engine setup
// app.set('views', path.join(__dirname, 'views'));
// app.set('view engine', 'html');
// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, 'client')));
app.use('/', routes);
// app.use('/users', users);
// catch 404 and forward to error handler
app.use((req, res, next) => {
var err = new Error('Not Found');
err.status = 404;
next(err);
});
// error handlers
// development error handler
// will print stacktrace
if (app.get('env') === 'development') {
app.use((err, req, res, next) => {
res.status(err.status || 500);
res.json({
message: err.message,
error: err
});
});
}
// production error handler
// no stacktraces leaked to user
app.use((err, req, res, next) => {
res.status(err.status || 500);
res.json({
message: err.message,
error: {}
});
});
module.exports = app;
Utility Function
Did you notice in our routes that we are reusing much of the same code in each of the CRUD functions:
pg.connect(connectionString, (err, client, done) => {
// Handle connection errors
if(err) {
done();
console.log(err);
return res.status(500).json({success: false, data: err});
}
// SQL Query > Select Data
const query = client.query('SELECT * FROM items ORDER BY id ASC;');
// Stream results back one row at a time
query.on('row', (row) => {
results.push(row);
});
// After all data is returned, close connection and return results
query.on('end', () => {
done();
return res.json(results);
});
});
We should abstract that out into a utility function so we’re not duplicating code. Do this on your own, and then post a link to your code in the comments for review.
Conclusion and next steps
That’s it! Since there’s a number of moving pieces here, please review how each piece fits into the overall process and whether each is part of the client or server. Comment below with questions. Grab the code from the repo.
This app is far from finished. What else do we need to do?
- Handle Permissions via passport.js
- Add a task runner - like Gulp
- Test with Mocha and Chai
- Check test coverage with Istanbul
- Add promises
- Use Bower for managing client-side dependencies
- Utilize Angular Routing, form validation, Services, and Templates
- Handle updates (PUT requests)
- Better manage the database layer by adding an ORM - like Sequelize (check out my follow-up post on Node, Postgres, and Sequelize) - and a means of managing migrations
What else? Comment below.


This plugin for Obsidian integrates your academic reference manager with the Obsidian editing experience.
The plugin supports reading bibliographies in BibTeX / BibLaTeX .bib
format and CSL-JSON format.
You can install this plugin via the Obsidian "Third-party plugin interface." It requires Obsidian 0.9.20 or higher.
Once the plugin is installed, you must provide it with a bibliography file:
File
-> Export library ...
. Select Better BibLaTeX
or Better CSL JSON
as the format. (We recommend using the BibLaTeX export unless you experience performance issues. The BibLaTeX format includes more information that you can reference from Obsidian, such as associated PDF attachments, but loads more slowly than the JSON export.)Now open the Obsidian preferences and view the "Citations" tab. Paste the path to the exported file (.bib
or .json
, depending on the format you chose) in the text field labeled "Citation export path." After closing the settings dialog, you should now be able to search your references from within Obsidian!
The plugin offers three simple features at the moment:
MIT License.
Generated using TypeDoc


Foods
Nutritional Assessment
View Detail
or
Create New
#
Name
Times
Quantity
Unit
Advice
#
1
Select
Select
Add


About
The seventh iteration of GunnHacks, Gunn High School's annual hackathon.
Join us from February 13th to 14th for an virtual, 36 hour high school hackathon. Work in teams of up to five to create something amazing. We welcome any high school student with an interest in technology!


We Love Mommy a whole lot
way more than a pot that's hot.
We Love her so much
we love her touch.
Her kisses are sweet
sweeter than feet.
We wish you a great birthday
in every super duper way!


Super Chef
This project is no where near finished - please check back later for more details!
Visit Site View on GithubFull-stack developer
and film score composer
Austin, TX
I'm a full-stack web developer and film composer living in Austin, Texas.
Currently, I work at WP Engine. In my spare time I can be found working on new projects at Github, making new music on Soundcloud, or doing coding challenges on HackerRank.
After graduating from Berklee College of Music, I spent four years living and working in Los Angeles as a film composer, and had the opportunity to work on quite a few interesting projects. While I still enjoy creating music, I am currently focused on my new found passion for programming, software development and the web. You can keep up with my latest work here and read my thoughts on programming and code at my blog.
Thanks for stopping by!
Below you can find details on the projects I am currently working on, along with lnks to their relevant web pages or Github repos.
This project is no where near finished - please check back later for more details!
Visit Site View on GithubA random assortment of interest and hobbies I have, complete with matching Font Awesome icons.
Feel free to drop me a line if you're interested in talking or working todether, or just want to say "Hello!"


---
layout: post
title: Merging PDFs
tags:
- ColdFusion
- coldfusion
- itext
- merge
- pdf
status: publish
type: post
published: true
meta:
_edit_last: '2'
aktt_notify_twitter: 'no'
---
I have just posted two small utility functions to merge PDF documents together for those working in CF. You can view them here . Or inline below.
The first function takes an array of PDF documents and merges them into one. This was handy when different pages for a report had different styling requirements (such a full background colouring bleeding across the margins)
The second function stamps a pdf document over another pdf document at certain position. I needed this for a document that had a table dynamically generated that spanned multiple pages and I wanted the footer to not overlap the table content (I could not figure out how to use a css based solution because of the margins).
Anyway maybe somebody else will find these handy.


Configs for general code style.
- Line Separators:
IntelliJ IDEA lets you configure line separator and indentation options for various
languages. When reformatting
source code, IntelliJ IDEA will apply the specified indentation behavior and skip the sections denoted
with the special formatting off/on markers.
- Indents detection
- EditorConfig:
In this area enable the support of the EditorConfig plugin.


UK Labour Party hit by second cyber attack in 24 hours
by By Press AssociationLabour has suffered a second cyber attack on its digital platforms within the space of 24 hours, the party said.
A party spokeswoman said the latest distributed denial-of-service (DDoS) incident was being dealt with “quickly and efficiently”.
Earlier, leader Jeremy Corbyn expressed concern after the party experienced what it described as a “sophisticated and large scale” DDoS attack on Monday.
However, PA understands it was a relatively “low level” attack.
The National Cyber Security Centre confirmed it would not be investigating the matter further, while a source said there was no evidence of “state-sponsored activity”.
DDoS attacks – where hackers flood a target’s online platforms with traffic from various sources, causing them to slow or crash – are considered relatively common.
Following the latest incident, a Labour spokeswoman said: “We have ongoing security processes in place to protect our platforms, so users may be experiencing some differences.
“We are dealing with this quickly and efficiently.”
If this is a sign of things to come in this election, I feel very nervous about it all
Speaking at a campaign event in Blackpool following the first incident, Mr Corbyn said he was “nervous” about what it could mean for the rest of the General Election campaign.
“We have a system in place in our office to protect us against these cyber attacks, but it was a very serious attack against us,” he said.
“So far as we’re aware, none of our information was downloaded and the attack was actually repulsed because we have an effective in-house developed system by people within our party.
“But if this is a sign of things to come in this election, I feel very nervous about it all because a cyber attack against a political party in an election is suspicious, something one is very worried about.”


---
title: Pupil Player Release
description: >
Pupil Labs software release
created: !!timestamp '2014-02-20 11:00:00'
author: Pupil Dev Team
---
{% mark excerpt -%}
{%- endmark %}
{% mark body -%}
## Pupil Player
We would like to introduce a new app for Pupil - **Pupil Player** - With this application we've finally added the crucial missing part of the toolchain. You can now visualize Pupil Capture recordings after the fact using the app with GUI.
Take a look at the demo screencast.
### Features
Currently implemented:
+ A seek bar
+ Scan Path
+ Different methods of gaze visualization
+ Offline marker based surface tracker
+ Exporter
Expect more features to follow in the coming weeks!
### Platform for offline processing
Pupil Player uses the plugin system found in Pupil Capture. This allows developers and contributors to roll their own awesome new ideas into Pupil. Currently we have a few simple Visualizations but more powerful plugins are in the Pipeline!
### Exporting
The current visualization plugins support exporting. Using the app you can export all or just sections of the recording with a visualization in the background. Multiple exports can be processed simultaneously while you continue to browse though the video and try out different visualization methods!
## Bundles
Unfortunately, only the Linux bundles are available. Mac and Windows will work running from source.
## User Guide
We have added Pupil Player to the user guide on github. [Check it out](https://github.com/pupil-labs/pupil/wiki/Pupil-Player).
As always. This is very fresh code. Please try it out and and give us feedback on the [Pupil Google Group](http://groups.google.com/group/pupil-discuss)!
{%- endmark %}


Your new package is there! You can edit the package properties in the package manager. Use the edit button in the upper right corner of the package details panel to open the package editor.
Here is what you should do:
Of course, the most interesting thing is how to edit the technology definition. When the package was initialized, a folder hierarchy consisting of a tech folder containing a technology definition file and empty "libraries", "macros", "pymacros" and "drc" folders was created. You can use these empty folders to put your own files there. The technology definition can be edited in the technology manager where you can find the technology as "new_tech" under the name you had given the package. Initially, the technology definition is without any particular definitions.
In the package details you will find the local path to your package data under "Installation". You can use any versioning system to manage your files there.
Once you have finished your package, don't forget to specify the package version so users of you package will be informed of updates. Finally you can publish the package files to a place of your choice and submit the download URL to the Salt Mine server.


@(uuid: String) @layout(title = "Spark Streaming", appName = "spark") { Spark Streaming Counts By Geo CO CA FL HI NY Count By Average Bid Logs Raw Logs {{rawCount | number : 0 }} By Pub and Geo {{pubGeoCount | number : 0 }} MongoDB {{mongoCount | number : 0 }} }
{{rawCount | number : 0 }}
{{pubGeoCount | number : 0 }}
{{mongoCount | number : 0 }}


|
SignalK-Orientation
0.1.3
Orientation output in Signal K format for ESP8266 and ESP32
|
A template specialization of SKOutput:: for sending attitude values to the Signal K server. More...
#include <signalk_output.h>
Public Member Functions | |
| SKOutput (String sk_path, String config_path="", SKMetadata *meta=NULL) | |
| The constructor. More... | |
| SKOutput (String sk_path, SKMetadata *meta) | |
| virtual void | set_input (Attitude new_value, uint8_t input_channel=0) override |
| virtual String | as_signalk () override |
| virtual void | get_configuration (JsonObject &root) override |
| String | get_config_schema () override |
| virtual bool | set_configuration (const JsonObject &config) override |
| virtual void | set_metadata (SKMetadata *meta) |
| virtual SKMetadata * | get_metadata () override |
Protected Attributes | |
| SKMetadata * | meta_ |
A template specialization of SKOutput:: for sending attitude values to the Signal K server.
When SKOutput is called with the output variable of type struct Attitude, the overridden as_signalk() method writes the three attitude values (yaw, pitch, roll) contained in the struct.
|
inline |
The constructor.
| sk_path | The Signal K path the output value is sent on. |
| config_path | The optional configuration path that allows an end user to change the configuration of this object. See the Configurable class for more information. |
| meta | Optional metadata that is associated with the value output by this class. A value specified here will cause the path's metadata to be emitted on the first delta sent to the server. Use NULL if this path has no metadata to report, or if the path is already an official part of the Signal K specification. |
Show that valid values are not available. The Signal K spec indicates this is done by sending a JSON null for the value key. Note that this is not the same as an empty string, the string "null", or the value 0, which one gets by value["yaw"] = "" or "null" or NULL, respectively.
Used to set the optional metadata that is associated with the Signal K path this transform emits. This is a second method of setting the metadata (the first being a parameter to the constructor). Note that since an Attitude consisting of yaw, pitch and roll in radians is defined in the Signal K spec, usually we would not send metadata.


Test of positioning with Bootstrap popovers.
Click through them and make sure they work as expected
This is the target


Whether to show a notification when a new song starts.
Show Tidal-hifi's menu bar
Show Tidal-hifi's tray icon
Enables extra hotkeys to achieve feature parity with the desktop apps
Tidal-hifi has a web api built in to allow users to get current song information. You can optionally enable playback control as well.
Whether to enable the Tidal-hifi web api
Whether to enable playback control from the api
Tidal-hifi is extensible trough the use of integrations. You can enable or disable integrations here
Whether to enable the mpris media player controls for Linux systems
Show what you're listening to on Discord
Tidal-hifi is made by Rick van Lieshout.
It uses castlabs versions of Electron for widevine support.


CellDesigner Walkthrough¶
The following is a walkthrough of how to produce Systems Biology Markup Language (SBML) files that are compatible with CRNT4SBML. The SBML file is a machine-readable format for representing biological models. Our preferred approach to constructing this file is by using CellDesigner. CellDesigner is a structured diagram editor for drawing gene-regulatory and biochemical networks. CellDesigner is a freely available software and can be downloaded by visiting celldesigner.org . Although creating this SBML file may be achievable by other means, use of CellDesigner is the only approach that has been verified to work well with the provided code. Extreme caution should be used if the user wishes to use an already established SBML file or another software that produces an SBML file. We will continue by demonstrating how to represent the C-graph of Figure 1C from [OMYS17] (provided below) for both mass conserving and semi-diffusive networks in CellDesigner. For this demonstration we will be using version 4.4.2 of CellDesigner on a Mac.
Creating a Species¶
To begin, launch CellDesigner and create a new document. The following new document box will then appear. The name provided in this box can be set to anything the user desires and a specific name is not required. In addition to a name, this box also asks for the dimension of white space available in the workspace. The default width of 600 and height of 400 will be appropriate for most small networks.
Once the workspace has been created, the species of the network can be represented in CellDesigner by creating a generic protein, which can be found in the top toolbar (as pictured below) by hovering over the symbols.
After the generic protein symbol is selected click on the workspace to create a species. A box will then appear and ask for the species name. Although no specific name is required, for visual purposes it is suggested to use a name that is similar to the name used in the C-graph. Below we have created the species and of the provided C-graph using generic proteins.
Although regular species are sufficient enough to represent a C-graph, it may also be useful to specify if a particular species is phosphorylated. This can be done by selecting the “Add/Edit Residue Modification” symbol in the top toolbar. A box will then appear and the up and down arrows can be used to select “phosphorylated”. After pressing ok, a species can be phosphorylated by hovering over the generic protein and selecting one of the dots on the outline of the protein. One can tell if the species is phosphorylated by noticing if there is a circle with a “P” in the middle. Below we have a species where the generic protein on the left is not phosphorylated and the generic protein on the right is phosphorylated.
In addition to creating species we can also create chemical complexes as in the C-graph. To do this, in the top toolbox select the symbol “Complex” and click in the workspace, again a specific name is not required, but it is encouraged. One can then place species within this complex using the generic protein approach outlined above. Below is the CellDesigner representation of complex .
Creating a Reaction¶
In CellDesigner there are three types of reactions that are important when recreating a C-graph: State Transition , Heterodimer Association , and Dissociation . We will first demonstrate Heterodimer Association and Dissociation reactions by creating reactions and of the C-graph. We will then address State Transition reactions by creating . To create reactions and , first create species and , in addition to complex . Then using the top toolbox select “Heterodimer Association” and first select the two species and (order of selection does not matter) then select the complex . This concludes the creation of , and the CellDesigner depiction should be similar to the picture provided below.
To create we need to make the heterodimer reaction reversible. To make a reaction reversible right click the reaction and select “Change Identity…”, then select True under the reversible category. This provides the CellDesigner representation of and as provided below.
Now we create reaction using a dissociation reaction. To do this, select “Dissociation” and first select the complex and then select the species and phosphorylated species (the order of selection of the species does not matter). This provides the CellDesigner representation of below.
The last type of reaction we will consider is a State Transition, to do this we will produce reaction . After creating complex , we create reaction by selecting “State Transition” and first click the complex and then the phosphorylated species . Although we have created a reaction we have not created exactly yet. We have not accounted for the fact that two molecules of the phosphorylated species are produced. To specify this in CellDesigner right click the reaction and select “Edit Reaction….”, this opens the following box.
In this box one can then specify the stoichiometry of the reactants and products of the reaction. Note that the species are defined in terms of the species id, rather than the name that the user provided. To obtain the species id one can hover over a species or complex in the workspace, or one can see a list of the species by viewing the bottom box in CellDesigner and selecting the “Species” tab, an example of this box can be seen below.
In the reaction box produced by selecting “Edit Reaction….”, we can specify that two molecules of phosphorylated species are produced by selecting the “listOfProducts” tab then clicking the species corresponding to the phosphorylated species and then selecting Edit and changing stoichiometry to 2.0. We can confirm this change by choosing Update. A similar process can be completed if you want to change the number of molecules of any species in the reactants, but in this case one would instead choose the “listOfReactants” tab.
Representing Catalysis¶
Another useful feature that has been implemented in crnt4sbml is the ability to represent catalysis. In CellDesigner catalysis is fairly straightforward to implement and can often lead to simpler looking diagrams. If we consider the C-graph provided, one can see that the reactions and depict catalysis, where is the catalyst. To represent this in CellDesigner, we first create the species and phosphorylated species . Once these species are created, we then construct a State Transition from species to the phosphorylated species . Note that the State Transition cannot be reversible. We can now specify catalysis, which is represented in CellDesigner as the symbol , by selecting the symbol for catalysis, selecting species and then clicking on the square box of the State Transition. If these steps are followed, the following CellDesigner layout should be produced:
When parsing this type of SBML file, crnt4sbml will construct the underlying C-graph appropriately. For example, if we say the species is given by species id ‘s1’, phosphorylated species by species id ‘s2’, and species by species id ‘s3’, then crnt4sbml will construct the following reactions s1+s3 -> s3s1, s3s1 -> s1+s3, and s3s1 -> s2+s3. These reactions will then have the reaction labels ‘re1f’, ‘re1d’, and ‘re1c’, respectively, specifying complex formation, complex dissociation, and catalysis, respectively, when referenced in crnt4sbml.
In addition to this type of catalysis, we also allow for catalysis involving a complex dissociation reaction. However, we do not allow for catalysis involving a complex formation reaction. Below we depict these two scenarios.
Basic Mass Conservation SBML File¶
Using the tools we have outlined so far, we can represent the mass conservation portion of the provided C-graph using CellDesigner. One particular layout of this CellDesigner representation can be seen below. In this diagram we have manipulated the shape of the reactions by right clicking them and choosing “Add Anchor Point”. Note that when saving the CellDesigner diagram, it will be saved as an xml file, this is an xml file with the layout of an SBML file. At this point no conversion to SBML is necessary and the xml file produced can be imported into the code.
Catalysis Mass Conservation SBML File¶
Although the CellDesigner layout produced above is perfectly fine, it may become congested especially if more reactions and species are added. In this case, it may be beneficial to represent particular groups of reactions as catalysis instead. Using the guidelines established in the sections above, we can construct the mass conservation portion of the C-graph as follows in CellDesigner.
Adding Inflow and Outflow¶
In a semi-diffusive network we consider the degradation and formation of a species and we have to consider how to implement a source and a sink in the SBML file. Here a source is a node providing an inflow of a species and a sink is an outflow of a species. To do this, we will pick one species to be a boundary species in CellDesigner, for graphical purposes we will use the degradation symbol in CellDesigner (i.e. ). This symbol will serve as a sink, source, or both a sink and a source. This usage will prevent unnecessary clutter and make it simpler to create SBML files for semi-diffusive networks. One very important thing to note here is that the user must specify that this species is a boundary species! If the user does not do this then the sink/source will be considered as a normal species, this will create incorrect results and will not allow the semi-diffusive approach to be constructed. To create a boundary species right click the “Degraded” symbol in the top toolbox and then click in the workspace. At this point the item produced is just a species, although its appearance differs from a species or a complex. To make this species a source/sink right click the created item and choose “Edit species”, the box provided below should appear.
In this box set boundaryCondition to true and choose “Update” to confirm the change. One last word of caution: according to the semi-diffusive approach if there is formation of a species there must also be degradation of that species. However, one can allow for just degradation of a species.
Semi-diffusive SBML File¶
Using the inflow and outflow convention, and the ideas established in the previous subsections, we can recreate the semi-diffusive portion of the provided C-graph using CellDesigner. One possible layout of this C-graph in CellDesigner is provided below.


CrossFit is the principal strength and conditioning program for many police academies and tactical operations teams, military special operations units, champion martial artists, and hundreds of other elite and professional athletes worldwide.
Our program delivers a fitness that is, by design, broad, general, and inclusive. Our specialty is not specializing. Combat, survival, many sports, and life reward this kind of fitness and, on average, punish the specialist.
The CrossFit program is designed for universal scalability making it the perfect application for any committed individual regardless of experience. We’ve used our same routines for elderly individuals with heart disease and cage fighters one month out from televised bouts. We scale load and intensity; we don’t change programs.
CrossFit is a core strength and conditioning program. We have designed our program to elicit as broad an adaptation response as possible. CrossFit is not a specialized fitness program but a deliberate attempt to optimize physical competence in each of ten recognized fitness domains. They are Cardiovascular and Respiratory endurance, Stamina, Strength, Flexibility, Power, Speed, Coordination, Agility, Balance, and Accuracy.
The CrossFit Program was developed to enhance an individual’s competency at all physical tasks. Our athletes are trained to perform successfully at multiple, diverse, and randomized physical challenges. This fitness is demanded of military and police personnel, firefighters, and many sports requiring total or complete physical prowess. CrossFit has proven effective in these arenas.
Aside from the breadth or totality of fitness the CrossFit Program seeks, our program is distinctive, if not unique, in its focus on maximizing neuroendocrine response, developing power, cross-training with multiple training modalities, constant training and practice with functional movements, and the development of successful diet strategies.
We train our athletes in gymnastics from rudimentary to advanced movements garnering great capacity at controlling the body both dynamically and statically while maximizing strength to weight ratio and flexibility. We also place a heavy emphasis on Olympic Weightlifting having seen this sport’s unique ability to develop an athletes’ explosive power, control of external objects, and mastery of critical motor recruitment patterns. And finally we encourage and assist our athletes to explore a variety of sports as a vehicle to express and apply their fitness.
The CrossFit method is to establish a hierarchy of effort and concern that builds as follows:
Diet
A proper diet lays the molecular foundations for fitness and health.
Metabolic Conditioning
This builds capacity in each of three metabolic pathways, beginning with aerobic, then lactic acid, and then phosphocreatine pathways.
Gymnastics
Establishes functional capacity for body control and range of motion.
Weightlifting and Throwing
Develop ability to control external objects and produce power.
Sport
Applies fitness in competitive atmosphere with more randomized movements and skill mastery.
Absolutely! Your needs and the Olympic athlete’s differ by degree not kind. Increased power, strength, cardiovascular and respiratory endurance, flexibility, stamina, coordination, agility, balance, and coordination are each important to the world’s best athletes and to our grandparents.
The amazing truth is that the very same methods that elicit optimal response in the Olympic or professional athlete will optimize the same response in the elderly. Of course, we can’t load your grandmother with the same squatting weight that we’d assign an Olympic skier, but they both need to squat. In fact, squatting is essential to maintaining functional independence and improving fitness.
Squatting is just one example of a movement that is universally valuable and essential yet rarely taught to any but the most advanced of athletes. This is a tragedy. Through painstakingly thorough coaching and incremental load assignment CrossFit has been able to teach anyone who can care for themselves to perform safely and with maximum efficacy the same movements typically utilized by professional coaches in elite and certainly exclusive environments.
There isn’t a strength and conditioning program anywhere that works with a greater diversity of tools, modalities, and drill. Here's some examples of the exercises we utilize:
It is a common sentiment to feel that because of the obligations of career and family that you don’t have the time to become as fit as you might like. Here’s the good news: world class, age group strength and conditioning is obtainable through just an hour a day six days per week of training.
It turns out that the intensity of training that optimizes physical conditioning is not sustainable past forty-five minutes to an hour. Athletes that train for hours a day are developing skill or training for sports that include adaptations inconsistent with elite strength and conditioning. Past one hour, more is not better!
Nutrition plays a vital part in fitness and overall health. Here's the CrossFit dietary prescription:
Protein
Protein should be lean and varied and account for about 30% of your total caloric load.
Carbohydrates
Carbohydrates should be predominantly low-glycemic and account for about 40% of your total caloric load.

Calories
Calories should be set at between .7 and 1.0 grams of protein per pound of lean body mass depending on your activity level. The .7 figure is for moderate daily workout loads and the 1.0 figure is for the hardcore athlete.


Type Definitions
BattleriteConfig
Options used to configure the Battlerite module.
Type:
- Object
Properties:
| Name | Type | Description |
|---|---|---|
key |
String | Your API key. you can get one at the developer portal |
- Source:
MatchFilterOptions
Match Filter options
Type:
- Object
Properties:
| Name | Type | Description |
|---|---|---|
createdAt-start |
String | start time of the matches retrieved. format is iso8601. |
createdAt-end |
String | end time of the matches retrieved. format is iso8601. |
playerIds |
String | Array.<String> | Filters by player ID. Can be a string of comma-separated IDs or an array of IDs. |
MatchListOptions
Options available while retrieving a list of matches.
Type:
- Object
Properties:
| Name | Type | Default | Description |
|---|---|---|---|
page |
PageOptions | pagination options | |
sort |
String | "createdAt" | tells how matches should be sorted. |
filter |
MatchFilterOptions | Filter options. |
PageOptions
Pagination options
Type:
- Object
Properties:
| Name | Type | Description |
|---|---|---|
offset |
number | the match offset to start from. Alolws paging over results. |
limit |
number | limits the number of matches retureved. The default (and current maximum) is 5. Values less than 5 and greater than 1 are supported. |
PlayerFilterOptions
Player Filter options
Type:
- Object
Properties:
| Name | Type | Description |
|---|---|---|
playerIds |
String | Array.<String> | Filters by player ID. Can be a string of comma-separated IDs or an array of IDs. |
playerNames |
String | Array.<String> | Filters by player name. Can be a string of comma-separated IDs or an array of names. |
steamIds |
String | Array.<String> | Filters by player steam ID. Can be a string of comma-separated IDs or an array of steam IDs. |
PlayerListOptions
Options available while retrieving a list of players.
Type:
- Object
Properties:
| Name | Type | Description |
|---|---|---|
filter |
PlayerFilterOptions | Filter options. |
TeamListOptions
Options available while retrieving a list of teams.
Type:
- Object
Properties:
| Name | Type | Description |
|---|---|---|
filter |
TeamTagOptions | required tag options. |
TeamTagOptions
Team Tag options - required parameters for retrieving a list of teams
Type:
- Object
Properties:
| Name | Type | Description |
|---|---|---|
playerIds |
String | Array.<String> | The identifiers of the team's players. Can be a string of comma-separated IDs or an array of IDs. |
season |
number | the number of the season the team played. |


max_depth |
-d
<int>
--depth <int> |
Maximum number of generation steps before returning a single node. |
max_nodes |
-n
<int>
--max-nodes <int> |
Maximum number of nodes to produce. Actual number produced will always be somewhat larger. |
dot_output_file |
-do
<file>
|
Output file for .dot representation of the graph. |
probability_link |
-pl
<float>
|
Probability of growing a link for a generative step. |
probability_split |
-ps
<float>
|
Probability of splitting for a generative step. |
probability_read |
-pr
<float>
|
Probability of a node being a read. |
probability_write |
-pw
<float>
|
Probability of a node being a write. |
boogie_output_file |
-bo
<file>
|
Output file for boogie generated code. |
seed |
-s
<int>
--seed <int> |
The seed used for random number generation. |


2 references to PSDataStreams
System.Management.Automation (2)
engine\hostifaces\PowerShell.cs (2)
640
Streams = new
PSDataStreams
(this);
694
Streams = new
PSDataStreams
(this);


This Template is responsible for creating a table of domain objects.
If you modify this template, do not forget to change the overwrite settings
in /Configuration/ExtensionBuilder/settings.yaml:
Resources:
Private:
Templates:
List.html: keep
Otherwise your changes will be overwritten the next time you save the extension in the extension builder
Listing for Calendar
|
|
|
|
|
|
|
| {calendar.id} |
{calendar.summary} |
{calendar.description} |
{calendar.location} |
{calendar.timeZone} |
Edit |
Delete |
New Calendar


top
|
up
| prev |
next
BackendSelector Struct
Definition at line
59
of
Main.cpp
Constructors
BackendSelector
(
BackEnd
backend)
Constructor Details
BackendSelector Constructor
BackendSelector::BackendSelector(
BackEnd
backend)
Definition at line
61
of
Main.cpp
top
|
up
| prev |
next


This version mainly makes a lot of improvements to the Cuda project, and adds support for lex/yacc compilation.
It also adds custom support for link phases such as on_link
, before_link
and after_link
to the target.
Here, I would also like to thank @OpportunityLiu for support for xmake. In this version OpportunityLiu contributed a lot of code to Improve Cuda support. In addition, he helped improve xmake’s entire unit testing framework, self-updating programs, command line tab completions, and ci scripts to make xmake’s update iterations more efficient and stable.
Introduction of new features
Improve to build Cuda project
Header file dependency detection and incremental compilation
Prior to 2.2.6, the compiler support for cuda was not perfect. At least the header file dependency detection was not provided. Therefore, if there is more cuda code, every change will compile all, not like c/c++ code. Do it to detect changes and perform incremental compilation.
In the new version, xmake has supported it, and now it is very good to handle dependencies on different platforms, which will improve the efficiency of daily compilation and development.
Add gencodes api
In the previous version, adding gencodes configuration was very cumbersome and not concise. You can look at the previous configuration:
target("cuda_console")
set_kind("binary")
add_files("src/*.cu")
add_cuflags("-gencode arch=compute_30,code=sm_30", "-gencode arch=compute_35,code=sm_35")
add_cuflags("-gencode arch=compute_37,code=sm_37", "-gencode arch=compute_50,code=sm_50")
add_cuflags("-gencode arch=compute_52,code=sm_52", "-gencode arch=compute_60,code=sm_60")
add_cuflags("-gencode arch=compute_61,code=sm_61", "-gencode arch=compute_70,code=sm_70")
add_cuflags("-gencode arch=compute_70,code=compute_70")
add_ldflags("-gencode arch=compute_30,code=sm_30", "-gencode arch=compute_35,code=sm_35")
add_ldflags("-gencode arch=compute_37,code=sm_37", "-gencode arch=compute_50,code=sm_50")
add_ldflags("-gencode arch=compute_52,code=sm_52", "-gencode arch=compute_60,code=sm_60")
add_ldflags("-gencode arch=compute_61,code=sm_61", "-gencode arch=compute_70,code=sm_70")
add_ldflags("-gencode arch=compute_70,code=compute_70")
Therefore, in order to streamline the configuration of xmake.lua, the add_cugencodes
api added to the cuda project is used to simplify the configuration. The improvements are as follows:
target("cuda_console")
set_kind("binary")
add_files("src/*.cu")
-- generate SASS code for each SM architecture
add_cugencodes("sm_30", "sm_35", "sm_37", "sm_50", "sm_52", "sm_60", "sm_61", "sm_70")
-- generate PTX code from the highest SM architecture to guarantee forward-compatibility
add_cugencodes("compute_70")
In addition, when configured as add_cugencodes("native")
, xmake will automatically detect the gencodes supported by the current device, which will be added automatically, which is more convenient and efficient.
This, thanks to the probe code provided by [OpportunityLiu] (https://github.com/OpportunityLiu) and the implementation of add_cugencodes
.
Support device link for cuda
In the new version, xmake basically refactors the entire cuda build process, extracting the cuda-related builds to a separate cuda build rule for maintenance, and by default uses the device-link link.
For the description and benefits of device-link, please refer to the relevant official introduction: https://devblogs.nvidia.com/separate-compilation-linking-cuda-device-code/
We also need devlink when compiling calls that contain __global__
or __device__
functions that cross compiler units, so in xmake, devlink is currently enabled by default.
For the user, there is no need to make any changes to xmake.lua. Of course, if the user wants to disable devlink manually, it is also possible:
target("test")
set_kind("binary")
add_files("src/*.cu")
add_values("cuda.devlink", false) -- explicitly disable the default device-link behavior
Support for compiling cuda projects with clang
Clang currently supports compilation of *.cu files, but clan versions supported by different versions of clang have certain limitations. Clang7 can only support cuda7-9.2, 8 supports up to 10, and clan9 is required to support 10.1.
In addition to supporting nvcc to compile cuda projects, xmake can also be compiled directly into clang, for example:
xmake f --cu=clang
xmake
However, regarding devlink, it seems that you still need to rely on nvcc, clang does not support it.
Switch c++ compiler for nvcc
xmake added the --cu-ccbin=
parameter to configure the switch. The nvcc defaults to the c++ compiler and linker. The usage is as follows:
xmake f --cu-ccbin=clang++
xmake
Let nvcc call the clang++ compiler internally when compiling cuda code.
Custom the linking process
In the new version, we have added customization processing related to the link link phase. Users can extend their own link process by implementing on_link
, before_link
and after_link
in target/rule.
For example, we want to pre-process some other things before the link phase of normal c/c++ code, such as doing something about *.o files, then we can write our own lua script in the before_link stage:
target("test")
before_link(function (target)
print("process objects", target:objectfiles())
end)
Or we want to rewrite the built-in link process, you can use on_link
:
target("test")
on_link(function (target)
print("link objects", target:objectfiles())
end)
And after_link
is to do some customization tasks after the link is completed.
support Lex/Yacc Compilation
Currently xmake can natively support lex/flex, yacc/bison, etc. to compile and process .l/.y files to quickly develop some compiler-related projects.
We only need to add lex, yacc two rules to the target, so that it can handle .l/.y files normally, of course .ll/.yy is also supported.
target("calc")
set_kind("binary")
add_rules("lex", "yacc")
add_files("src/*.l", "src/*.y")
Here is an example code for reference: lex_yacc_example
Improve to set run environments
Setting the running directory
We can use the set_rundir
interface to set the current running directory of the default running target program. If not set, by default, the target is loaded and run in the directory where the executable file is located.
If the user wants to modify the load directory, one is to customize the run logic by on_run()
, and to do the switch inside, but just to cut the directory, this is too cumbersome.
Therefore, you can quickly switch settings to the default directory environment through this interface.
target("test")
set_kind("binary")
add_files("src/*.c")
set_rundir("$(projectdir)/xxx")
Adding the environment variables
Another new interface, add_runenvs
, can be used to add environment variables that set the default run target program.
target("test")
set_kind("binary")
add_files("src/*.c")
add_runenvs("PATH", "/tmp/bin", "xxx/bin")
add_runenvs("NAME", "value")
Support Command line tab completion
In order to improve the user experience, the new version also supports the xmake command parameter tab completion under the command line. The user can conveniently and quickly tab out all the command parameters of xmake.
Currently supports zsh/bash/sh and powershell.
More convenient self-updating commands
In previous versions, xmake had provided a convenient self-updating command xmake update
to update xmake’s own version, or even to update the specified branch version, for example: xmake update dev/master
However, there are still some shortcomings:
- Every time you update, you need to recompile the core, so the update is very slow. However, in many cases, the new version only has script changes, and the core does not change.
- Update the specified dev/master branch, which is not perfect on Windows, a little lagging, and can’t be instantly synced to the online dev/master version.
Therefore, this OpportunityLiu has helped a lot of improvements:
- Provide the
xmake update -s/--scriptonly
parameter, just update the lua script, do not compile the core extra, and implement a fast iterative update. - Improve ci script, implement ci automation build on windows,
xmake update dev
automatically pulls pre-built installation package to download update on ci - You can specify to update xmake from other github repos, so that contributors can update their fork version, and also switch users to repo,
xmake update gitee:tboox/xmake
Changelogs
New features
- #440: Add
set_rundir()
andadd_runenvs()
api for target/run - #443: Add tab completion support
- Add
on_link
,before_link
andafter_link
for rule and target - #190: Add
add_rules("lex", "yacc")
rules to support lex/yacc projects
Changes
- #430: Add
add_cucodegens()
api to improve set codegen for cuda - #432: support deps analyze for cu file
- #437: Support explict git source for xmake update,
xmake update github:xmake-io/xmake#dev
- #438: Support to only update scripts,
xmake update --scriptonly dev
- #433: Improve cuda to support device-link
- #442: Improve test library


WCRTOMB
Section: Linux Programmer's Manual (3)
Updated: 2014-03-18
Index
Return to Main Contents
NAME
wcrtomb - convert a wide character to a multibyte sequence
SYNOPSIS
#include <wchar.h>
size_t wcrtomb(char *s, wchar_t wc, mbstate_t *ps);
DESCRIPTION
The main case for this function is when
s
is
not NULL and
wc
is not a null wide character (L'\0').
In this case, the
wcrtomb()
function
converts the wide character
wc
to its multibyte representation and stores it
at the beginning of the character
array pointed to by
s.
It updates the shift state
*ps,
and
returns the length of said multibyte representation,
that is, the number of bytes
written at
s.
A different case is when
s
is not NULL,
but
wc
is a null wide character (L'\0').
In this case, the
wcrtomb()
function stores at
the character array pointed to by
s
the shift sequence needed to
bring
*ps
back to the initial state,
followed by a '\0' byte.
It updates the shift state
*ps
(i.e., brings
it into the initial state),
and returns the length of the shift sequence plus
one, that is, the number of bytes written at
s.
A third case is when
s
is NULL.
In this case,
wc
is ignored,
and the function effectively returns
wcrtomb(buf, L'\0', ps)
where
buf
is an internal anonymous buffer.
In all of the above cases, if
ps
is NULL, a static anonymous
state known only to the
wcrtomb()
function is used instead.
RETURN VALUE
The
wcrtomb()
function returns the number of
bytes that have been or would
have been written to the byte array at
s.
If
wc
can not be
represented as a multibyte sequence (according to the current locale),
(size_t) -1
is returned, and
errno
set to
EILSEQ.
CONFORMING TO
C99.
NOTES
The behavior of
wcrtomb()
depends on the
LC_CTYPE
category of the
current locale.
Passing NULL as
ps
is not multithread safe.
SEE ALSO
mbsinit(3),
wcsrtombs(3)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- RETURN VALUE
-
- CONFORMING TO
-
- NOTES
-
- SEE ALSO
-
This document was created by
man2html,
using the manual pages.
Time: 02:54:55 GMT, September 18, 2014


README
ConnectionException
DarkSky
Alert
DataBlock
DataPoint
Flags
Forecast
Languages
Units
class
ConnectionException
ConnectionException
Exception
Reference
Object
Defined in:
exceptions/connection_exception.cr
Constructors
.new
(response, url)
Constructor Detail
def self.
new
(response, url)
#
[
View source
]