HSCN connectivity FAQs
General
What is HSCN?
The Health and Social Care Network (HSCN) is designed to provide a solution for hospitals, medical centres and GPs to collaborate and access services over a secure, high-speed network. It enables third-party software solutions to be presented to front-line patient care organisations. It's a government network like the PSN, but specifically designed for the health and social care community.
Can I use UKCloud's HSCN connection without using UKCloud's cloud services?
No. We can provide an HSCN connection only to customers who use our cloud services, such as our Infrastructure as a Service (IaaS) or Platform as a Service (PaaS) offerings.
Does UKCloud provide local connections to the HSCN network?
No. We can't arrange HSCN connections to third party offices. We only enable our customers and partners to provide services via the HSCN, using applications and solutions hosted on the UKCloud cloud platform.
Do you have any answers to general connectivity questions?
You can find information about other connectivity methods and answers to general connectivity questions in the General connectivity FAQs document on the UKCloud Portal.
How do I get an HSCN connection from UKCloud?
You must sign up to the terms of the HSCN Connection Agreement before you can have access to the HSCN: https://digital.nhs.uk/services/health-and-social-care-network/new-to-hscn/connecting-to-hscn
If you think you have signed the Connection Agreement, go to https://crm.digital.nhs.uk/hscnconnectionagreementsearch/ and search either using your Organisation name or ODS code
If you haven't yet received an invitation to complete your Connection Agreement, please contact<EMAIL_ADDRESS>to request access to their online portal
Once you have access to the NHS Digital online portal, sign and submit your Connection Agreement to NHS Digital
Alternatively, you can request a new UKCloud Master Services Agreement (MSA v11.0) which contains the flow-down of the HSCN Connection Agreement terms. If you sign and submit this, then you are automatically signing up to the terms of the Connection Agreement, and do not need to sign a separate Connection Agreement with NHS Digital. If you would like to sign the MSAv11.0 then please contact your Account Manager.
UKCloud will validate that you have signed up to the terms of the HSCN Connection Agreement before connecting you to HSCN.
What is UKCloud's ODS code?
The UKCloud ODS code is 8J561.
You can find all ODS and connection agreements at https://crm.digital.nhs.uk/hscnconnectionagreementsearch/.
UKCloud are not on NHS Digital's CN-SP list. Can you provide HSCN?
UKCloud doesn't appear on the NHS Digital list of HSCN Consumer Network Service Providers (CN-SPs) as we are not a connectivity service provider in the same way as BT, Vodafone, Redcentric are, as we cannot provide 'cables in the ground' for consumers of HSCN. We are a Cloud Service Provider (CSP), which means we can allow customers to share our HSCN link as long as they have an ODS code, a valid DSP Toolkit, are signed up to the terms in the HSCN Connection Agreement and are consuming one of our value-add services, such as our VMware or OpenStack IaaS or our Virtual Desktop services. We can provide more information about this on request.
Service
Can UKCloud accept dedicated HSCN connections?
Yes. Our HybridConnect service option enables customers and partners to provide their own private circuits, including dedicated HSCN connections. If you want a dedicated HSCN connection to our cloud platform, our team can arrange for installation of dedicated HSCN circuits to each of our UK data centres.
In these cases, you must complete a HSCN Connection Agreement before we can implement connectivity.
What is the resilience of the UKCloud solution?
The UKCloud assured cloud platform is connected to the HSCN in geographically diverse locations. In the unlikely event of a circuit failure, we'll continue to provide connectivity to the HSCN via our secure data centre interconnectivity and our secondary HSCN connection.
How will I be billed?
Billing for HSCN connectivity is monthly in arrears. Charges are included in your monthly invoice, along with charges for your UKCloud services.
We charge for each separate connection on the UKCloud platform at the Service vOrg/Project level UKCloud pricing is available via the UKCloud Pricing Guide
Is there a minimum commitment period?
UKCloud charges monthly for connectivity solutions, and requires a minimum commitment of one month for HSCN connectivity.
Will I incur an upfront cost (setup fee)?
Simple implementations of HSCN won't incur any additional setup or onboarding charges.
For complex networking solutions, we reserve the right to charge SFIA rates. We'll always tell you in advance if an engagement will incur SFIA Rate Card charges.
Does UKCloud provide data encryption?
The HSCN is an unencrypted network and we don't provide additional data encryption.
You must encrypt the data within your applications, especially personally identifiable data (PID), with an AES256 level of encryption.
Can I use UKCloud's HSCN connected service if I'm based outside of England?
IT Service Providers can use a share of UKCloud's HSCN connection from outside of England as long as they comply with the criteria specified in the NHS Digital guidance: https://digital.nhs.uk/services/health-and-social-care-network/hscn-technical-guidance/hscn-private-it-service-provider-connecting-from-outside-of-englands-borders-policy.
This guidance does not apply to NHS organisations who would need to seek clarification from NHS Digital for their specific situation.
Will I have full and unrestricted access to the entire HSCN network?
You will have unrestricted access to the HSCN but you may not be able to access any services presented onto HSCN until you have reached an agreement with the supplier of those services.
Process
Are you an HSCN Aggregator?
We are an HSCN connected Cloud Service Provider and can give you an HSCN connection to environments on our cloud, however there is no longer an Aggregation programme for HSCN.
Once you are aligned with the HSCN Connection Agreement terms, either by signing your own agreement, or by signing to UKCloud's terms, we will connect you to our aggregated HSCN connection.
How do I get an HSCN-connected solution via the UKCloud assured cloud platform?
You can get HSCN connectivity in one of two ways.
Sign your own Connection Agreement, have this counter-signed by NHS Digital and then send us a copy
Sign up to UKCloud's MSA (version 11.0 onwards) as a consumer of our services and we cover you with the flow-down of the Connection Agreement terms. No need to get NHS Digital to counter-sign an Agreement.
Do either of these and we'll enable your access to the HSCN and provide an appropriate HSCN IP address.
How long does the Connection Agreement process take?
If you get your own Connection Agreement then the time taken will depend on NHS Digital's speed of counter-signing your Connection Agreement.
If you simply sign up to the Agreement flow-down through UKCloud's MSA then it only takes as long as it would for an order to be processed.
We'll enable your connection to the HSCN within one working day of your successful completion of the assurance process.
Do I need to contact NHS Digital to apply?
If you want to sign your own Connection Agreement then yes, you do. However, you can be covered through the flow-down of the Agreement in UKCloud's MSA, in which case, you don't.
We're an NHS organisation and already have an HSCN connection, can I use it to connect UKCloud's services?
Yes. You'll need to provide us with your Connection Agreement and we can then provide you HSCN connectivity.
You may also need to contact NHS Digital once you have been allocated an IP address to change any DNS records.
We are a non-NHS customer who already have HSCN connectivity, can we use your HSCN-connected cloud services?
Yes. Simply show us your Connection Agreement and we'll be able to connect your UKCloud service to the HSCN.
You may also need to contact NHS Digital once you have been allocated an IP address to change any DNS records.
I need a solution that's designed to face the HSCN and an additional network. Can UKCloud help? **
Yes. We can help with best-practice advice on designing solutions that face multiple networks. It's important to ensure your design doesn't compromise any other networks, or leave the possibility of unauthorised bridging.
Usually, you'll need specific components of your solution to be dedicated to each network you want to use.
Do I need an NHS sponsor to connect to UKCloud's HSCN?
You won't need a sponsor to connect to HSCN, however you may need a sponsor to connect to HSCN-connected services such as Spine or Emis.
Do I need to complete a Connection Agreement for each HSCN service I have on your cloud platform?
No. you only need one signed Connection Agreement or UKCloud's terms and conditions to present multiple services to HSCN.
However, you may need to create an accreditation pack for each individual service to present to the Information Accreditors who are looking at the security of your application before customers will procure it.
Do you provide an SLA on HSCN connectivity?
We provide an SLA for availability of our core services such as Enterprise Compute Cloud. We cannot provide an SLA on external services (such as the HSCN) as they are outside our control. UKCloud can only provide assurance associated with the native SLAs that are offered as part of the core HSCN framework.
How many HSCN IP addresses will I be allocated?
You will be given one (1) useable IP address per HSCN Edge/router. Any additional IP addresses will need to be justified and are an additional cost.
You can be allocated up to 5 IP addresses per connection. If you require more than 5 IPs per connection you will need to request additional IPs from NHS Digital and we can advertise them on your behalf.
How do I justify the need for more IP addresses?
As IPv4 addresses are in short supply, you must use your addresses as efficiently as possible. Before additional HSCN addresses can be allocated, you will need to demonstrate your use of:
Load balancing services - enabling several web servers to be accessed via a single externally routable IP address
Host headers - enabling web servers to accept connections for several URLs via a single externally routable IP address
VPN tunnelling - enabling the use of internal (RFC 1918) IP addresses for non-production services such as UAT AND development
Is there a cost for additional HSCN IP addresses?
Yes. There is an administration fee of £20 for each additional HSCN IP address.
How can I whitelist source HSCN IP addresses on the edge gateway?
You can log into the UKCloud Portal and, within the edge gateway properties, edit the firewall settings to allow or deny incoming connections from external IP addresses.
How does IP address allocation work on an HSCN network for two front-end servers?
You can implement this in two ways:
Create an external org VDC network in which UKCloud routes from the ASA firewall. This can then be used for NAT to the HSCN address.
Use one of your public IP addresses, which is then translated (using NAT) on the ASA firewall. You can then use NAT rules on your edge gateway from an external org network as described in option 1.
How does name resolution (DNS) happen on HSCN?
There are two DNS servers on the HSCN network which is looked after by the NHS Digital DNS team. UKCloud permits access (outbound) on UDP port 53 for DNS queries.
To request a DNS change, please email<EMAIL_ADDRESS>who require the following information:
Domains that you wish to change.
Old IP address(es).
New IP address(es).
Date and Time of Change.
We recommend a couple of days lead time as there may be scheduling issues, though these can be waived in emergencies.
Please note that IP changes are NOT instantaneous and may take some time to propagate fully. We can do out of hours changes for NHS customers
Feedback
If you find a problem with this article, click Improve this Doc to make the change yourself or raise an issue in GitHub. If you have an idea for how we could improve any of our services, send an email to feedback@ukcloud.com.


Overview
Introduction ============ ehcache is a pure Java, in-process cache with the following features: 1. Fast 2. Simple 3. Act as a pluggable cache for Hibernate 2.1. 4. Small foot print. Both in terms of size and memory requirements. 5. Minimal dependencies apart from J2SE. 6. Fully documented. See the online Documentation and the online JavaDoc. 7. Comprehensive Test Coverage. See the clover test report. 8. Available under the Apache 1.1 license. EHCache's copyright and licensing has been reviewed and approved by the Apache Software Foundation, making EHCache suitable for use in Apache projects. 9. Production tested. All versions of EHCache are production tested for several weeks on a large and very busy eCommerce site before release. Java Requirements ================= ehcache supports JDK1.2, 1.3, 1.4 and 1.5 at runtime. When compiling from source, the build process requires JDK 1.4 or JDK1.5. ehcache does not work with JDK1.1. Dependencies ============ For JDK1.4, ehcache requires commons-logging from Apache's Jakarta project. For JDK1.2 and JDK 1.3, ehcache requires: - Apache Jakarta's commons-collections, version 2.1 - Apache xerces (xml-apis.jar and xercesImpl.jar), version 2.5 All three dependencies are also Hibernate dependencies, so if you are using ehcache as a Hibernate plugin, dependency requirements are met. Installation ============ Place ehcache-x.x.jar into your classpath. Ensure the required dependencies are in the classpath. Documentation ============= See http://ehcache.sourceforge.net/documentation for full documentation. The JavaDoc is in the distribution and also online at http://ehcache.sourceforge.net/javadoc. Configuration ============= The distribution contains an example configuration file called ehcache.xml and its accompanying schema, ehcache.xsd. To configure ehcache, edit ehcache.xml. For Hibernate it must be placed in your classpath. For use as a general case you can specify its location as a parameter of CacheManager.create(...). See http://ehcache.sourceforge.net/documentation/#configuration for more information.


{% extends 'base.html' %} {% block title %}Gallery · {{ block.super }}{% endblock %} {% block heading %} {{ album.title }} {% endblock %} {% block content %}
{{ message }}
Copy this link and send it to your friends. It will send them to a page where they can download a zip file containing all the photos you just uploaded.
{{ link.url }}


Photoshots.ie
Home
About Me
Landmarks
Contact
Famous Landmarks
Famous Landmarks
My Hobby is taking images from landmarks all over the world
Get in touch
Fill in the form below, and we'll get back to you within 24 hours.
Name: (required)
Email: (required)
Telephone: (required)
Message: (required)
Send Email


Setting the Editor Height
How to set the height of the Description Editor that is displayed on the Edit Announcements page of the Announcements module.
-
- Select the Announcements Settings tab.
- In the Editor Height (px) text box, enter the height in pixels for the Editor. The default setting is 300.
-
Click the OK button to confirm.


Collapsible example
Collapsible
1. Collapsible contents
Some content is supposed to come here.
1.1. Collapsible contents continued
Some continued content is supposed to come here.
Collapsible
1. Collapsible contents
Some content is supposed to come here.
1.1. Collapsible contents continued
Some continued content is supposed to come here.


Our flexible, interdisciplinary major lets students pursue a wide range of academic interests and careers.
Explore Undergraduate AdmissionsStudy the workplace comprehensively with the world's highest concentration of workplace faculty.
Explore Graduate ProgramsInvest in your career by learning from instructors who blend world-leading research with business-tested practicality.
Explore Professional Education


'England Star Would Be Crazy To Join Man Utd'
by SL InternationalBorussia Dortmund star Jadon Sancho would be crazy to join 'struggling' Manchester United, according to a former Liverpool star.
Read: Expected January Signing To Start Training With Man Utd?
Sancho rose to prominence in the Bundesliga last season and has reportedly attracted interest from the likes of the Red Devils and Liverpool.
The English winger left Manchester City in search of regular game time, but former Reds defender Steve Nicol feels Sancho would be making a mistake by joining United.
“I think he’s crazy if he goes to Man Utd.
“We’re talking about he’s struggling in a team that’s struggling (Dortmund) - Man United are going to be struggling for a couple of seasons, so I would stay away from there.”
“Well, if I was advising him, let me put it that way, I would like to see him at Liverpool.
“I think he would be fantastic. If he could get his head round playing second fiddle to Mane and Salah, then that would be huge for Liverpool in my opinion.
“They could save the legs of both of those two and kind of swap the three of them in and out.
“But he’s not going to do that, he’s going to go somewhere to play. So I think Liverpool’s out.”
Read: Man Utd Target: I Sleep With My Hat-Trick Balls In My Bed


HTML & CSS
Scrimba: The Frontend Developer Career Path
Challenges that taught me how to create a basic layout using CSS, as well as a few styling tips.
Interactive Sites
Scrimba: The Frontend Developer Career Path
Challneges that taught me how to make websites interactive using JavaScript.
My Emojis
Scrimba: The Frontend Developer Career Path
Challenges that taught me how to use JS to interact with the DOM, allowing the creation of websites that respond to user actions.
Diary App
Scrimba: The Frontend Developer Career Path
Scrimba: Diary App
CSS Fundamentals
Scrimba: The Frontend Developer Career Path
These exercises taught me CS fundamentals: the box model, margin and padding, as well as basic styling
JavaScript Challenges
Build a Modal
Using JS to create a modal (positioning, opacity, button interactivity)
JavaScript Challenges
Search Bar
Keyboard events, JS filtering, DOM tree search
JavaScript Challenges
Carousel
Carousel with JS, HTML, CSS


Components are interactive building blocks of our design system.
Each component was created to meet a specific UI and accessibility need.
Components should be used harmoniously together in the same space to create more intuitive user experiences.
{%- for element in elements -%}
{%- if element.docsTemplatePath -%}
{%- if env.ELEVENTY_ENV == "prod" -%}
{%- else -%}


——Whatever is worth doing is worth doing well.
He is just a programmer, of course, you can also think he is a hacker.
Asia.China
1. Family
2. Make friends
3. Network protocol
4. Network security
5. Software architecture design
6. Program design—C/C++
7. Good OS—Linux/Unix


class PrefixSpan extends Logging with Serializable
A parallel PrefixSpan algorithm to mine frequent sequential patterns. The PrefixSpan algorithm is described in J. Pei, et al., PrefixSpan: Mining Sequential Patterns Efficiently by Prefix-Projected Pattern Growth (see here).
- Annotations
- @Since( "1.5.0" )
- Source
- PrefixSpan.scala
- See also
- Alphabetic
- By Inheritance
- PrefixSpan
- Serializable
- Serializable
- Logging
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Instance Constructors
-
new
PrefixSpan()
Constructs a default instance with default parameters {minSupport:
0.1
, maxPatternLength:10
, maxLocalProjDBSize:32000000L
}.Constructs a default instance with default parameters {minSupport:
0.1
, maxPatternLength:10
, maxLocalProjDBSize:32000000L
}.- Annotations
- @Since( "1.5.0" )
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
getMaxLocalProjDBSize: Long
Gets the maximum number of items allowed in a projected database before local processing.
Gets the maximum number of items allowed in a projected database before local processing.
- Annotations
- @Since( "1.5.0" )
-
def
getMaxPatternLength: Int
Gets the maximal pattern length (i.e.
Gets the maximal pattern length (i.e. the length of the longest sequential pattern to consider.
- Annotations
- @Since( "1.5.0" )
-
def
getMinSupport: Double
Get the minimal support (i.e.
Get the minimal support (i.e. the frequency of occurrence before a pattern is considered frequent).
- Annotations
- @Since( "1.5.0" )
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
-
def
initializeLogIfNecessary(isInterpreter: Boolean, silent: Boolean): Boolean
- Attributes
- protected
- Definition Classes
- Logging
-
def
initializeLogIfNecessary(isInterpreter: Boolean): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
isTraceEnabled(): Boolean
- Attributes
- protected
- Definition Classes
- Logging
-
def
log: Logger
- Attributes
- protected
- Definition Classes
- Logging
-
def
logDebug(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logDebug(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logError(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logError(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logInfo(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logInfo(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logName: String
- Attributes
- protected
- Definition Classes
- Logging
-
def
logTrace(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logTrace(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logWarning(msg: ⇒ String, throwable: Throwable): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
def
logWarning(msg: ⇒ String): Unit
- Attributes
- protected
- Definition Classes
- Logging
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
-
def
run[Item, Itemset <: Iterable[Item], Sequence <: Iterable[Itemset]](data: JavaRDD[Sequence]): PrefixSpanModel[Item]
A Java-friendly version of
run()
that reads sequences from aJavaRDD
and returns frequent sequences in a PrefixSpanModel.A Java-friendly version of
run()
that reads sequences from aJavaRDD
and returns frequent sequences in a PrefixSpanModel.- Item
item type
- Itemset
itemset type, which is an Iterable of Items
- Sequence
sequence type, which is an Iterable of Itemsets
- data
ordered sequences of itemsets stored as Java Iterable of Iterables
- returns
a PrefixSpanModel that contains the frequent sequential patterns
- Annotations
- @Since( "1.5.0" )
-
def
run[Item](data: RDD[Array[Array[Item]]])(implicit arg0: ClassTag[Item]): PrefixSpanModel[Item]
Finds the complete set of frequent sequential patterns in the input sequences of itemsets.
Finds the complete set of frequent sequential patterns in the input sequences of itemsets.
- data
sequences of itemsets.
- returns
a PrefixSpanModel that contains the frequent patterns
- Annotations
- @Since( "1.5.0" )
-
def
setMaxLocalProjDBSize(maxLocalProjDBSize: Long): PrefixSpan.this.type
Sets the maximum number of items (including delimiters used in the internal storage format) allowed in a projected database before local processing (default:
32000000L
).Sets the maximum number of items (including delimiters used in the internal storage format) allowed in a projected database before local processing (default:
32000000L
).- Annotations
- @Since( "1.5.0" )
-
def
setMaxPatternLength(maxPatternLength: Int): PrefixSpan.this.type
Sets maximal pattern length (default:
10
).Sets maximal pattern length (default:
10
).- Annotations
- @Since( "1.5.0" )
-
def
setMinSupport(minSupport: Double): PrefixSpan.this.type
Sets the minimal support level (default:
0.1
).Sets the minimal support level (default:
0.1
).- Annotations
- @Since( "1.5.0" )
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()


virus Zika ZIKV patients clinical Fig. Infect Dis dengue pain reported Chikungunya DENV Emerg Faye Lanciotti Musso fever infection negative samples transmission Brazil. Brazilian CHIKV Cao-Lormeau RNA symptoms AJ, Asian Clin French GenBank RS, RT-PCR VM, accession analysis chain disease patients, reaction reverse sequences serum using viral virus, viruses


--- layout: page title: About header-img: "img/about-bg.png" ---
I'm a data science student at the Flatiron School. After years of admiring the insights generated by people that get to work in analytics and data science, I decided that I want to join them. It's going to be a challenging and rewarding journey to develop my skills in this area while balancing work and life, but nothing worth doing is easy! Thanks for following my work, if you're learning too please let me know if I can help (or more likely, you can help me). - Ryan


{{#if adminView}}switch to player view{{else}}switch to admin view{{/if}}
{{#if simulationRunning}}
simulation stop
{{else}}
speed
simulation start
simulation step
create snapshot
load snapshot
──────────
empty
{{#each snapshots}}
{{name}}
{{/each}}
{{#if snapshotSelected}}
delete snapshot
{{/if}}
export json
{{/if}}
Policy Garden
refresh garden map
{{#if adminView}}
Edit Goals
select to edit
{{#each goals}}
{{title}}
{{/each}}
{{#if selectedGoal}} {{>node selectedGoal}} {{/if}}
create goal
Edit Policies
select to edit
{{#each policies}}
{{title}}
{{/each}}
{{#if selectedPolicy}} {{>node selectedPolicy}} {{/if}}
create policy
{{else}}
Are We Reaching Our Goals?
{{#each goalsSorted}}
{{title}} (level: {{level}}, outflow: {{currentOutflow}})
{{/each}}
Our Strongest Policies
{{#each policiesSorted}} {{> policyShort}} {{/each}}
{{/if}}
{{#if adminView}}
Edit Players
{{else}}
Play
{{/if}}
{{#each players}} {{> node}} {{/each}}
{{#if adminView}}
create player
{{/if}}
import JSON


bokeh.util¶
Provide a collection of general utilities useful for implementing Bokeh functionality.
bokeh.util.browser
¶
Utility functions for helping with operations involving browsers.
-
get_browser_controller
(browser=None)[source]¶ Return a browser controller.
Parameters: browser (str or None) – browser name, or
None
(default:None
) If passed the string'none'
, a dummy web browser controller is returnedOtherwise, use the value to select an appropriate controller using the
webbrowser
standard library module. In the value isNone
then a system default is used.Note
If the environment variable
BOKEH_BROWSER
is set, it will take precedence.Returns: a web browser controller Return type: controller
-
view
(location, browser=None, new='same', autoraise=True)[source]¶ Open a browser to view the specified location.
Parameters: - location (str) – Location to open If location does not begin with “http:” it is assumed to be a file path on the local filesystem.
- browser (str or None) – what browser to use (default: None)
If
None
, use the system default browser. - new (str) –
How to open the location. Valid values are:
'same'
- open in the current tab'tab'
- open a new tab in the current window'window'
- open in a new window - autoraise (bool) – Whether to automatically raise the location in a new browser window (default: True)
Returns: None
bokeh.util.callback_manager
¶
Provides PropertyCallbackManager
and EventCallbackManager
mixin classes for adding on_change
and on_event
callback
interfaces to classes.
-
class
EventCallbackManager
(*args, **kw)[source]¶ A mixin class to provide an interface for registering and triggering event callbacks on the Python side.
-
class
PropertyCallbackManager
(*args, **kw)[source]¶ A mixin class to provide an interface for registering and triggering callbacks.
bokeh.util.compiler
¶
Provide functions and classes to help with various JS and CSS compilation.
-
exception
CompilationError
(error)[source]¶ A
RuntimeError
subclass for reporting JS compilation errors.
-
class
CoffeeScript
(code, file=None)[source]¶ An implementation for a Bokeh custom model in CoffeeScript.
Example
class MyExt(Model): __implementation__ = CoffeeScript(""" <CoffeeScript code> """)
Note that
CoffeeScript
is the default implementation language for custom model implementations. The following is equivalent to example above:class MyExt(Model): __implementation__ == """ <some coffeescript code> """
-
class
FromFile
(path)[source]¶ A custom model implementation read from a separate source file.
Parameters: path (str) – The path to the file containing the extension source code
-
class
Inline
(code, file=None)[source]¶ Base class for representing Bokeh custom model implementations that may be given as inline code in some language.
Parameters:
-
class
JavaScript
(code, file=None)[source]¶ An implementation for a Bokeh custom model in JavaScript
Example
class MyExt(Model): __implementation__ = Javacript(""" <JavaScript code> """)
-
class
TypeScript
(code, file=None)[source]¶ An implementation for a Bokeh custom model in TypeScript
Example
class MyExt(Model): __implementation__ = TypeScript(""" <TypeScript code> """)
-
calc_cache_key
()[source]¶ Generate a key to cache a custom extension implementation with.
There is no metadata other than the Model classes, so this is the only base to generate a cache key.
We build the model keys from the list of
model.full_name
. This is not ideal but possibly a better solution can be found found later.
-
get_cache_hook
()[source]¶ Returns the current cache hook used to look up the compiled code given the CustomModel and Implementation
-
set_cache_hook
(hook)[source]¶ Sets a compiled model cache hook used to look up the compiled code given the CustomModel and Implementation
-
exts
= ('.coffee', '.ts', '.js', '.css', '.less')¶ recognized extensions that can be compiled
bokeh.util.dependencies
¶
Utilities for checking dependencies
-
detect_phantomjs
(version='2.1')[source]¶ Detect if PhantomJS is avaiable in PATH, at a minimum version.
Parameters: version (str, optional) – Required minimum version for PhantomJS (mostly for testing) Returns: str, path to PhantomJS
-
import_optional
(mod_name)[source]¶ Attempt to import an optional dependency.
Silently returns None if the requested module is not available.
Parameters: mod_name (str) – name of the optional module to try to import Returns: imported module or None, if import fails
bokeh.util.deprecation
¶
bokeh.util.future
¶
Utilities for Py2/Py3 interop.
-
with_metaclass
(meta, *bases)[source]¶ Add metaclasses in both Python 2 and Python 3.
Function from jinja2/_compat.py. License: BSD.
Use it like this:
class BaseForm(object): pass class FormType(type): pass class Form(with_metaclass(FormType, BaseForm)): pass
This requires a bit of explanation: the basic idea is to make a dummy metaclass for one level of class instantiation that replaces itself with the actual metaclass. Because of internal type checks we also need to make sure that we downgrade the custom metaclass for one level to something closer to type (that’s why __call__ and __init__ comes back from type etc.).
This has the advantage over six.with_metaclass of not introducing dummy classes into the final MRO.
bokeh.util.hex
¶
Functions useful for dealing with hexagonal tilings.
For more information on the concepts employed here, see this informative page
-
axial_to_cartesian
(q, r, size, orientation, aspect_scale=1)[source]¶ Map axial (q,r) coordinates to cartesian (x,y) coordinates of tiles centers.
This function can be useful for positioning other Bokeh glyphs with cartesian coordinates in relation to a hex tiling.
This function was adapted from:
Parameters: - q (array[float]) – A NumPy array of q-coordinates for binning
- r (array[float]) – A NumPy array of r-coordinates for binning
- size (float) –
The size of the hexagonal tiling.
The size is defined as the distance from the center of a hexagon to the top corner for “pointytop” orientation, or from the center to a side corner for “flattop” orientation.
- orientation (str) – Whether the hex tile orientation should be “pointytop” or “flattop”.
- aspect_scale (float, optional) –
Scale the hexagons in the “cross” dimension.
For “pointytop” orientations, hexagons are scaled in the horizontal direction. For “flattop”, they are scaled in vertical direction.
When working with a plot with
aspect_scale != 1
, it may be useful to set this value to match the plot.
Returns: (array[int], array[int])
-
cartesian_to_axial
(x, y, size, orientation, aspect_scale=1)[source]¶ Map Cartesion (x,y) points to axial (q,r) coordinates of enclosing tiles.
This function was adapted from:
Parameters: - x (array[float]) – A NumPy array of x-coordinates to convert
- y (array[float]) – A NumPy array of y-coordinates to convert
- size (float) –
The size of the hexagonal tiling.
The size is defined as the distance from the center of a hexagon to the top corner for “pointytop” orientation, or from the center to a side corner for “flattop” orientation.
- orientation (str) – Whether the hex tile orientation should be “pointytop” or “flattop”.
- aspect_scale (float, optional) –
Scale the hexagons in the “cross” dimension.
For “pointytop” orientations, hexagons are scaled in the horizontal direction. For “flattop”, they are scaled in vertical direction.
When working with a plot with
aspect_scale != 1
, it may be useful to set this value to match the plot.
Returns: (array[int], array[int])
-
hexbin
(x, y, size, orientation='pointytop', aspect_scale=1)[source]¶ Perform an equal-weight binning of data points into hexagonal tiles.
For more sophisticated use cases, e.g. weighted binning or scaling individual tiles proportional to some other quantity, consider using HoloViews.
Parameters: - x (array[float]) – A NumPy array of x-coordinates for binning
- y (array[float]) – A NumPy array of y-coordinates for binning
- size (float) –
The size of the hexagonal tiling.
The size is defined as the distance from the center of a hexagon to the top corner for “pointytop” orientation, or from the center to a side corner for “flattop” orientation.
- orientation (str, optional) – Whether the hex tile orientation should be “pointytop” or “flattop”. (default: “pointytop”)
- aspect_scale (float, optional) –
Match a plot’s aspect ratio scaling.
When working with a plot with
aspect_scale != 1
, this parameter can be set to match the plot, in order to draw regular hexagons (instead of “stretched” ones).This is roughly equivalent to binning in “screen space”, and it may be better to use axis-aligned rectangular bins when plot aspect scales are not one.
Returns: DataFrame
The resulting DataFrame will have columns q and r that specify hexagon tile locations in axial coordinates, and a column counts that provides the count for each tile.
Warning
Hex binning only functions on linear scales, i.e. not on log plots.
bokeh.util.logconfig
¶
Configure the logging system for Bokeh.
By default, logging is not configured, to allow users of Bokeh to have full
control over logging policy. However, it is useful to be able to enable
logging arbitrarily during when developing Bokeh. This can be accomplished
by setting the environment variable BOKEH_PY_LOG_LEVEL
. Valid values are,
in order of increasing severity:
debug
info
warn
error
fatal
none
The default logging level is none
.
bokeh.util.options
¶
Utilities for specifying, validating, and documenting configuration options.
-
class
Options
(kw=None)[source]¶ Leverage the Bokeh properties type system for specifying and validating configuration options.
Subclasses of
Options
specify a set of configuration options using standard Bokeh properties:class ConnectOpts(Options): host = String(default="<IP_ADDRESS>", help="a host value") port = Int(default=5590, help="a port value")
Then a
ConnectOpts
can be created by passing a dictionary containing keys and values corresponding to the configuration options, as well as any additional keys and values. The items corresponding to the properties onConnectOpts
will be *removed* from the dictionary. This can be useful for functions that accept their own set of config keyword arguments in addition to some set of Bokeh model properties.
bokeh.util.paths
¶
bokeh.util.serialization
¶
Functions for helping with serialization and deserialization of Bokeh objects.
Certain NunPy array dtypes can be serialized to a binary format for performance and efficiency. The list of supported dtypes is:
np.int16
np.uint32
np.uint16
np.float32
np.int8
np.float64
np.uint8
np.int32
-
array_encoding_disabled
(array)[source]¶ Determine whether an array may be binary encoded.
The NumPy array dtypes that can be encoded are:
np.int16
np.uint32
np.uint16
np.float32
np.int8
np.float64
np.uint8
np.int32
Parameters: array (np.ndarray) – the array to check Returns: bool
-
convert_datetime_array
(array)[source]¶ Convert NumPy datetime arrays to arrays to milliseconds since epoch.
Parameters: array – (obj) A NumPy array of datetime to convert
If the value passed in is not a NumPy array, it will be returned as-is.
Returns: array
-
convert_datetime_type
(obj)[source]¶ Convert any recognized date, time, or datetime value to floating point milliseconds since epoch.
- Arg:
- obj (object) : the object to convert
Returns: milliseconds Return type: float
-
convert_timedelta_type
(obj)[source]¶ Convert any recognized timedelta value to floating point absolute milliseconds.
- Arg:
- obj (object) : the object to convert
Returns: milliseconds Return type: float
-
decode_base64_dict
(data)[source]¶ Decode a base64 encoded array into a NumPy array.
Parameters: data (dict) – encoded array data to decode Data should have the format encoded by
encode_base64_dict()
.Returns: np.ndarray
-
encode_base64_dict
(array)[source]¶ Encode a NumPy array using base64:
The encoded format is a dict with the following structure:
{ '__ndarray__' : << base64 encoded array data >>, 'shape' : << array shape >>, 'dtype' : << dtype name >>, }
Parameters: array (np.ndarray) – an array to encode Returns: dict
-
encode_binary_dict
(array, buffers)[source]¶ Send a numpy array as an unencoded binary buffer
The encoded format is a dict with the following structure:
{ '__buffer__' : << an ID to locate the buffer >>, 'shape' : << array shape >>, 'dtype' : << dtype name >>, 'order' : << byte order at origin (little or big)>> }
Parameters: - array (np.ndarray) – an array to encode
- buffers (set) –
Set to add buffers to
This is an “out” parameter. The values it contains will be modified in-place.
Returns: dict
-
is_datetime_type
(obj)[source]¶ Whether an object is any date, time, or datetime type recognized by Bokeh.
- Arg:
- obj (object) : the object to test
Returns: True if obj
is a datetime typeReturn type: bool
-
is_timedelta_type
(obj)[source]¶ Whether an object is any timedelta type recognized by Bokeh.
- Arg:
- obj (object) : the object to test
Returns: True if obj
is a timedelta typeReturn type: bool
-
make_globally_unique_id
()[source]¶ Return a globally unique UUID.
Some situtations, e.g. id’ing dynamically created Divs in HTML documents, always require globally unique IDs.
Returns: str
-
make_id
()[source]¶ Return a new unique ID for a Bokeh object.
Normally this function will return simple monotonically increasing integer IDs (as strings) for identifying Bokeh objects within a Document. However, if it is desirable to have globally unique for every object, this behavior can be overridden by setting the environment variable
BOKEH_SIMPLE_IDS=no
.Returns: str
-
serialize_array
(array, force_list=False, buffers=None)[source]¶ Transforms a NumPy array into serialized form.
Parameters: - array (np.ndarray) – the NumPy array to transform
- force_list (bool, optional) – whether to only output to standard lists This function can encode some dtypes using a binary encoding, but setting this argument to True will override that and cause only standard Python lists to be emitted. (default: False)
- buffers (set, optional) –
If binary buffers are desired, the buffers parameter may be provided, and any columns that may be sent as binary buffers will be added to the set. If None, then only base64 encoding will be used (default: None)
If force_list is True, then this value will be ignored, and no buffers will be generated.
This is an “out” parameter. The values it contains will be modified in-place.
Returns: list or dict
-
transform_array
(array, force_list=False, buffers=None)[source]¶ Transform a NumPy arrays into serialized format
Converts un-serializable dtypes and returns JSON serializable format
Parameters: - array (np.ndarray) – a NumPy array to be transformed
- force_list (bool, optional) – whether to only output to standard lists This function can encode some dtypes using a binary encoding, but setting this argument to True will override that and cause only standard Python lists to be emitted. (default: False)
- buffers (set, optional) –
If binary buffers are desired, the buffers parameter may be provided, and any columns that may be sent as binary buffers will be added to the set. If None, then only base64 encoding will be used (default: None)
If force_list is True, then this value will be ignored, and no buffers will be generated.
This is an “out” parameter. The values it contains will be modified in-place.
Returns: JSON
-
transform_array_to_list
(array)[source]¶ Transforms a NumPy array into a list of values
Parameters: array (np.nadarray) – the NumPy array series to transform Returns: list or dict
-
transform_column_source_data
(data, buffers=None, cols=None)[source]¶ Transform
ColumnSourceData
data to a serialized formatParameters: - data (dict) – the mapping of names to data columns to transform
- buffers (set, optional) –
If binary buffers are desired, the buffers parameter may be provided, and any columns that may be sent as binary buffers will be added to the set. If None, then only base64 encoding will be used (default: None)
This is an “out” parameter. The values it contains will be modified in-place.
- cols (list[str], optional) – Optional list of subset of columns to transform. If None, all columns will be transformed (default: None)
Returns: JSON compatible dict
-
transform_series
(series, force_list=False, buffers=None)[source]¶ Transforms a Pandas series into serialized form
Parameters: - series (pd.Series) – the Pandas series to transform
- force_list (bool, optional) – whether to only output to standard lists This function can encode some dtypes using a binary encoding, but setting this argument to True will override that and cause only standard Python lists to be emitted. (default: False)
- buffers (set, optional) –
If binary buffers are desired, the buffers parameter may be provided, and any columns that may be sent as binary buffers will be added to the set. If None, then only base64 encoding will be used (default: None)
If force_list is True, then this value will be ignored, and no buffers will be generated.
This is an “out” parameter. The values it contains will be modified in-place.
Returns: list or dict
-
traverse_data
(obj, use_numpy=True, buffers=None)[source]¶ Recursively traverse an object until a flat list is found.
If NumPy is available, the flat list is converted to a numpy array and passed to transform_array() to handle
nan
,inf
, and-inf
.Otherwise, iterate through all items, converting non-JSON items
Parameters:
bokeh.util.session_id
¶
Utilities for generating and manipulating session IDs.
A session ID would typically be associated with each browser tab viewing an application or plot. Each session has its own state separate from any other sessions hosted by the server.
-
check_session_id_signature
(session_id, secret_key=None, signed=False)[source]¶ Check the signature of a session ID, returning True if it’s valid.
The server uses this function to check whether a session ID was generated with the correct secret key. If signed sessions are disabled, this function always returns True.
Parameters:
-
generate_secret_key
()[source]¶ Generate a new securely-generated secret key appropriate for SHA-256 HMAC signatures. This key could be used to sign Bokeh server session IDs for example.
-
generate_session_id
(secret_key=None, signed=False)[source]¶ Generate a random session ID.
Typically, each browser tab connected to a Bokeh application has its own session ID. In production deployments of a Bokeh app, session IDs should be random and unguessable - otherwise users of the app could interfere with one another.
If session IDs are signed with a secret key, the server can verify that the generator of the session ID was “authorized” (the generator had to know the secret key). This can be used to have a separate process, such as another web application, which generates new sessions on a Bokeh server. This other process may require users to log in before redirecting them to the Bokeh server with a valid session ID, for example.
Parameters:
bokeh.util.string
¶
Functions useful for string manipulations or encoding.
-
decode_utf8
(u)[source]¶ Decode a sequence of bytes to a UTF-8 string
Parameters: u (str) – the bytes to decode Returns: UTF-8 string
-
encode_utf8
(u)[source]¶ Encode a UTF-8 string to a sequence of bytes.
Parameters: u (str) – the string to encode Returns: bytes
-
escape
(s, quote=("'", '"'))[source]¶ Perform HTML-safe escaping.
Replaces special characters “&”, “<” and “>” to HTML-safe sequences, and optionally translates quote characters.
Parameters: Returns: str
-
format_docstring
(docstring, *args, **kwargs)[source]¶ Safely format docstrings.
When Python is executed with the
-OO
option, doc strings are removed and replaced the valueNone
. This function guards against applying the string formatting options in that case.Parameters: Returns: str or None
-
indent
(text, n=2, ch=' ')[source]¶ Indent all the lines in a given block of text by a specified amount.
Parameters:
bokeh.util.tornado
¶
Internal utils related to Tornado
bokeh.util.terminal
¶
Provide utilities for formatting terminal output.
bokeh.util.version
¶
Provide a version for the Bokeh library.
This module uses versioneer to manage version strings. During development, versioneer will compute a version string from the current git revision. For packaged releases based off tags, the version string is hard coded in the files packaged for distribution.
-
__version__
¶ The full version string for this installed Bokeh library
- Functions:
- base_version:
- Return the base version string, without any “dev”, “rc” or local build information appended.
bokeh.util.warnings
¶
Provide Bokeh-specific warning subclasses.
The primary use of these subclasses to to force them to be unconditionally displayed to users by default.


The ECP group structure.
We consider two types of curve equations:
-
Short Weierstrass:
y^2 = x^3 + A x + B mod P
(SEC1 + RFC-4492)
-
Montgomery:
y^2 = x^3 + A x^2 + x mod P
(Curve25519, Curve448)
In both cases, the generator (G
) for a prime-order subgroup is fixed.
For Short Weierstrass, this subgroup is the whole curve, and its cardinality is denoted by N
. Our code requires that N
is an odd prime as mbedtls_ecp_mul() requires an odd number, and mbedtls_ecdsa_sign() requires that it is prime for blinding purposes.
For Montgomery curves, we do not store A
, but (A + 2) / 4
, which is the quantity used in the formulas. Additionally, nbits
is not the size of N
but the required size for private keys.
If modp
is NULL, reduction modulo P
is done using a generic algorithm. Otherwise, modp
must point to a function that takes an mbedtls_mpi
in the range of 0..2^(2*pbits)-1
, and transforms it in-place to an integer which is congruent mod P
to the given MPI, and is close enough to pbits
in size, so that it may be efficiently brought in the 0..P-1 range by a few additions or subtractions. Therefore, it is only an approximative modular reduction. It must return 0 on success and non-zero on failure.
- Note
- Alternative implementations must keep the group IDs distinct. If two group structures have the same ID, then they must be identical.
Definition at line 232 of file ecp.h.


Thrift Store
Donate
Our History
Contact Us
Home
Thrift Store
Donate
Our History
Contact Us
menu
Sorry. The page your looking for doesn't exist!
Please check out one of our other cool pages!
Home
|
Thrift Store
|
Donate
|
History
|
Contact
arrow_upward
Like
Subscribe
Recommend
Follow


These unit tests will delete any servers in your account whose names start with "test", and will create 10 servers prefixed with "test" that exist for the duration of the test.
Results
Log


Giving children evening tutoring every wednesday from 4pm to 5:30pm." More details
Looking for volunteer teachers every saturday starting in december 15th More details


This island formally housed a French Naval Base which supported the nuclear testing site at nearby Mururoa atoll. It is home for about 1200 people. Rarely visited by yachts as it lies to the soth of most cruising routes.
Position 18°03'90S, 141°0 0'31W. (the pass)
Anchorage off Otepa 18°06'S,140°54'W.
The wide entrance to the lagoon is at the northern end of the atoll.
There is a very protected area off the village of Otepa where is is possible to tie to the wall. Althernatively, anchor off in 60ft avoiding the coral heads.
Another good anchorage is by the pearl farm at Nake (18°24'S,140°40'W).
Last updated September 2011.


Home
iBWIM
iSHM
Research
Resources
About
White Papers
Bridge Weigh in Motion (BWIM)
Overview of iBWIM
Accuracy of iBWIM
Applications of iBWIM
Vehicle classification
Our research topics on iBWIM
iBWIM for Bridge Structural Assessment
Structural Health Monitoring (SHM)
Overview of iSHM


ICICI Lombard, Biocon, Hindalco: Three stocks Anand Rathi is bullish on
As regards Biocon, the stock has provided a breakout from the inverse head and shoulders pattern with an increase in volume. There is a buy crossover in its oscillators as well
by Jay Anand ThakkarNIFTY: BUY TGT 12050/12100 SL: 11800
Nifty closed firm on Monday above the 11900 mark, which is a positive sign in the short-term. The index has been forming 'wave E' of the rising wedge pattern and is expected to inch towards the upper end of this pattern. The short-term target, however, is 12050/12100 and the support is seen at 11800 levels.
HINDALCO: BUY TGT: 210 SL: 190
The stock has completed the right shoulder of the inverse head and shoulders pattern, which is a bullish reversal pattern. The daily as well as weekly momentum indicator, MACD, is well in the buy mode. The move prior to this up move was impulsive. Hence, another impulse wave on the way up has started.
BIOCON: BUY TGT: 282 SL: 249
The stock has provided a breakout from the inverse head and shoulders pattern with an increase in volume. There is a buy crossover in its oscillators as well. The support on the lower side is pegged at 249. The conservative target is 282.
ICICI Lombard General Insurance: BUY TGT 1450 SL: 1265
The stock has provided a breakout from the ascending triangular pattern and seems to be retesting the same in the short-term. The stock has an aggressive target of 1450 in the wave 5 up. We suggest buying this stock for the above mentioned target, keeping the stop loss at 1265.
===================
Note: All figures for stocks in Rs unless stated otherwise. Nifty level in points.
Disclaimer: Jay Anand Thakkar is CMT -Assistant Vice President - Equity Research, Anand Rathi Shares and Stock Brokers. Views expressed are his own. He may/may not have position(s) in the stocks and index mentioned above.


The best images from the weekend’s sporting action.
Jose Mourinho returned to the dugout for the first time since his appointment as Tottenham head coach with a tense 3-2 win at West Ham.
Liverpool tightened their stance at the top of the Premier League with victory at Crystal Palace, with Leicester and Manchester City in close pursuit.
There were boxing title bouts, European action in rugby union, Europe’s number one golfer was crowned in Dubai and the International Swimming League arrived in London.


Updates
James Bond
Love wine? Love food? Love to win an iPad 2 with gift certificates to your faorite IA winery & Dine restaurant. http://bit.ly/xQ4Ls8
Love wine? Love food? Love to win an iPad 2 with gift certificates to your faorite IA winery & Dine restaurant. http://bit.ly/xQ4Ls8
Jim Malone
Would you happen to know where Capone is?


#include "lua.h"
Data Fields | |
| int | event |
| const char * | name |
| const char * | namewhat |
| const char * | what |
| const char * | source |
| int | currentline |
| int | nups |
| int | linedefined |
| int | lastlinedefined |
| char | short_src [LUA_IDSIZE] |
| int | i_ci |
typedef struct lua_Debug {
int event;
const char *name; (n)
const char *namewhat; (n)
const char *what; (S)
const char *source; (S)
int currentline; (l)
int nups; (u) number of upvalues
int linedefined; (S)
int lastlinedefined; (S)
char short_src[LUA_IDSIZE]; (S)
private part
other fields
} lua_Debug;
A structure used to carry different pieces of information about an active function. lua_getstack fills only the private part of this structure, for later use. To fill the other fields of lua_Debug with useful information, call lua_getinfo.
The fields of lua_Debug have the following meaning:
source: If the function was defined in a string, then source is that string. If the function was defined in a file, then source starts with a '@' followed by the file name.
short_src: a "printable" version of source, to be used in error messages.
linedefined: the line number where the definition of the function starts.
lastlinedefined: the line number where the definition of the function ends.
what: the string "Lua" if the function is a Lua function, "C" if it is a C function, "main" if it is the main part of a chunk, and "tail" if it was a function that did a tail call. In the latter case, Lua has no other information about the function.
currentline: the current line where the given function is executing. When no line information is available, currentline is set to -1.
name: a reasonable name for the given function. Because functions in Lua are first-class values, they do not have a fixed name: some functions can be the value of multiple global variables, while others can be stored only in a table field. The lua_getinfo function checks how the function was called to find a suitable name. If it cannot find a name, then name is set to NULL.
namewhat: explains the name field. The value of namewhat can be "global", "local", "method", "field", "upvalue", or "" (the empty string), according to how the function was called. (Lua uses the empty string when no other option seems to apply.)
nups: the number of upvalues of the function.
用于持有关于活动函数的信息的不同事项的结构。lua_getstack只填充本结构的专用部分，留作后用。要用有用的信息填充lua_Debug的其他字段，调用lua_getinfo。
lua_Debug的字段具有下面的含义：
source: 如果函数在字符串中定义，则source就是那个字符串。如果函数在文件中定义，则source以‘@’开头后跟文件名。
short_src: 一个source的“可打印”版本，将用于错误消息中。
linedefined: 函数定义开始的行号。
lastlinedefined: 函数定义结束的行号。
what: 如果函数是Lua函数则为字符串"Lua"，如果是C函数则为"C"，如果是单元的主体部分则为"main"，并且如果是执行了尾调用的函数则为 "tail"。最后一种情况，Lua没有关于函数的其他信息。
currentline: 给定函数正执行的当前行。当没有行信息可用时，currentline被设为-1。
name: 给定函数的合适的名字。因为Lua函数是第一类值，所以它们没有固定的名字：一些函数可为多个全局变量的值，然而其他的可只存储于一个表字段中。函数lua_getinfo检查函数是如何被调用的以找到合适的名字。如果找不到，则name被设为NULL。
namewhat: 解释name字段。依据函数被如何调用，namewhat的值可为"global"、"local"、"method"、"field"、"upvalue"或""（空字符串）。（当看似没有其他选项可用时Lua使用空串。）
nups: 函数的upvalue的数量。
| int currentline |
| int event |
| int i_ci |
| int lastlinedefined |
| int linedefined |
| const char* name |
| const char* namewhat |
| int nups |
| char short_src[LUA_IDSIZE] |
| const char* source |
| const char* what |


california_housing_prices documentation!¶
This report analyzes the Random Forrest regression model for California housing prices. (A work in progress)
Summary
The model yielded an R^2 value of .83
Code on github
Contents:
Analysis¶
Jupyter notebook contents:


I am a research scientist at
NVIDIA Research, working on emerging GPU archiecture with the
computer architecture research group.
My research focuses on accelerated computing and the automation of the hardware, algorithm, and mapping co-optimization to enhance the system performance.
Previously, I earned my PhD in
Computer Science
at
UC Berkeley, where I was advised by Prof.
John Wawrzynek and collaborated closely with Prof.
Sophia Shao. During my PhD, I have worked on algorithm-hardware codesign for FPGA accelerators, HLS-based design methodology, and ML/ILP-assisted compiler optimization and hardware DSE techniques. My thesis focuses on novel design and scheduling techniques for accelerating deep learning algorithms on heterogeneous architecture. Prior to UC Berkeley, I received my B.A.Sc. from the University of Toronto, where I worked with the
LegUp research group.


{% extends "base.html" %} {% block page_body %} You are registering to receive an account on this system.


--- layout: page title: About header-img: "img/about-bg.png" ---
Flatiron School data science student and aspiring data scientist.


Our Technologies
OSRS Group is working on several key areas, we divide our work into projects which roughly cover a technology area. Each project will have multiple sub-areas and applicability to many organizations and industries.
Our industry focus dimension is accounted for separately in our active area "P" (Industry Projects and Functional Domains), which contains sub-projects for each industry domain in which we are conducting work.
Top-level General Scope Technology R&D Ongoing Project Areas:
- Area A: Geospatial and Location Technologies
- Area B: Agent Based Simulation and Computational Modeling
- Area C: Math, Logic and Numerical Computing
- Area D: Enterprise Framework and Well-Known Types
- Area E: Temporal, BiTemporal, TimeSeries, History and Archival Systems
- Area O: Open Data and Specifications
- Area M: Machine Learning and Artificial Intelligence
- Area P: Industry Projects and Functional Domains
- Area S: Cybersecurity, Anti-Tamper, Information Assurance and Data Governance
- Area W: Commons Core Technologies
- Area X: Runtimes, Virtual Machines and Programming Languages
- Area Y: Operating Systems, Containers, Distributed Environments
- Area Z: Hardware, Hardware Anti-Tamper and Physical Security
Top-level Industry Projects and Functional Domains (Area P):
- Analytics: General Purpose Risk and Comparative Risk Ratings (GRAMI)
- Data: Administrative Boundaries, Measurement Sites, Geolocation of Well-Known and Casual Locations
- Data: Biological Taxonomies and History of Changes and Common Names
- Data: Census, LODES, Commerce
- Data: Climate, Weather and Atmospherics
- Data: Land use, Land cover, Terrain and Geodetic Movement
- Data: Manufacture of Goods and General Product Taxonomies
- Data: Measurement Instruments, Sensors, Calibrations and Manufacture
- Data: People, Organizations, Contactable Parties and Addressing Systems
- Data: Real Property, Structures, Parcels and Cadastre
- Infrastructure: Drinking, Treatment and Irrigation Water Distribution
- Infrastructure: Electric Power Grid
- Infrastructure: Oil, Gas and Pipeline
- Infrastructure: Telecommunications
- Infrastructure: Transportation: Roads and Rails
- Infrastructure: Transportation: Ships, Shipping, Maritime Routes and Ports
- Infrastructure: Transportation: Airports, Air Routes, Aircraft
- Infrastructure: Transportation: Dams, Bridges
OSRS Geospatial Capabilities. Robust, deep capabilities and ESRI/OGC Compatible.
We've built custom geometry libraries for vector geometries including upcoming support for global and polar spanning features. We have support for geospatial grids of multiple cell shapes including support for a semi-uniform global grid system. Our grid capability includes support for highly multi-threaded agent-based computation using image processing inspired algorithms. We also have a robust, dynamic tessellation engine that supports creation of constrained Delaunay triangulations with mesh quality guarantees. Finally, we support a geospatial binding to our agent-based simulation framework that supports complex, dynamic computation over vector and gridded datasets for complex analysis.
Temporal Computing. What was and when did we know.
We offer several temporal capabilities including a general purpose temporal library (in development) that handles temporal data from high-precision attosecond scale to massive "history of the universe" scale. Our primary temporal areas of interest are time series/time sequence capabilities for measurement data which we support across a host of persistent data stores, and our temporal/bitemporal capability for fully temporally enabling enterprise record data. This temporal capability is designed to support geospatial data with our custom extensions for spatial-temporal interpolation of events.
Enterprise SoSD Framework Model. Easy, compact, done.
Given we invented SoSD and Systematize, we of course have a suite of libraries for providing simplified development of autonomous services which can be dynamically scaled and provisioned. Our framework model offers a distributed system of systems security, logging and configuration capability as well to keep your enterprise data and analytics flowing.
Well-Known Data System. Consume, Share, Integrate, Done.
Building on our other capabilities, we've developed an approach to integrated, distributed services for well-known data types that are efficiently shared between applications, departments and organizations in real time. No development required, just deploy an existing package or contact us to help adapt to your needs and infrastructure.
Infrastructure Analytics. Assess, Plan, Mitigate Risk.
Telecommunications, Energy, Transportation. Infrastructure is a critical resource and OSRS Group has been helping stakeholders understand and mitigate risks to critical infrastructure for over a decade. We build solutions that help decision makers and engineers understand where vulnerabilities are and more importantly, which impacts are most likely to better inform mitigation planning.


Sarah is an award-winning Speaker, Sr Cloud Developer Advocate at Microsoft, and Staff Writer at CSS-Tricks. Sarah is also the co-founder of Web Animation Workshops, with Val Head. She is the author of SVG Animations from OíReilly and has given Front-end Masters workshops on Vue.js and Advanced SVG Animations. Sarah is formerly Manager of UX Design & Engineering at Trulia (Zillow). Sarah won CSS Dev Con's Best of the Best Award as well as Best Code Wrangler from CSS Design Awards.
Phil Nash is a developer evangelist for Twilio.  Sometimes he writes open source code, which is much less stressful because if it is wrong someone else can correct it. He blogs on this site and on the Twilio blog and youíll find plenty of code there too.


The jMock Release Process
Releasing is pretty automated but there are still some manual steps.
- Tag a release using the
tag.sh
script. Tags have the
format 1.2.3-RC4 where, in this case, 1 is the
major version, 2 is the minor version and 3 is the patch number and 4 is
the release candidate number. The trailing _RC4 is optional.
- Run the release script: ./release.sh 1.2.3-RC4. Again the "-RC4" is
optional. That will publish the zips and javadoc. Zips are published
under http://www.jmock.org/dist,
javadoc under http://www.jmock.org/javadoc/.
- Update the website. This is currently entirely manual and needs to be
more automatic.
- Check out the website module from SVN and cd into the checked out directory.
- Run the
version.py
script to update the version numbers.
- Update the content/download.html document to link to the
released JARs
- Update the content/javadoc.html document to link to the
released Javadoc.
- Update the content/news-rss2.xml file to announce the new
release.
- Run make to build a local copy. Check that it all looks
ok by opening skinned/index.html and browsing the download
and javadoc pages.
- Run make published to publish the updated website.
- Commit the website changes to SVN.
- Add the new version to the list of jMock versions in JIRA (if it
doesn't already exist) and mark it as released on the current
date.


{{ support.basic.name }} |
{{ support.premium.name }} |
||||
|---|---|---|---|---|---|
| {{ key[1] }} | {% else %}{{ key[1] }} | {{ support.basic[k] }} | {{ support.premium[k] }} | {% endunless %}
Displayed prices are for an annual contract.
Support plans do not include end users. Once a support plan has been purchased it is the business's responsiblity to inform Rocket.Chat who will be their internal point of contact for the support plan. Up to three contacts are permitted per organization.
Rocket.Chat provides user information for adminstrators, end users and developers at https://rocket.chat/docs.
Premium plan subscribers are entitled to a one-hour consultation each month with a core team member. Additional hours can be purchased for a fee.
An issue affecting Rocket.Chat that prevents a business from operating as normal.
Examples include: data loss or corruption; system crashes; loss of critical functionality; large numbers of users unable to work.
The first response time is 1 hour for the Basic plan and 30 minutes for the Premium plan.
An issue affecting Rocket.Chat that causes a partial or non-critical loss of functionality.
Examples include: some system functions are unavailable; minor performance problems; small numbers of users unable to work.
The first reponse time is 12 hours for the Basic plan and 8 hours for the Premium plan.
A question, feature request or documentation issue that does not have an impact on performance.
The first response time is 2 business days for the Basic plan and 1 business day for the Premium plan.


---
layout: blocks
title: Homepage
date: 2017-11-22T23:00:00.000+00:00
page_sections:
- template: navigation-header-w-button
block: header-2
logo: "/uploads/2018/06/21/forestry-full.svg"
navigation:
- link: "/"
link_text: Home
- link: "/uslugi"
link_text: Usługi
- link: "/cennik"
link_text: Cennik
- link: "/kontakt"
link_text: Kontakt
cta:
url: https://github.com/forestryio/ubuild-jekyll/archive/master.zip
button_text: Download
- template: hero-banner-w-image
block: hero-2
headline: uBuild
design blocks
content: The tool that allows you to build beautiful sites
all inside Forestry's
content manager.
cta:
enabled: true
url: https://github.com/forestryio/ubuild-jekyll
button_text: 'See on GitHub '
image:
image: "/uploads/2018/06/21/product-shot-1.png"
alt_text: Product Shot
background_image: "/uploads/2018/06/21/hero-2-bg.png"
- template: content-feature
block: feature-1
media_alignment: Left
headline: Swap & Switch the Blocks to create sites quickly
content: Quickly assemble and create custom sites with 16 design blocks for seven
different sections.
media:
image: "/uploads/2018/06/21/blocks-split.png"
alt_text: uBuild Blocks Mock-Up
- template: content-feature
block: feature-1
media_alignment: Right
headline: Customize Blocks to make quick
edits throughout your new site
content: Each block comes with custom Front Matter that can easily be edited in
Forestry's UI.
media:
image: "/uploads/2018/06/21/edit.gif"
alt_text: Customize Blocks
- template: 1-column-text
block: one-column-1
headline: 16 Fully Responsive Design Blocks
content: "The Design Blocks can be used without Forestry but to harness the power
of Blocks we recommend using Forestry. Once the site is imported you can immediately
create new sites and make them fully customizable. \U0001F447"
- template: full-width-media-element
block: media-1
image: "/uploads/2018/06/21/theme.png"
caption: All Available Blocks
- template: detail-content
block: text-1
headline: Steps to Build a Site!
content:
uBuild is an open-source Jekyll based theme that doubles as a builder tool inside the Forestry content manager. It's easy to get started!
Fork the repo and import the site into Forestry (or use our magic button).
Click on 'Add New' in Forestry and select the Page-Builder template.
Add and customize the available Blocks and preview them as you go along.
Read our article and create your own Blocks.


Java Sample App Backend Tutorial
The Java SDK tutorial bridges the gap between simple and advanced concepts by walking through a complete web application.
The full source code for the tutorial is available on GitHub couchbaselabs/try-cb-Java.
The primary focus of the tutorial is to explain the function and theory behind the Couchbase Java client and how it works together with Couchbase Server, and especially new features in versions 4.0/4.5 like N1QL
, FTS
and sub-document
.
It makes use of the travel-sample
data set.
The code that generates the web application is provided with the source code, but is not discussed in this tutorial.
Specific Java prerequisites and set up
In addition to the prerequisites mentioned in the Sample Application, you’ll also need:
-
Your favourite IDE with a JDK 1.6+ installed (this tutorial assumes IntelliJ with JDK 1.8)
-
Maven 3
-
That’s it!
To get set up for the tutorial, follow these steps:
-
git clone https://github.com/couchbaselabs/try-cb-java.git
or download the source -
if your Couchbase Server is not running on
localhost
you can update the configuration’s hostname insrc/main/resources/application.properties
-
open the project in your IDE, import as needed and let it build
-
alternatively, go straight to running the project by executing the following command in a terminal from inside the project’s root directory:
mvn spring-boot:run
|
If you want to code it yourself, the real work is done in the following files: There’s currently no "fill-in-the-blanks" branch so you’ll have to delete method bodies and try to take it from there. |
| This tutorial focuses on querying through N1QL and FTS rather than views. If you want information about using views, see 6.0@server:learn:views/views-intro.adoc. |
Walking Through the API
The following sections lead you through the primary functions of the sample application. This shows you how to use the various features and services of Couchbase including: connecting to a cluster and bucket, key/value interactions, document query through N1QL and full text searches.
Configure and Bootstrap the SDK
Goals: Connecting to a Cluster
, getting a reference to a Bucket
and learning to reuse it.
Relevant Documentation Topics: Managing Connections using the Java SDK with Couchbase Server
The first step is to let the application connect to your cluster and obtain a reference to a Bucket
(this is your entry point for the whole storage API).
Spring Boot automatically configures a Cluster
using the @autowired
keyword by looking for the following properties in src/main/resources/application.properties
:
-
spring.couchbase.bootstrap-hosts
-
spring.couchbase.bootstrap.bucket.name
-
spring.couchbase.bootstrap.bucket.password
Note that both Cluster
and Bucket
are thread safe and must be reused across your application (if you don’t, you’ll see a warning in the logs).
Spring already knows the Cluster
is a singleton because it’s @autowired
and the Bucket
can be set up with the @Bean
keyword so that it will also be managed as a singleton in the application.
Connecting to the Cluster
public @Bean Cluster cluster() {
return CouchbaseCluster.create(hostname);
}
The cluster()
method creates the bean for the cluster reference.
Here the application uses one of the simpler factory methods, with just a hostname.
Without a hostname
, the default is to connect to localhost
.
Note that you can tune the SDK through a CouchbaseEnvironment
instance; you can pass this in as an additional first argument.
This is particularly recommended if you need to connect to multiple clusters in the same application.
You could make the bootstrap process safer by providing a list of hostnames/IPs to bootstrap from (in case the one node you provided for bootstrap is unfortunately down when creating the Cluster reference).
It is recommended for production deployments that at least 3 hostnames/IPs are used.
|
Getting a Bucket
public @Bean Bucket bucket() {
return cluster().openBucket(bucket, password);
}
The second step is to connect to the Couchbase bucket you’ll be using.
Here the application uses sample data from travel-sample
(and the application.properties
configuration reflects that).
To obtain the corresponding Bucket
from the Cluster
and register it as a @Bean
in bucket()
method, simply open it using the configured bucket
name and password
.
Both the bucket and cluster can be managed through the SDK as well (e.g. add views or create new buckets), see Managing clusters using the Java SDK with Couchbase Server for more information.
With these steps, the application is ready to use the API. In the next step, the Key/Value (KV) storage part of the API will be covered.
Manage Users using Key/Value API
Goals: Use Bucket
's Key/Value operations and discover the Document
API.
Relevant Documentation Topics: CRUD Document Operations Using the Java SDK with Couchbase Server, Asynchronous Progamming Using the Java SDK with Couchbase Server
Couchbase Server is a document oriented database which provides access to your data both through a document ID (for high performance access), as well as through views and N1QL (as powerful query languages).
This is noticeable in the API, where the methods reflect Key/Value operations (get
, create
, etc) and work with a Document
interface that has an id()
and a content.
The default Document implementation, JsonDocument
, accepts a simple representation of JSON as a content using JsonObject
.
If you already have mechanisms in place to deal with marshalling/unmarshalling of your domain objects to/from JSON, you can skip the extra step of converting them to JsonObject and use a RawJsonDocument instead.
|
Creating New Users
Since this is a @Service
, the createLogin
method will be used by the REST API and return a Result
object.
This is a standardized wrapper for results returned by this application, that the frontend can interpret.
This particular result will contain a Map<String, Object>
with some more information about the user just created.
Spring injects the Bucket reference for us, along with the request parameters username
and password
:
/**
* Create a user.
*/
public Result<Map<String, Object>> createLogin(final Bucket bucket, final String username, final String password, int expiry) {
Next the application will prepare the content for the new user (as a JsonObject) and the associated document (in order to give it an ID) and it will also set the document expiry, if one was provided:
String passHash = BCrypt.hashpw(password, BCrypt.gensalt());
JsonObject data = JsonObject.create()
.put("type", "user")
.put("name", username)
.put("password", passHash);
JsonDocument doc;
if (expiry > 0) {
doc = JsonDocument.create("user::" + username, expiry, data);
} else {
doc = JsonDocument.create("user::" + username, data);
}
The "user::" prefix is arbitrary to this application, this is just a convention that the app uses to obtain unique keys and have additional information in it, but the key could have been anything else (even sequence numbers or UUIDs).
|
Here comes the part where the application use the Couchbase Server API to store the document, it’s rather simple:
bucket.insert(doc);
Actually, the application should send a response with the content and a success flag to the HTTP client. It should also indicate failure if the SDK throws an exception, so it wraps that in a try-catch block:
try {
bucket.insert(doc);
return Result.of(
JsonObject.create().put("token", jwtService.buildToken(username)).toMap(),
narration);
} catch (Exception e) {
throw new AuthenticationServiceException("There was an error creating account");
}
|
When it comes to storing a document, you have broadly three choices of method:
|
So the result in fact just contains a JWT (Json WebToken) to identify the new user.
If there is a problem, an AuthenticationServiceException
will be thrown and correctly translated by the controller layer.
But what is this narration
object in the Result?
The frontend understands this second part of the Result, the narration, as something that it can display in a console, so that users of the application can get an idea of what is going on, on the server side while browsing the app. It is similar to a log, but sent to the frontend.
Checking Login by Getting the User’s Document
In the login
method, the application checks a User’s credential and for that it needs to retrieve the corresponding document.
Since user documents are identified by prefixing their username with user::
, this is pretty simple:
JsonDocument doc = bucket.get("user::" + username);
If that particular key doesn’t exist, the get
method returns null
.
That’s useful to check if the user exists:
if (doc == null) {
throw new AuthenticationCredentialsNotFoundException("Bad Username or Password");
}
Otherwise it’s just a matter of checking the hashed password with the one provided by the user, and responding accordingly.
Notice how the application gets the hash by calling content().getString("password")
:
//...continued
} else if(BCrypt.checkpw(password, doc.content().getString("password"))) {
return JsonObject.create()
.put("token", jwtService.buildToken(username))
.toMap();
} else {
throw new AuthenticationCredentialsNotFoundException("Bad Username or Password");
}
A Quick Glance at the Async API with RxJava
The 2.x Java SDK relies on RxJava for its asynchronous API.
It offers a powerful way of composing asynchronous streams for your processing.
The getFlightsForUser()
method can serve as a quick example of such an asynchronous call, it will return the result of a chain started with the async SDK call:
bucket.async().get("user::" + username)
RxJava’s Observable
is a push model where you describe your stream (by composing and chaining rx operators) then subscribe to it (to consume the end data).
You can also manage what to do with error notifications in the subscription.
The async()
method on Bucket will switch to the async API.
There, get
will return an Observable
in which the requested Document is emitted.
| If the requested key doesn’t exist, the async API will instead result in an empty Observable and nothing will be emitted. See below for an example of how to deal with that particular case. |
The next step in the chain is simply to extract the flight information that is needed and return it as a List
.
This is done by the transforming operator map
.
The application passes a function that will transform each emitted JsonDocument
into a List<Object>
:
.map(new Func1<JsonDocument, List<Object>>() {
@Override
public List<Object> call(JsonDocument doc) {
JsonObject data = doc.content();
JsonArray flights = data.getArray("flights");
if (flights != null) {
return flights.toList();
} else {
return Collections.emptyList();
}
}
})
In order to detect that the document doesn’t exist, the application has to do things a bit differently since the map function won’t receive a null
(it’s the enclosing Observable stream that is empty).
Fortunately, RxJava provides a method to emit a single default value if an upstream Observable is empty:
.defaultIfEmpty(Collections.emptyList())
Finally, since in this example the application still must exit the method by returning a value in a synchronous manner, it can revert to a blocking behaviour and say "we only expect a single()
value to be emitted and wait for it to return it":
.toBlocking()
.single();
| To learn more about Observables, see the Asynchronous Progamming Using the Java SDK with Couchbase Server section. |
A First N1QL Query: Finding Airports
Goals: Use N1QL and the DSL to perform your first SELECT
on Couchbase Server.
Relevant Documentation Topics: N1QL Queries Using the Java SDK with Couchbase Server.
In the SDK, there is a query
method that accepts all variants of querying with Couchbase Server (views, spatial/geo views, N1QL and FTS).
For N1QL, the N1qlQuery
is expected.
This allows you to wrap a N1QL Statement
, provide query tuning through a N1qlParams
and if necessary provide values for placeholders in the statement as a JsonObject
or JsonArray
.
| N1QL is a super-set of SQL, so if you’re familiar with SQL you’ll feel at ease. |
Statements can be provided either in String form or using the DSL.
The findAll
method is expected to return a List
(several matching rows) of Map
s representing the JSON value.
Once again, it is to be wrapped in a Result
to standardize the JSON representation for the frontend.
Spring will inject the bucket
into it and the params
attribute from the HTTP request.
From that the application will start building a Statement
:
/**
* Find all airports.
*/
public static Result<List<Map<String, Object>>> findAll(final Bucket bucket, final String params) {
Statement query;
//continued...
The application needs to select just the airport name from relevant documents in the bucket. Since it wants to filter relevant document on a criteria that depends on the input length, the query starts with "SELECT airportname FROM `travel-sample`".
AsPath prefix = select("airportname").from(i(bucket.name()));
Then it can choose the correct fields to look into depending on the length of the input.
Notice the x()
method that produces a token/expression from a string.
From there you can apply operators like eq()
(equals).
if (params.length() == 3) {
query = prefix.where(x("faa").eq(s(params.toUpperCase())));
} else if (params.length() == 4 && (params.equals(params.toUpperCase()) || params.equals(params.toLowerCase()))) {
query = prefix.where(x("icao").eq(s(params.toUpperCase())));
} else {
query = prefix.where(i("airportname").like(s(params + "%")));
}
|
Use static imports on these methods of the
|
The statement is ready!
You can view (and log it) via its toString()
method:
logQuery(query.toString());
//query.toString() example: SELECT airportname FROM `travel-sample` WHERE faa = "LAX"
Then the application needs to actually execute this statement by wrapping it in a N1qlQuery
and invoking bucket.query()
.
Here is a very simple query with no placeholders and no particular tuning of the query is necessary, so we’ll use the N1qlQuery.simple()
factory method:
N1qlQueryResult result = bucket.query(N1qlQuery.simple(query));
List<Map<String, Object>> data = extractResultOrThrow(result);
By looking at extractResultOrThrow
, you can understand the structure of the N1QL response (as represented by N1qlQueryResult
):
/**
* Extract a N1Ql result or throw if there is an issue.
*/
private static List<Map<String, Object>> extractResultOrThrow(N1qlQueryResult result) {
if (!result.finalSuccess()) {
LOGGER.warn("Query returned with errors: " + result.errors());
throw new DataRetrievalFailureException("Query error: " + result.errors());
}
List<Map<String, Object>> content = new ArrayList<Map<String, Object>>();
for (N1qlQueryRow row : result) {
content.add(row.value().toMap());
}
return content;
}
The N1qlQueryResult
has two status flags: one intermediary parseSuccess()
that indicates immediately if there is a syntax error (parseSuccess() == false
) or not, and one that indicates the definite result of the query (finalSuccess()
).
If the query is successful, it will offer a list of N1qlQueryRow
through allRows()
.
Otherwise it will have JsonObject
errors in errors()
.
That’s what the application inspects to respectively build a list of results or throw a DataRetrievalFailureException
containing all the errors.
After is has extracted the rows, it once again packages them into a Result
, augmented with the exact statement the application executed as a narration:
return Result.of(data, query.toString());
More Complex Queries: Finding Routes
Goals: Let the DSL guide you into making more complex N1QL queries.
Relevant Documentation Topics: N1QL Queries Using the Java SDK with Couchbase Server.
In this class, there are two more complex queries. The first aims at transforming the human-readable airport name for the departure and arrival airports to FAA codes:
SELECT faa AS fromAirport FROM `travel-sample` WHERE airportname = "Los Angeles Intl"
UNION SELECT faa AS toAirport FROM `travel-sample` WHERE airportname = "San Francisco Intl"
The second aims at constructing the result set of available flight paths that connect the two airports:
SELECT a.name, s.flight, s.utc, r.sourceairport, r.destinationairport, r.equipment
FROM `travel-sample` AS r
UNNEST r.schedule AS s
JOIN `travel-sample` AS a ON KEYS r.airlineid
WHERE r.sourceairport = "LAX" AND r.destinationairport = "SFO" AND s.day = 6
ORDER BY a.name ASC
Yes, you read that right, N1QL can do joins (on a single bucket or on several).
It works as long as the "foreign key" described by ON KEYS clause can be mapped to a document’s key in the joined bucket.
|
A specificity of N1QL that can be seen in the second statement is UNNEST
.
It extracts a sub-JSON and puts it at the same root level as the bucket (so its possible to do joins on each element in this sub-JSON as if they were entries in a left-hand side bucket).
For this final step, try to obtain the equivalent of these statements via the DSL and see how it guides you through the possibilities of the query language.
Indexing the Data: N1QL & GSI
Goals: Use the Index DSL to make sure data is indexed for N1QL to query it.
Index management is a bit more advanced (and is already done when loading the sample), so now that you’ve learned about N1QL, you can have a look at it.
For N1QL to work, you must first ensure that at least a Primary Index
has been created.
For that you can use the DSL from the Index
class:
Index.createPrimaryIndex().on(bucket.name())
The fluent API will guide you with the available options, you just have to declare that you want to createPrimaryIndex()
and specify on(...)
which Bucket.
You can also create secondary indexes on specific fields of the JSON, for better performance:
Index.createIndex("index_name").on(bucket.name(), "field_to_index")
In this case, give a name to your index, specify the target bucket AND the field(s) in the JSON to index.
Full Text Search: Finding Hotels
Goals: Use FTS to search for matching Hotels and use subdoc API to fetch the relevant data for each result.
Relevant Documentation Topics: Searching from the SDK, Sub-Document Operations.
In this service, hotels are searched for using more fuzzy criterias, like the content of the address or the description of an hotel. This is done using Full Text Search (FTS). When some results match the specified criteria, only the relevant data for each result to be displayed in the UI is fetched using the subdocument API.
The findHotels
method accepts two parameters, location
and description
, which are the two possible refining criteria for an hotel search.
public Result findHotels(final String location, final String description) {
ConjunctionQuery fts = SearchQuery.conjuncts(SearchQuery.term("hotel").field("type"));
A ConjunctionQuery
allows to combine multiple FTS queries into one, in an AND fashion.
That search always includes an exact match criteria that restricts it to the hotel
data type (as reflected in the type
field of the JSON document).
If the user provided a location keyword, a second component is added to the FTS query that will look for that keyword in several address-related fields of the document.
That is done in an OR fashion, using a Disjunction
this time:
if (location != null && !location.isEmpty() && !"*".equals(location)) {
fts.and(SearchQuery.disjuncts(
SearchQuery.matchPhrase(location).field("country"),
SearchQuery.matchPhrase(location).field("city"),
SearchQuery.matchPhrase(location).field("state"),
SearchQuery.matchPhrase(location).field("address")
));
}
Similarly, if a description keyword was provided by the user, the application look at the freeform text description
field and name
fields of the document:
if (description != null && !description.isEmpty() && !"*".equals(description)) {
fts.and(
SearchQuery.disjuncts(
SearchQuery.matchPhrase(description).field("description"),
SearchQuery.matchPhrase(description).field("name")
));
}
The matchPhrase
FTS query can contain several words and will search for variations of the words (e.g.
including plural forms or words with the same root).
The compound FTS query is now ready to be executed.
The application builds a SearchQuery
object out of it, which also determines which FTS index to use ("hotels") and allows you to set various parameters (like a limit of maximum 100 hits to return).
The query is logged (and kept for narration) then executed, returning a SearchQueryResult
object:
SearchQuery query = new SearchQuery("hotels", fts)
.limit(100);
logQuery(query.export().toString());
SearchQueryResult result = bucket.query(query);
The FTS results are then iterated over, and the document corresponding to each result is fetched. In actuality, only the parts of the document that will be displayed in the UI are required. This is where the sub-document API comes in.
The sub-document API allows you to fetch or mutate only a set of paths inside a JSON document, without having to send the whole document back and forth. This can save network bandwidth if the document is large and the parts that the application is interested in are small. So here the results of the FTS search are iterated over and appropriate subdoc calls are triggered:
for (SearchQueryRow row : result) {
DocumentFragment<Lookup> fragment = bucket
.lookupIn(row.id())
.get("country")
.get("city")
.get("state")
.get("address")
.get("name")
.get("description")
.execute();
Each FTS result is represented as a SearchQueryRow
which exposes the document’s id()
.
The application can use the sub-document API dedicated to fetching data (bucket.lookupIn(documentId)
) and specify what parts it wants: country, city, state, address, name and description.
It can then execute()
the sub-document specification.
In the rest of the code, the address-related fields are aggregated together and the data obtained is returned as a List<Map<String, Object>>
.
Back in the findHotels
method, the application artificially prepares a narration that reflects the subdocument specification and returns the list of data wrapped in a Result
with two narration elements: the FTS query that was executed and the subdocument specification.


{{define "Head"}} {{ template "bootstrap-table" . }} {{end}} {{define "body"}} {{template "checkAuthentication" .}}
You are logged in as ### PENDING ###. All characters you add below will be available under this login. You must also add ### PENDING ### in the characters below to access their data.
The following services are available for you to join. If the wrong character is displayed, uncheck auth from the character in the character pane below and reload this page.
| Join | Type | Service Name | Name | Reason | Entity |
|---|
| Sharing | Name | Scope Groups | Last Status | Delete |
|---|
Integration tokens allow us to determine which alliance/corporation services you can use and authenticate you automatically on these services. Your alliance or corporation can only see characters that you have with them and not out of corp alts unless you are explicitly sharing data with them in the characters table above.
| Type | Name | Delete |
|---|


Hopes are high of town hosting the Knife Angel
by Dominic RobertsonA meeting is taking place this week to see whether it will be possible to bring the ‘Knife Angel’ to Newtown.
Powys County Council’s anti-poverty champion, Councillor Joy Jones is putting together a team of helpers including Dyfed-Powys Police and Crime Commissioner Dafydd Llywelyn, to bring the iconic monument to Wales for the first time.
The Knife Angel is on a tour of the UK at the moment and will be outside Chester Cathedral until the end of the month.
Councillor Jones, explained: “This is a very special national monument and we will be very lucky to have it here. Its purpose is 28 days of youth and anti-violence workshops and programmes.
“I have asked the Dyfed-Powys Police and Crime Commissioner Dafydd Llywelyn if he would help bring this to Newtown and it is beginning to look positive.
“We have a meeting with the people from the British Ironwork Centre to discuss if and when we can bring this to Newtown.
Councillor Jones says that if they receive the go-ahead and a date for when the Knife Angel can be brought to Newtown, she will put together a team to help her which includes members of the council cabinet, who have been “very supportive” of her idea.
Councillor Jones added: “I did put the idea on Facebook over the weekend to find out what people though of the idea and received a lot of positive messages.
“I’m determined we can do this.”
“I have already had offers of help in bringing the angel to Newtown as well as where to place it.”
Weapons
A spokesperson for the Dyfed-Powys Police and Crime Commissioner, Mr Llywelyn said that they would be joining Councillor Jones at the meeting.
The monument was created at the British Ironwork Centre just over the border near Oswestry and is a “national monument against violence and aggression”.
The Knife Angel was created from knives collected from 43 police forces all around the country.
A spokesperson for the British Ironwork Centre, said: “Once the knives and weapons were delivered to our workshop, artist Alfie Bradley got to work.
“He created a structure out of steel and formed the basic shape which the knives could then be welded onto.
“Steel sheeting formed the external, organic shape of the angel.
“Each knife was blunted before welding it onto the sculpture.
“The wings were then created using the blades only, creating a feather like appearance.
“Working so closely with the families has been crucial in campaigning and raising awareness throughout the campaign.”
Part of the the Knife Angel’s work is to promote a petition supporting a “Save a Life – Surrender you Knife” campaign that has already been signed by nearly 16,000 people.
The petition can be found at change.org


Goal:
Add a tutorial to the menu structure.
Steps to complete:
- Copy the the following files to TE/tutorials/myTutorials
- TE/tutorials/TE/newTutorial
- TE/tutorials/TE/menu_04_newTutorial.xml
See the effects of your work
(Click here for an example of the expected results of this step)
- Reload the main menu by navigating to File → Reload Menu
- Note: the menu must be reloaded to view any changes made to the menu structure
- Navigate to Learn → My Tutorials
You will now see a new tutorial, 'New Tutorial' under 'My Tutorials'.
The changes are indicated with the following:
- Indicated text has been removed
- Indicated text has been edited
- Indicated text has been added
- Indicated text is the source of a copy


Before jumping into writing your own application, it might be useful to compile and run an existing sample application. This chapter will take you through the generic steps of checking out a source file, compiling it, then running the compiled application on the emulator with the Swat debugger attached. The next two chapters explore GEOS development in greater detail by stepping through every step in creating the application "Tutorial". We recommend that you step through this chapter to acquaint yourself with the generic process of compiling an application, then carefully follow the tutorial to get a flavor for GOC, Swat debugging, and Geode Parameter files.
Typically, your development sequence will follow these steps:
mkmf
utility;
pmake
utility;The next section follows this sequence using the Dialogs sample application, though of course the same steps apply for any sample application. (Refer to the release notes in the README.TXT file or the Troubleshooting guide in the "Installing the SDK" chapter if you encounter problems.)
In the directory paths below, prepend your correct drive letter or path to PCGEOS and replace "workingdir" as appropriate. Also note that if you are using the Nokia 9000i SDK version 2.0, the directory labled here as N9000v11
will be N9000v20
in your development branch.
CD PCGEOS\workingdir\APPL
MD SDK_9000\DIALOGS CD SDK_9000\DIALOGS
COPY \PCGEOS\N9000V11\APPL\SDK_9000\DIALOGS\DIALOGS.GOC
mkmf
to create the makefile.
pmake
to compile and link the executable. This will create an error-checking version called
DIALOGSEC.GEO
.
start ss
.
start pcgeos\bin\swat
. (The full path is only necessary if there is also a Swat stub in your current directory, which you
do not
want to run.)
c
to continue.
Ctrl-W
to clear the "Where is it" default; then type
i
(lower-case) to ignore that file.
Ctrl-C
, then using the
Ctrl-W
,
i
sequence described above to ignore the file.
Ctrl-C
in the Swat window to bring command control back to Swat.
send dialogs
.
c
to continue Swat.
Ctrl-F12
to launch the Extras folder.
F1
to launch it. (The keys F1 - F4 correspond to the menu list on the right of the emulator window.)
Ctrl-C
to bring command control back to Swat, then type
quit
to exit the emulator.In this section, you learned how to check out a source code file by copying it from the Branch directory to your Working Directory, and then compile and run it on the emulator. Notice that it was not necessary to copy all the files from the \DIALOGS\ subdirectory in the N9000v11 Branch. When compiling and linking, the tools are smart enough to look for files in your Working Directory first and then look for whatever other files it needs in the Branch directory. This allows you to copy only the file or files you need to work on; shared files can remain in the Branch directory.
Now that you've gone through the basic steps of compiling and running a GEOS application, you can go on to the next chapter to create your own application from scratch.