CCTL is a serial bootloader for the Chipcon CC1110/CC1111 using only one 1KB page of flash. It allows update of the the microcontroller firmware over its serial port.
The bootloader consists of two components, a piece of firmware that is flashed
onto the device and a utility for downloading code and manipulating the
flash memory. The client program, cctl-prog
runs on Linux, OSX/Darwin and Windows.
Joby Taffey (c) 2012<EMAIL_ADDRESS>Portions originally from CC Bootloader, Fergus Noble (c) 2011
The first step is to flash your device with the cctl.hex
firmware file. A prebuilt version prebuilt-cctl.hex
is provided.
Once the device is flashed with this firmware it will identify itself over the serial interface with the message "CCTL" on reset.
The microcontroller is configured for 115200, 8N1 transmitting on P0.3, receiving on P0.2. Note that the CC111x is not 5v tolerant, so be sure to use a 3v serial adapter.
You can now use cctl-prog to download your payload code. A prebuilt version of cctl-prog.exe is provided for Windows. For Linux or OSX, type "make".
For usage instructions, run cctl-prog with no arguments:
./cctl-prog
ChipCon Tiny Loader Programmer
cctl-prog -d /dev/ttyXYZ [-c] [-f file.hex]
--help -h This help
--console -c Connect console to serial port on device
--flash=file.hex -f file.hex Reflash device with intel hex file
--timeout=n -t n Search for bootload string for n seconds
If both --console
and --flash
are specified, then the device will be reflashed first, then the console will connect.
Before flashing, cctl-prog
sends the string "+++", which firmware can detect
and reset automatically.
Preparing your user code for usage with the bootloader is very simple. All you
need to do is set your linker to start the code section at 0x400. For an
example of this see the Makefile
file in the example_payload
subdirectory.
This is the relevant line:
LDFLAGS_FLASH = ... --code-loc 0x400 ...
This requires sdcc (Small Device C Compiler). Then it should be as simple as issuing
make
from the root directory of the project.
The code has been tested with SDCC version 3.0.0
CCTL uses a custom binary serial protocol, running at 115200bps, 8 bits, no party, 1 stop bit.
On reset, the bootloader prints "\r\nCCTL\r\n" followed by "B" up to 8 times with a delay between each. If the bootloader receives any character before printing "B" 8 times, it will enter upgrade mode.
If no character is received, the bootloader will attempt to launch user code from 0x400.
The bootloader enables the watchdog with a 1s timeout while running. It does not engage the hardware watchdog when jumping to user code (as the watchdog cannot be disabled making it incompatible with applications which remain in deep sleep for long periods).
Once in upgrade mode, the bootloader expects to receive at least one character per second, else it will reset using the hardware watchdog.
In upgrade mode, the following commands are available:
Jumps to user code. On failure, the device will reset.
-> j
Erase a 1KB page of flash. On completion, \0
is sent
-> e
, uint8_t page
(0-31)
<- \0
Read a 1KB page from flash. Sends 1024 raw bytes. On completion, '\0' is sent
-> r
, uint8_t page
(0-31)
<- uint8_t data[1024]
, \0
Loads 1KB page from serial into a RAM buffer. Receives 1024 raw bytes. On completion, '\0' is sent
-> l
, uint8_t data[1024]
<- \0
Program a 1KB page of flash from RAM buffer. On completion, \0
is sent
-> p
, uint8_t page
(0-31)
<- \0
CCTL resides in the first flash page, 0x0000 to 0x0400. On reset, the CC1110 begins executing from address 0x0000 where it finds the CCTL reset vector.
CCTL provides a vector table which jumps to the relevant vector in application code at 0x400 + offset.
For interrupts which are used by both CCTL and application code, CCTL looks at the F1 user flag in the PSW register. When this flag is 0, the bootloader isr is called, when 1, the application isr is called.
Application code should not modify PSW.F1.
The CC111x is programmed with a SPI like protocol using a hardware programmer. The protocol is given in detail in http://focus.ti.com/lit/ug/swra124/swra124.pdf
(CCTL is placed in the flash using this protocol, it is different to the serial protocol).
Official hardware programmer
Third-party hardware programmers
Open source implementations of protcol
cctl-prog
is currently built for Windows using the mingw32 cross compiler from Linux.
make -f Makefile.mingw32
The Linux/OSX version of cctl-prog
compiles and runs under cygwin.
Run the createdevices.sh script in cygwin to populate /dev.
In cygwin COM ports are available as /dev/ttySX.  COM7 = /dev/ttyS6


To add filters in data grid set filterEnable to "true" in column definations.
To toggle filters, set showFilters to "true" or "false" in grid defination. Show filters
Default value for showFilters is "true".
To reset filters, "Reset" option is given in filter operator's dropdown. It will be enabled when any filter operator is selected.
On selecting "Reset" filter will be removed from that column.
In Client side data grid all filter oprations will be done on client side.
In Server side data grid filterColumns will be passed to onLoadData(options:LoadOptions).
Which will contains array of all filter columns as {{ '{' }} column : string,
filterOperator: string, filterValue: string, dataType: string {{'}'}}
Possible values for filterOperator are startswith, endswith, contains, gt, lt, ge, le, eq, ne.
Possible values for dataType are number, string, date, boolean.
options:{{currentLoadOptions | json}}


United Drugstore Inc
- TGT:
- Php 1,232,827.00
- EI:
- Php 800,00.00
- MS:
- 2.6
- SO:
- Php 340,523.22
- SI:
- Php 220,523.22
- AR:
- 93.33%
- RPS:
- 96.87%
- IMPL:
- 100% (20/20)
- NPD:
- 93.33% (14/15)
event notification: NPD Memo & Sample
event notification: Check the Neozep 5+1 ISB
-
Chat started by Andy Martinez • 4:58 PM
-
Chat ended by Andy Martinez • 5:30 PM


{# This file is a modified version of the equivalent file in the pinpayments app. #} {# The 'modified_' prefix is necessary to avoid a collision with the unmodified template. #} {% load i18n %}


Are you sure you want to delete this expense report? You would loose all the associated expenses to this report.


Nouns and Pronouns
Nouns can be one of the easiest words to learn in Japanese. However, memorizing over 6,000 words isn't an easy task. When you learn nouns, you create a framework that is paired with grammar to express the things we want to talk about.
We will also introduce pronouns, which are words that indirectly refer to people, direction, and things that require context to be properly understood.
Nouns
In simple terms, a
noun
名詞
represents a person, place, state, quality, event, or thing. In Japanese, nouns have no number or gender.
This means that there is no distinction between singular and plural forms or masculine and feminine forms.
There is also no articles like "a", "an", or "the" that accompany nouns like in English.
The following table shows the most common nouns in Japanese. These words are written with the most basic
Kanji漢字
that are taught early on in Japanese education.
| Noun | Meaning |
|---|---|
| カラオケ | Karaoke |
| ラーメン | Ramen |
| 空手 | Karate |
| お酒 | Alcohol |
| 寿司 | Sushi |
| 山 | Mountain |
| アニメ | Anime |
Grammar Note: Making nouns plural, although not common, is still possible. One method involves the suffixたち, which is typically used to refer to a group of people or (living) things.
Examples:
1. 女性たち
(Group of) women.
2. 男性たち
(Group of) men.
3. 犬たち
(Group of) dogs.
Proper Nouns
In English, a proper noun is a noun that indicates an individual person, place, organization, etc. and is
spelled with an initial capital letter. In Japanese, words are not capitalized, but the concept of a proper
noun 固有名詞
still exists.
| Proper Nouns | Meaning |
|---|---|
| 東京 | Tokyo |
| 京都 | Kyoto |
| 大阪 | Osaka |
| 横浜 | Yokohama |
| 日本 | Japan |
| アメリカ | America |
| ロシア | Russia |
Loanwords
A loanword is a word borrowed from another lanuage. Loanwords in Japanese are called 外来語
and are
typically borrowed from modern languages in the last two to three centuries. Words borrowed from the Chinese
language during it's development are called 漢語
and are treated separately. Words that came in
recent
centuries are treated as 外来語.
The vast majority of loanwords come from English. We must remember to treat these loanwords as Japanese words. This means you can't simpy pronounce it as if it were English. Some examples can be found in the following table.
| Loanwords | Meaning |
|---|---|
| メートル | Meter |
| ゲーム | Game |
| バス | Bus |
| ペン | Pen |
| ソファー | Sofa |
| パイ | Pie/pi |
| ポイント | Point |
Grammatical Person
A pronoun 代名詞 indirectly refers to an entity that involves a person, direction, or thing. The meaning of said entity is determined by context. For instance, proper names are pronouns because they stand in place of the actual person/thing they reference. Proper names can also be shared with others or other things, and so we need context to truly understand what is meant by saying the name "Seth"
Words like "here" and "there" or even words like "this" and "that" are pronouns. This is becasue no one can ascertain what they refer to without context.
Generally when we think of pronouns, we think of pronouns that are used to establish grammatical person. The following tables show the distinctions in English of grammatical person.
| Person | Singular | Plural |
|---|---|---|
| 1st | I | We |
| 2nd | You | You (all) |
| 3rd | He/she/it | They |
Gender and number both play a role in English in determining what grammatical person is used in a sentence. However, in Japanese there isn't a single pronoun that corresponds to each of the pronouns for grammatical person. This means there is more than one word for "I", "we", etc. This is beacuse all pronouns in Japanese started out as typical nouns, or were far vaguer pronouns that didn't match up with grammatical person.
In Japanese, pronouns differ by their politeness and by who actually uses them. Many pronouns are reserved for whether the speaker is male or female, or whether the person is young or old. Dialects also effect which pronouns are used.
The following pronouns listed in the table below are the most essential.
| Person | Singular | Plural |
|---|---|---|
| 1st | 私 僕 |
私たち 僕たち |
| 2nd | あなた | あなたたち |
| 3rd | 彼 彼女 |
彼ら 彼女たち |
Usage Notes:
- わたくし is the respectful form of 私. Typically わたし will suffice in most situtations. However, "I" is often dropped altogether. As long as it's known that the sentence is about oneself, there is no need to use the pronoun "I".
- 僕 is another pronoun for "I" and is used heavily by male speakers, both young and old.
- There are many pronouns for "you", but the most neutral in terms of politeness and purpose is あなた. However it is also typically dropped from most sentences. It is inherently direct, which is a quality not typically found in statments directed at others. Second person statments are rarely stated in absolute terms, usually referring to others in third person.
- あなた may be used as a term of endearment to refer to one's male partner/spouse, both when one is happy and mad at one's significant other.
- In casual settings, the pronouns 彼 and 彼女 may respectively mean "boyfriend" and "girlfriend".
- The plural form of 彼, 彼ら uses the ら suffix making it plural.
- 彼ら may refer to a group of people with both men and women, but 彼女たち only refers to groups of women.
- The pronoun "it" is omitted because it's combined in Japanese with the concept of "that".
In English, pronouns change form depending on their grammatical purpose in a sentence. In grammar, this is called grammatical case. Pronouns change the most in English depending on their case. An example is "my" which is the possessive form of "I".
In Japanese, grammatical case is marked by the use of "case particles". Case particles take the place of form change to noun/pronouns to indicate what function the word has in the sentence. For pronouns, there are two grammatical cases you should know about: nominative and possessive.
- Nominative Case (subjective): Noun/pronoun used as the subject of the sentence (person or thing that is doing an action).
- Possessive Case: Noun/pronoun form that shows ownership of one noun by another.
- I am an America man. (I = nominative)
- Your dog is adorable. (Your = possessive)
- We are scientists. (We = nominative)
- Our goal is world peace. (Our = possessive)
The subject of a sentence is the person/thing that performs an action or exhibits some description which is what the sentence is about. By adding a case particle to a noun/pronoun we express these grammatical concepts. We add が to the noun/pronoun for nominative cases. We use の for possessive cases. The following table shows examples of these cases.
| Nominative | Possessive | ||
|---|---|---|---|
| I | 私が 僕が |
My | 私の 僕の |
| We | 私たちが 僕たちが |
Our | 私たちの 僕たちの |
| You | あなたが | Your | あなたの |
| You (all) | あなたたちが | Your | あなたたちの |
|
He She |
彼が 彼女が |
His Her |
彼の 彼女の |
| They | 彼らが 彼女たちが |
Their | 彼らの 彼女たちの |
Grammar note: To make a third person reference into the possessive case, just add の to whatever name your using. This means "Seth's" would be セスの.
Place and Things
Pronouns used for place and thing are also not used exactly like their English counterparts. See the following table for examples.
| Close to speaker | Close to listener/known only to speaker | Far from speaker and listener/known to both speaker and listener |
|---|---|---|
| Here | There | Over there |
| ここ | そこ | あそこ |
| This | That | That over there |
| これ | それ | あれ |
Table notes: これ is the closest Japanese equivalent to "it".
When speaking about entities physically visible, there is a three-way distinction made based on the proximity of the entity from the speaker and listener. When the entity discussed is not physically visible, there is a two-way distinction made based on who knows abut the entity in question. The criterion then becomes whether only the speaker knows about the entity or if both the speaker and listener(s) know about it.


Interior designers make the interior spaces aesthetically pleasing. safe, and functional. We do this by reading blueprints and determining the space for a selection of items such as furniture, lighting, and other materials. We also have to be aware of regulations for buildings, building codes, and accessibility standards. Engineers and architectures work closely with us as well.


Créer les conditions de l’employabilité dans un monde en mutation.
Chapter I, page XV
1.Comment redéployer massivement les compétences et les métiers ? Quels dispositifs nouveaux (et véritablement efficaces) pour mettre en œuvre la formation professionnelle ?
2. Quel rôle de l’entreprise, et celui du salarié, dans le maintien et le développement des compétences et des savoirs adaptés au monde d’aujourd’hui ?
3. Comment favoriser les passages d’un secteur d’activité à un autre ?
Chapter I, page XV
A Prophet sat in the market-place and told the fortunes of all who cared to engage his services. Suddenly there came running up one who told him that his house had been broken into by thieves, and that they had made off with everything they could lay hands on.
Chapter I, page XV
A Prophet sat in the market-place and told the fortunes of all who cared to engage his services. Suddenly there came running up one who told him that his house had been broken into by thieves, and that they had made off with everything they could lay hands on.
Chapter II, page VII
A thirsty Crow found a Pitcher with some water in it, but so little was there that, try as she might, she could not reach it with her beak, and it seemed as though she would die of thirst within sight of the remedy.
Chapter III, page XI
Every man carries Two Bags about with him, one in front and one behind, and both are packed full of faults. The Bag in front contains his neighbours’ faults, the one behind his own. Hence it is that men do not see their own faults, but never fail to see those of others.
Créer les conditions de l’employabilité dans un monde en mutation.
Chapter I, page XV


{% extends "content_template.html" %} {% from "components/service-link.html" import service_link %} {# Used by the content_template.html layout, prefixes the "navigation" accessible name #} {% set navigation_label_prefix = 'Using Notify' %} {% block per_page_title %} Team members and permissions {% endblock %} {% block content_column_content %}
Notify lets you set different permissions for each member of your team.
Go to the {{ service_link(current_service, 'main.manage_users', 'team members') }} page to:
You must add at least one team member with the ‘manage settings, team and usage’ permission. This person will be responsible for your service if you’re unable to sign in to Notify.
You can invite team members who do not have a government email address.
{% endblock %}


In Angular, templates are written with HTML that contains Angular-specific elements and attributes. Angular combines the template with information from the model and controller to render the dynamic view that a user sees in the browser.
These are the types of Angular elements and attributes you can use:
{{ }}
to bind expressions
to elements is built-in Angular markup.The following code snippet shows a template with directives and curly-brace expression bindings:
<html ng-app>
<!-- Body tag augmented with ngController directive -->
<body ng-controller="MyController">
<input ng-model="foo" value="bar">
<!-- Button tag with ng-click directive, and
string expression 'buttonText'
wrapped in "{{ }}" markup -->
<button ng-click="changeFoo()">{{buttonText}}</button>
<script src="angular.js">
</body>
</html>
In a simple app, the template consists of HTML, CSS, and Angular directives contained
in just one HTML file (usually index.html
).
In a more complex app, you can display multiple views within one main page using "partials" – segments of template located in separate HTML files. You can use the ngView directive to load partials based on configuration passed to the $route service. The angular tutorial shows this technique in steps seven and eight.


Below is a list of file formats that were identified by Fido. Clicking on the PRONOM ID for the format will display information about the format in PRONOM.
| PRONOM ID | Name | Files |
|---|---|---|
| {{ m.id }} | {{ fondz.formats.get(m.id).name }} | {{ humanize.intcomma(m.files|count) }} |


Dashboard
Council Member
Professors and D.Sc
Faculty Staff
Guests
Meeting Agenda
Voting Card
Minutes
Message
Settings
General Settings
Account
PWR Faculty Council Meeting Application
admin
Edit Profile
change password
Log Out
Admin dashboard
0
Council Members
Total Council Members
0
Agendas
Total Agendas
0
Voting Cards
Total Voting Cards


We can change the state of an object by making an assignment to one of its instance variables. For example, we could change the numerator of the fraction by assigning a new value to self.num. Likewise, we could do the same thing for self.den.
One place where this type of modification makes sense is when we place a fraction in lowest terms. Lowest terms simply means that the numerator and denominator do not share any common factors. For example, 12/16 is a fraction but it is not in lowest terms since 2 can divide into both 12 and 16. We call 2 a common divisor. If we divide the numerator and the denominator by a common divisor, we get an equivalent fraction. If we divide by the greatest common divisor, we will get the lowest terms representation. In this case 4 would be the greatest common divisor and the lowest terms representation would be 3/4.
There is a very nice iterative method for computing the greatest common divisor of two integers. Try to run the function on a number of different examples.
Now that we have a function that can help us with finding the greatest common divisor, we can use that to implement a fraction method called simplify. We will ask the fraction “to put itself in lowest terms”.
The simplify method will pass the numerator and the denominator to the gcd function to find the greatest common divisor. It will then modify itself by dividing its num and its den by that value.
There are two important things to note about this implementation. First, the gcd function is not a method of the class. It does not belong to Fraction. Instead it is a function that is used by Fraction to assist in a task that needs to be performed. This type of function is often called a helper function. Second, the simplify method does not return anything. Its job is to modify the object itself. This type of method is known as a mutator method because it mutates or changes the internal state of the object.


|
SuanShu, a Java numerical and statistical library | |||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object com.numericalmethod.suanshu.stats.test.HypothesisTest com.numericalmethod.suanshu.stats.test.distribution.pearson.ChiSquare4Independence
public class ChiSquare4Independence
Pearson's chi-square test of independence assesses whether paired observations on two variables, expressed in a contingency table, are independent of each other.
| Nested Class Summary | |
|---|---|
static class |
ChiSquare4Independence.Type
the distribution used for the test |
| Field Summary |
|---|
| Fields inherited from class com.numericalmethod.suanshu.stats.test.HypothesisTest |
|---|
k, N, pValue, testStatistics |
| Constructor Summary | |
|---|---|
ChiSquare4Independence(Matrix sample)
Assess whether the two random variable in the contingency table is independent. |
|
ChiSquare4Independence(Matrix sample,
int nSim,
ChiSquare4Independence.Type type)
Assess whether the two random variable in the contingency table is independent. |
| Method Summary | |
|---|---|
java.lang.String |
alternativeHypothesis()
Get a description of the alternative hypothesis. |
static Matrix |
expectedContingencyTable(int[] rowSums,
int[] colSums)
Assume the null hypothesis of independence, we compute the expected frequency of each category. |
java.lang.String |
nullHypothesis()
Get a description of the null hypothesis. |
static double |
pearsonStat(Matrix O,
Matrix E,
boolean YatesContinuityCorrection)
Compute the Pearson's cumulative test statistic, which asymptotically approaches a χ2 distribution. |
| Methods inherited from class com.numericalmethod.suanshu.stats.test.HypothesisTest |
|---|
oneSidedPvalue, pValue, rejectNull, testStatistics |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public ChiSquare4Independence(Matrix sample, int nSim, ChiSquare4Independence.Type type)
sample
- a contingency tablenSim
- number of simulation when EXACT distribution is usedtype
- the type of distributionpublic ChiSquare4Independence(Matrix sample)
sample
- a contingency table| Method Detail |
|---|
public java.lang.String nullHypothesis()
HypothesisTest
nullHypothesis
in class HypothesisTest
public java.lang.String alternativeHypothesis()
HypothesisTest
alternativeHypothesis
in class HypothesisTest
public static Matrix expectedContingencyTable(int[] rowSums, int[] colSums)
rowSums
- row totalscolSums
- column totals
public static double pearsonStat(Matrix O, Matrix E, boolean YatesContinuityCorrection)
O
- the observation matrixE
- the expectation matrixYatesContinuityCorrection
- true iff to minus 0.5 for each observation in the test statistics
|
SuanShu, a Java numerical and statistical library | |||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


We provide a range of bespoke rainwater harvesting filters. RW filtration was cumbersome, labor-intensive because of lack of rw specific filtration units and high maintenance requirement. But with our range of filters we resolve that issue, reduce amount of excavation make retrofitting easier, outlet water can be directly reused (filtration up to 200 microns) for gardening, toilets, etc. , filters approved by most state govt bodies.
Dignissimos asperiores vitae velit veniam totam fuga molestias accusamus alias autem provident. Odit ab aliquam dolor eius.
It is a filter designed specifically for rooftop rainwater filtration. It consists of a filter element, which is capable of physical filtration up to 250 microns and in-build first-flush/bypass arrangement.
Rainwater filter is crucial if you intend to recharge rainwater in ground or reuse it for domestic purposes.
Easier to retrofit, minimum damage to existing structure, low maintenance, small footprint, first flush and bypass arrangement is easy to operate and handy. No water logging so no change of mosquito breeding.
Conventional filters are not rainwater specific and hence may not effectively filter rainwater for reuse or recharging purposes.
Physical impurities that get accumulated on the filter cartridge need to be periodically removed and cleaned. It is a simple 15 min activity and is required to be performed 5 times in a year - once every month during monsoons (June, July, Aug, Sept) and once just before monsoons in May. Cartridge replacement is recommended every 4 years.
For domestic application one filter is recommended for every 1000 sq ft of rooftop area. For industrial applications Ira team needs to do the sizing exercise.
Yes. For rooftop filters there is wall mounting brackets and inlet/outlet bypass connection, which a skilled plumber can do quickly and appropriately.
Yes.There is 1year warranty by the manufacturer.


| Sr | Fieldname | Type | Label | Options |
|---|---|---|---|---|
| 1 | column_break0 |
Column Break | ||
| 2 | company |
Link | Company | Company |
| 3 | employment_type |
Link |
Employment Type
Leave blank if considered for all employee types |
Employment Type |
| 4 | branch |
Link |
Branch
Leave blank if considered for all branches |
Branch |
| 5 | department |
Link |
Department
Leave blank if considered for all departments |
Department |
| 6 | designation |
Link |
Designation
Leave blank if considered for all designations |
Designation |
| 7 | column_break1 |
Column Break | ||
| 8 | from_date |
Date | From Date | |
| 9 | to_date |
Date | To Date | |
| 10 | leave_type |
Link | Leave Type | Leave Type |
| 11 | carry_forward |
Check |
Carry Forward
Please select Carry Forward if you also want to include previous fiscal year's balance leaves to this fiscal year |
|
| 12 | no_of_days |
Float | New Leaves Allocated (In Days) | |
| 13 | allocate |
Button | Allocate |
allocate_leave |
Inherits from frappe.model.document.Document
No docs
No docs
No docs
No docs


Enum XDataQueryStructureExceptionType
Query structure exception types
Namespace: XData.Exceptions
Assembly: XData.docfx.dll
Syntax
public enum XDataQueryStructureExceptionType
Fields
| Name | Description |
|---|---|
| AddTreeFilterError | Tree filter (START WITH) generation failed |
| AddTreeLinkError | Tree link (CONNECT BY PRIOR) filter generation failed |
| CallNonProcedureBasedStructureError | Call of non procedure based structure |
| DictionaryTableHasComplexPrimaryKeyError | Dictionary table has complex primary key |
| DictionaryTableHasNoPrimaryKeyError | Dictionary table has no primary key |
| EmptyQueryError | Empty query text generated error |
| FieldNotFoundError | Field not found |
| FilterCombinationNotFoundError | Filter combination not found |
| FindPropertyError | Property not found error |
| GetParentStructureError | Parent structure type not found error |
| HierarchyOnComplexPrimaryKeyTableError | Table with hierarchy has complex primary key |
| HierarchyOnNoPrimaryKeyTableError | Table with hierarchy has no primary key |
| IdPropertyNotFoundError | Id property not found |
| InnerViewNotFoundError | No inner view found for alias |
| LinkedPropertyNotFoundError | Linked property not found |
| LinkToProcedureFoundError | SQL stored procedure can not be linked |
| LinqExpressionCannotBeParsedError | LINQ expression can not be parsed |
| LinqExpressionHasUnknownMethodError | LINQ expression contains unknown method error |
| LinqExpressionHasUnsupportedMethodError | LINQ expression contains unsupported method |
| LinqExpressionHasUnsupportedMethodParametersError | LINQ expression contains unsupported method parameter count error |
| LinqExpressionHasUnsupportedTypeError | LINQ expression contains unsupported in this case expression type |
| NoDataSourceMappingFoundError | Data source mapping not found |
| NoElementsAtPositionError | Sequence contains no elements at position error |
| NoElementsError | Sequence contains no elements error |
| NoMappingFoundError | No mapping found for data object |
| NoneBasedObjectHasTablesError | Can't build data object based on NONE table contains other tables error |
| NoPropertyMappingFoundError | Property mapping not found |
| NoSelectedFieldsFoundError | Selected fields list is empty error |
| PropertyEnumValueNotFoundError | Property enum values not found |
| PropertyNotFoundError | Property not found (or not mapped) |
| ResultSetMappingExpressionError | SQL stored procedure / function result set expression mapping used |
| ResultSetNotRegisteredError | Result set not registered |
| RuntimeFilterUsedInsideDynamicQuery | Runtime filter used inside dynamic query |
| SubqueryAliasDuplicatedError | Subquery alias duplicated |
| SubqueryNotFoundError | No subquery found for alias |
| TableNotFoundError | Table source not found |
| WrongDataSourceTypeError | Wrong data source type used |
| WrongLoadChildPropertyTypeError | Serialize child repository wrong target property type |


[§236D-18] Disposition of revenues. All moneys collected under this chapter shall be state realizations, to be kept and accounted for as provided by law. [L 1983, c 217, pt of §1]


Join LinkedIn Today Sing Up First Name: Last Name: Email: Password: 6 or more characters Already on LinkedIn? Sing In


Military Background
Service Branch
Army
Navy
Marine Corp
Air Force
Other
Honerable Discharge?
yes
no
Duty Status
Active
Reserve
IRR
Other
Upload DD214
Not Military


How to Train Yourself
Actually twee pour-over Thundercats eiusmod. Blog taxidermy American Apparel, chillwave Intelligentsia four dollar toast labore nulla locavore church-key aute.
Continue ReadingWe understand that technology is evolving in a fast pace and keeping up can be daunting task. Our goal is to help you take a step back, take a breath, evaluate what is solid technology versus what could possibly be a fad. Our success is the direct reflection of your success with our partnership.
At Cielo Concepts The discovery process is the first step to a sucessful project. The Scope and depth of research and inquiry will differ from project to project, but the results are the same: valuable data. The more information you gather, interpret, and comprehend, the more prepared you will be to execute a site on budget and on target.
Drawing from the information gathered from the discovery phase, it’s time to determine the look and feel of your application or site. Along with wireframing and prototyping, the overall visual style will most likely be determined by the visual brand of the organization; the goal being to connect the Web with all other forms of the organization’s communications.
At Cielo Concepts Inc. we build websites and apps that perform. We believe the best technology is seamless to design. We apply and innovate upon enterprise or open source technologies to deliver solutions that perform for your company and your users. With a full team of developers working on cutting-edge solutions, we customize interactive development for all you needs.
Sometimes a bad production deployment can ruin all the effort you invested in a development process. Having a solid deployment workflow can become one of the greatest advantages of your team. What seems like a simple thing can actually be quite complex. At Cielo Concepts Inc., we will safely deploy your application though Development, Staging and Production enviroments.
Seitan brunch meh, food truck Wes Anderson quinoa XOXO readymade gastropub gluten-free heirloom wolf skateboard.
Seitan brunch meh, food truck Wes Anderson quinoa XOXO readymade gastropub gluten-free heirloom wolf skateboard.
Seitan brunch meh, food truck Wes Anderson quinoa XOXO readymade gastropub gluten-free heirloom wolf skateboard.
Seitan brunch meh, food truck Wes Anderson quinoa XOXO readymade gastropub gluten-free heirloom wolf skateboard.
Seitan brunch meh, food truck Wes Anderson quinoa XOXO readymade gastropub gluten-free heirloom wolf skateboard.
Seitan brunch meh, food truck Wes Anderson quinoa XOXO readymade gastropub gluten-free heirloom wolf skateboard.
American Apparel brunch Marfa biodiesel butcher chambray
four dollar toast sartorial tattooed cronut.
Actually twee pour-over Thundercats eiusmod. Blog taxidermy American Apparel, chillwave Intelligentsia four dollar toast labore nulla locavore church-key aute.
Continue ReadingVero tousled retro wayfarers polaroid fixie, leggings fugiat ugh sartorial sapiente. 3 wolf moon flannel lo-fi, est kitsch distillery cold-pressed banjo Blue Bottle.
Continue ReadingDreamcatcher four loko readymade typewriter. Jean shorts sed raw denim, skateboard tote bag typewriter Schlitz. Proident Banksy nostrud food truck dolore.
Continue ReadingNormcore keffiyeh Helvetica tousled, Tumblr cardigan four dollar toast Marfa Thundercats mixtape narwhal YOLO. Freegan food truck tattooed, authentic.
Continue ReadingHigh Life tofu readymade. Asymmetrical sustainable fixie fingerstache pour-over. Selfies beard meh DIY fixie you probably haven't heard of them.
Continue ReadingYOLO polaroid selvage, pour-over drinking vinegar roof party Pitchfork meditation Echo Park mixtape 8-bit 90's gluten-free keffiyeh flannel. Biodiesel trust fund keffiyeh bitters.
Continue Reading“Disemboweling in your species: fatal or non-fatal? I can explain. It's very valuable. Look, last night was a mistake. Enough about your promiscuous mother, Hermes! We have bigger problems. I never loved you.”
“Look, everyone wants to be like Germany, but do we really have the pure strength of 'will'? I saw you with those two "ladies of the evening" at Elzars. Explain that. Hey, what kinda party is this? There's no booze and only one hooker.”
“Interesting. No, wait, the other thing: tedious. Who are you, my warranty?! Oh, I don't have time for this. I have to go and buy a single piece of fruit with a coupon and then return it.”


 Trump's response was:
Trump blamed DACA not passing on Democrats:
What do you think about his response?


Create console app using visual studio, dot net framework and c# on OSX/MAC
Instructions :
- 1- Open Visual Studio to get to the landing page and click on + New
- 2- Choose Console Application web and console & with C#
- 3- Select .NET 5.0 as target framework
- 4- Give your project a name, choose your preferred project folder location, and press create
- 5- A test app will be generated for you containing "Hello World", Press F5 or Command + F5 or click the play button from top toolbar to build and run the app. A terminal will be opened with the app running within Visual Studio.
×


You may give EmailSPA personal information about you or others, such as name, username, and other details on various places on EmailSPA. This privacy policy describes how EmailSPA collects and uses your personal information.
How and where EmailSPA collects personal information:
- welcome introduction
How EmailSPA uses personal information:
The information you give EmailSPA is absolutely safe. EmailSPA will never rent, sell, share, or otherwise disclose your personal information to third parties. The information given to EmailSPA is never sent to nor stored in any server as all operations are on the client. This is the equivalent to just typing things into a text document on your computer as the data is never transmitted over the network. It is just routed around in your browser to the javascript file that you download on access to the site.
Use of the term EmailSPA on this page refers to the owners and operators of EmailSPA found here.


This chapter describes the Java API for WebSocket (JSR 356), which provides support for creating WebSocket applications. WebSocket is an application protocol that provides full-duplex communications between two peers over the TCP protocol.
In the traditional request-response model used in HTTP, the client requests resources, and the server provides responses. The exchange is always initiated by the client; the server cannot send any data without the client requesting it first. This model worked well for the World Wide Web when clients made occasional requests for documents that changed infrequently, but the limitations of this approach are increasingly relevant as content changes quickly and users expect a more interactive experience on the Web. The WebSocket protocol addresses these limitations by providing a full-duplex communication channel between the client and the server. Combined with other client technologies, such as JavaScript and HTML5, WebSocket enables web applications to deliver a richer user experience.
The following topics are addressed here:
In a WebSocket application, the server publishes a WebSocket endpoint, and the client uses the endpoint's URI to connect to the server. The WebSocket protocol is symmetrical after the connection has been established; the client and the server can send messages to each other at any time while the connection is open, and they can close the connection at any time. Clients usually connect only to one server, and servers accept connections from multiple clients.
The WebSocket protocol has two parts: handshake and data transfer. The client initiates the handshake by sending a request to a WebSocket endpoint using its URI. The handshake is compatible with existing HTTP-based infrastructure: web servers interpret it as an HTTP connection upgrade request. An example handshake from a client looks like this:
GET /path/to/websocket/endpoint HTTP/1.1 Host: localhost Upgrade: websocket Connection: Upgrade Sec-WebSocket-Key: xqBt3ImNzJbYqRINxEFlkg== Origin: http://localhost Sec-WebSocket-Version: 13
An example handshake from the server in response to the client looks like this:
HTTP/1.1 101 Switching Protocols Upgrade: websocket Connection: Upgrade Sec-WebSocket-Accept: K7DJLdLooIwIG/MOpvWFB3y3FE8=
The server applies a known operation to the value of the Sec-WebSocket-Key
header to generate the value of the Sec-WebSocket-Accept
header. The client applies the same operation to the value of the Sec-WebSocket-Key
header, and the connection is established successfully if the result matches the value received from the server. The client and the server can send messages to each other after a successful handshake.
WebSocket supports text messages (encoded as UTF-8) and binary messages. The control frames in WebSocket are close, ping, and pong (a response to a ping frame). Ping and pong frames may also contain application data.
WebSocket endpoints are represented by URIs that have the following form:
ws://host:port/path?query wss://host:port/path?query
The ws
scheme represents an unencrypted WebSocket connection, and the wss
scheme represents an encrypted connection. The port
component is optional; the default port number is 80 for unencrypted connections and 443 for encrypted connections. The path
component indicates the location of an endpoint within a server. The query
component is optional.
Modern web browsers implement the WebSocket protocol and provide a JavaScript API to connect to endpoints, send messages, and assign callback methods for WebSocket events (such as opened connections, received messages, and closed connections).
The Java EE platform includes the Java API for WebSocket (JSR 356), which enables you to create, configure, and deploy WebSocket endpoints in web applications. The WebSocket client API specified in JSR 356 also enables you to access remote WebSocket endpoints from any Java application.
The Java API for WebSocket consists of the following packages.
The javax.websocket.server
package contains annotations, classes, and interfaces to create and configure server endpoints.
The javax.websocket
package contains annotations, classes, interfaces, and exceptions that are common to client and server endpoints.
WebSocket endpoints are instances of the javax.websocket.Endpoint
class. The Java API for WebSocket enables you to create two kinds of endpoints: programmatic endpoints and annotated endpoints. To create a programmatic endpoint, you extend the Endpoint
class and override its lifecycle methods. To create an annotated endpoint, you decorate a Java class and some of its methods with the annotations provided by the packages mentioned previously. After you have created an endpoint, you deploy it to an specific URI in the application so that remote clients can connect to it.
|
Note: In most cases, it is easier to create and deploy an annotated endpoint than a programmatic endpoint. This chapter provides a simple example of a programmatic endpoint, but it focuses on annotated endpoints. |
The process for creating and deploying a WebSocket endpoint follows.
Create an endpoint class.
Implement the lifecycle methods of the endpoint.
Add your business logic to the endpoint.
Deploy the endpoint inside a web application.
The process is slightly different for programmatic endpoints and annotated endpoints, and it is covered in detail in the following sections.
|
Note: As opposed to servlets, WebSocket endpoints are instantiated multiple times. The container creates an instance of an endpoint per connection to its deployment URI. Each instance is associated with one and only one connection. This facilitates keeping user state for each connection and makes development easier, because there is only one thread executing the code of an endpoint instance at any given time. |
The following example shows how to create an endpoint by extending the Endpoint
class:
public class EchoEndpoint extends Endpoint { @Override public void onOpen(final Session session, EndpointConfig config) { session.addMessageHandler(new MessageHandler.Whole<String>() { @Override public void onMessage(String msg) { try { session.getBasicRemote().sendText(msg); } catch (IOException e) { ... } } }); } }
This endpoint echoes every message received. The Endpoint
class defines three lifecycle methods: onOpen
, onClose
, and onError
. The EchoEndpoint
class implements the onOpen
method, which is the only abstract method in the Endpoint
class.
The Session
parameter represents a conversation between this endpoint and the remote endpoint. The addMessageHandler
method registers message handlers, and the getBasicRemote
method returns an object that represents the remote endpoint. The Session
interface is covered in detail in the rest of this chapter.
The message handler is implemented as an anonymous inner class. The onMessage
method of the message handler is invoked when the endpoint receives a text message.
To deploy this programmatic endpoint, use the following code in your Java EE application:
ServerEndpointConfig.Builder.create(EchoEndpoint.class, "/echo").build();
When you deploy your application, the endpoint is available at ws://<host>:<port>/<application>/echo
; for example, ws://localhost:8080/echoapp/echo
.
The following example shows how to create the same endpoint from Programmatic Endpoints using annotations instead:
@ServerEndpoint("/echo") public class EchoEndpoint { @OnMessage public void onMessage(Session session, String msg) { try { session.getBasicRemote().sendText(msg); } catch (IOException e) { ... } } }
The annotated endpoint is simpler than the equivalent programmatic endpoint, and it is deployed automatically with the application to the relative path defined in the ServerEndpoint
annotation. Instead of having to create an additional class for the message handler, this example uses the OnMessage
annotation to designate the method invoked to handle messages.
Table 18-1 lists the annotations available in the javax.websocket
package to designate the methods that handle lifecycle events. The examples in the table show the most common parameters for these methods. See the API reference for details on what combinations of parameters are allowed in each case.
Table 18-1 WebSocket Endpoint Lifecycle Annotations
| Annotation | Event | Example |
|---|---|---|
|
Connection opened |
@OnOpen public void open(Session session, EndpointConfig conf) { } |
|
|
Message received |
@OnMessage public void message(Session session, String msg) { } |
|
|
Connection error |
@OnError public void error(Session session, Throwable error) { } |
|
|
Connection closed |
@OnClose public void close(Session session, CloseReason reason) { } |
WebSocket endpoints can send and receive text and binary messages. In addition, they can also send ping frames and receive pong frames. This section describes how to use the Session
and RemoteEndpoint
interfaces to send messages to the connected peer and how to use the OnMessage
annotation to receive messages from it.
Follow these steps to send messages in an endpoint.
Obtain the Session
object from the connection.
The Session
object is available as a parameter in the annotated lifecycle methods of the endpoint, like those in Table 18-1. When your message is a response to a message from the peer, you have the Session
object available inside the method that received the message (the method annotated with @OnMessage
). If you have to send messages that are not responses, store the Session
object as an instance variable of the endpoint class in the method annotated with @OnOpen
so that you can access it from other methods.
Use the Session
object to obtain a RemoteEndpoint
object.
The Session.getBasicRemote
method and the Session.getAsyncRemote
method return RemoteEndpoint.Basic
and RemoteEndpoint.Async
objects respectively. The RemoteEndpoint.Basic
interface provides blocking methods to send messages; the RemoteEndpoint.Async
interface provides nonblocking methods.
Use the RemoteEndpoint
object to send messages to the peer.
The following list shows some of the methods you can use to send messages to the peer.
void RemoteEndpoint.Basic.sendText(String text)
Send a text message to the peer. This method blocks until the whole message has been transmitted.
void RemoteEndpoint.Basic.sendBinary(ByteBuffer data)
Send a binary message to the peer. This method blocks until the whole message has been transmitted.
void RemoteEndpoint.sendPing(ByteBuffer appData)
Send a ping frame to the peer.
void RemoteEndpoint.sendPong(ByteBuffer appData)
Send a pong frame to the peer.
The example in Annotated Endpoints demonstrates how to use this procedure to reply to every incoming text message.
Each instance of an endpoint class is associated with one and only one connection and peer; however, there are cases in which an endpoint instance needs to send messages to all connected peers. Examples include chat applications and online auctions. The Session
interface provides the getOpenSessions
method for this purpose. The following example demonstrates how to use this method to forward incoming text messages to all connected peers:
@ServerEndpoint("/echoall") public class EchoAllEndpoint { @OnMessage public void onMessage(Session session, String msg) { try { for (Session sess : session.getOpenSessions()) { if (sess.isOpen()) sess.getBasicRemote().sendText(msg); } } catch (IOException e) { ... } } }
The OnMessage
annotation designates methods that handle incoming messages. You can have at most three methods annotated with @OnMessage
in an endpoint, one for each message type: text, binary, and pong. The following example demonstrates how to designate methods to receive all three types of messages:
@ServerEndpoint("/receive") public class ReceiveEndpoint { @OnMessage public void textMessage(Session session, String msg) { System.out.println("Text message: " + msg); } @OnMessage public void binaryMessage(Session session, ByteBuffer msg) { System.out.println("Binary message: " + msg.toString()); } @OnMessage public void pongMessage(Session session, PongMessage msg) { System.out.println("Pong message: " + msg.getApplicationData().toString()); } }
Because the container creates an instance of the endpoint class for every connection, you can define and use instance variables to store client state information. In addition, the Session.getUserProperties
method provides a modifiable map to store user properties. For example, the following endpoint replies to incoming text messages with the contents of the previous message from each client:
@ServerEndpoint("/delayedecho") public class DelayedEchoEndpoint { @OnOpen public void open(Session session) { session.getUserProperties().put("previousMsg", " "); } @OnMessage public void message(Session session, String msg) { String prev = (String) session.getUserProperties() .get("previousMsg"); session.getUserProperties().put("previousMsg", msg); try { session.getBasicRemote().sendText(prev); } catch (IOException e) { ... } } }
To store information common to all connected clients, you can use class (static) variables; however, you are responsible for ensuring thread-safe access to them.
The Java API for WebSocket provides support for converting between WebSocket messages and custom Java types using encoders and decoders. An encoder takes a Java object and produces a representation that can be transmitted as a WebSocket message; for example, encoders typically produce JSON, XML, or binary representations. A decoder performs the reverse function; it reads a WebSocket message and creates a Java object.
This mechanism simplifies WebSocket applications, because it decouples the business logic from the serialization and deserialization of objects.
The procedure to implement and use encoders in endpoints follows.
Implement one of the following interfaces:
Encoder.Text<T>
for text messages
Encoder.Binary<T>
for binary messages
These interfaces specify the encode
method. Implement an encoder class for each custom Java type that you want to send as a WebSocket message.
Add the names of your encoder implementations to the encoders
optional parameter of the ServerEndpoint
annotation.
Use the sendObject(Object data)
method of the RemoteEndpoint.Basic
or RemoteEndpoint.Async
interfaces to send your objects as messages. The container looks for an encoder that matches your type and uses it to convert the object to a WebSocket message.
For example, if you have two Java types (MessageA
and MessageB
) that you want to send as text messages, implement the Encoder.Text<MessageA>
and Encoder.Text<MessageB>
interfaces as follows:
public class MessageATextEncoder implements Encoder.Text<MessageA> { @Override public void init(EndpointConfig ec) { } @Override public void destroy() { } @Override public String encode(MessageA msgA) throws EncodeException { // Access msgA's properties and convert to JSON text... return msgAJsonString; } }
Implement Encoder.Text<MessageB>
similarly. Then, add the encoders
parameter to the ServerEndpoint
annotation as follows:
@ServerEndpoint( value = "/myendpoint", encoders = { MessageATextEncoder.class, MessageBTextEncoder.class } ) public class EncEndpoint { ... }
Now, you can send MessageA
and MessageB
objects as WebSocket messages using the sendObject
method as follows:
MessageA msgA = new MessageA(...); MessageB msgB = new MessageB(...); session.getBasicRemote.sendObject(msgA); session.getBasicRemote.sendObject(msgB);
As in this example, you can have more than one encoder for text messages and more than one encoder for binary messages. Like endpoints, encoder instances are associated with one and only one WebSocket connection and peer, so there is only one thread executing the code of an encoder instance at any given time.
The procedure to implement and use decoders in endpoints follows.
Implement one of the following interfaces:
Decoder.Text<T>
for text messages
Decoder.Binary<T>
for binary messages
These interfaces specify the willDecode
and decode
methods.
|
Note: Unlike with encoders, you can specify at most one decoder for binary messages and one decoder for text messages. |
Add the names of your decoder implementations to the decoders
optional parameter of the ServerEndpoint
annotation.
Use the OnMessage
annotation in the endpoint to designate a method that takes your custom Java type as a parameter. When the endpoint receives a message that can be decoded by one of the decoders you specified, the container calls the method annotated with @OnMessage
that takes your custom Java type as a parameter if this method exists.
For example, if you have two Java types (MessageA
and MessageB
) that you want to send and receive as text messages, define them so that they extend a common class (Message
). Because you can only define one decoder for text messages, implement a decoder for the Message
class as follows:
public class MessageTextDecoder implements Decoder.Text<Message> { @Override public void init(EndpointConfig ec) { } @Override public void destroy() { } @Override public Message decode(String string) throws DecodeException { // Read message... if ( /* message is an A message */ ) return new MessageA(...); else if ( /* message is a B message */ ) return new MessageB(...); } @Override public boolean willDecode(String string) { // Determine if the message can be converted into either a // MessageA object or a MessageB object... return canDecode; } }
Then, add the decoder
parameter to the ServerEndpoint
annotation as follows:
@ServerEndpoint( value = "/myendpoint", encoders = { MessageATextEncoder.class, MessageBTextEncoder.class }, decoders = { MessageTextDecoder.class } ) public class EncDecEndpoint { ... }
Now, define a method in the endpoint class that receives MessageA
and MessageB
objects as follows:
@OnMessage public void message(Session session, Message msg) { if (msg instanceof MessageA) { // We received a MessageA object... } else if (msg instanceof MessageB) { // We received a MessageB object... } }
Like endpoints, decoder instances are associated with one and only one WebSocket connection and peer, so there is only one thread executing the code of a decoder instance at any given time.
The ServerEndpoint
annotation enables you to use URI templates to specify parts of an endpoint deployment URI as application parameters. For example, consider this endpoint:
@ServerEndpoint("/chatrooms/{room-name}") public class ChatEndpoint { ... }
If the endpoint is deployed inside a web application called chatapp
at a local Java EE server in port 8080, clients can connect to the endpoint using any of the following URIs:
http://localhost:8080/chatapp/chatrooms/currentnews http://localhost:8080/chatapp/chatrooms/music http://localhost:8080/chatapp/chatrooms/cars http://localhost:8080/chatapp/chatrooms/technology
Annotated endpoints can receive path parameters as arguments in methods annotated with @OnOpen
, @OnMessage
, and @OnClose
. In this example, the endpoint uses the parameter in the @OnOpen
method to determine which chat room the client wants to join:
@ServerEndpoint("/chatrooms/{room-name}") public class ChatEndpoint { @OnOpen public void open(Session session, EndpointConfig c, @PathParam("room-name") String roomName) { // Add the client to the chat room of their choice ... } }
The path parameters used as arguments in these methods can be strings, primitive types, or the corresponding wrapper types.
To designate a method that handles errors in an annotated WebSocket endpoint, decorate it with @OnError
:
@ServerEndpoint("/testendpoint") public class TestEndpoint { ... @OnError public void error(Session session, Throwable t) { t.printStackTrace(); ... } }
This method is invoked when there are connection problems, runtime errors from message handlers, or conversion errors when decoding messages.
The Java API for WebSocket enables you to configure how the container creates server endpoint instances. You can provide custom endpoint configuration logic to:
Access the details of the initial HTTP request for a WebSocket connection
Perform custom checks on the Origin
HTTP header
Modify the WebSocket handshake response
Choose a WebSocket subprotocol from those requested by the client
Control the instantiation and initialization of endpoint instances
To provide custom endpoint configuration logic, you extend the ServerEndpointConfig.Configurator
class and override some of its methods. In the endpoint class, you specify the configurator class using the configurator
parameter of the ServerEndpoint
annotation.
For example, the following configurator class makes the handshake request object available to endpoint instances:
public class CustomConfigurator extends ServerEndpointConfig.Configurator { @Override public void modifyHandshake(ServerEndpointConfig conf, HandshakeRequest req, HandshakeResponse resp) { conf.getUserProperties().put("handshakereq", req); } }
The following endpoint class configures endpoint instances with the custom configurator, which enables them to access the handshake request object:
@ServerEndpoint( value = "/myendpoint", configurator = CustomConfigurator.class ) public class MyEndpoint { @OnOpen public void open(Session s, EndpointConfig conf) { HandshakeRequest req = (HandshakeRequest) conf.getUserProperties() .get("handshakereq"); Map<String,List<String>> headers = req.getHeaders(); ... } }
The endpoint class can use the handshake request object to access the details of the initial HTTP request, such as its headers or the HttpSession
object.
For more information on endpoint configuration, see the API reference for the ServerEndpointConfig.Configurator
class.
The dukeetf2
example application, located in the tut-install/examples/web/websocket/dukeetf2/
directory, demonstrates how to use a WebSocket endpoint to provide data updates to web clients. The example resembles a service that provides periodic updates on the price and trading volume of an electronically traded fund (ETF).
The dukeetf2
example application consists of a WebSocket endpoint, an enterprise bean, and an HTML page.
The endpoint accepts connections from clients and sends them updates when new data for price and trading volume becomes available.
The enterprise bean updates the price and volume information once every second.
The HTML page uses JavaScript code to connect to the WebSocket endpoint, parse incoming messages, and update the price and volume information without reloading the page.
The WebSocket endpoint is implemented in the ETFEndpoint
class, which stores all connected sessions in a queue and provides a method that the enterprise bean calls when there is new information available to send:
@ServerEndpoint("/dukeetf") public class ETFEndpoint { private static final Logger logger = Logger.getLogger("ETFEndpoint"); /* Queue for all open WebSocket sessions */ static Queue<Session> queue = new ConcurrentLinkedQueue<>(); /* PriceVolumeBean calls this method to send updates */ public static void send(double price, int volume) { String msg = String.format("%.2f / %d", price, volume); try { /* Send updates to all open WebSocket sessions */ for (Session session : queue) { session.getBasicRemote().sendText(msg); logger.log(Level.INFO, "Sent: {0}", msg); } } catch (IOException e) { logger.log(Level.INFO, e.toString()); } } ... }
The lifecycle methods of the endpoint add and remove sessions to and from the queue:
@ServerEndpoint("/dukeetf") public class ETFEndpoint { ... @OnOpen public void openConnection(Session session) { /* Register this connection in the queue */ queue.add(session); logger.log(Level.INFO, "Connection opened."); } @OnClose public void closedConnection(Session session) { /* Remove this connection from the queue */ queue.remove(session); logger.log(Level.INFO, "Connection closed."); } @OnError public void error(Session session, Throwable t) { /* Remove this connection from the queue */ queue.remove(session); logger.log(Level.INFO, t.toString()); logger.log(Level.INFO, "Connection error."); } }
The enterprise bean uses the timer service to generate new price and volume information every second:
@Startup @Singleton public class PriceVolumeBean { /* Use the container's timer service */ @Resource TimerService tservice; private Random random; private volatile double price = 100.0; private volatile int volume = 300000; private static final Logger logger = Logger.getLogger("PriceVolumeBean"); @PostConstruct public void init() { /* Initialize the EJB and create a timer */ logger.log(Level.INFO, "Initializing EJB."); random = new Random(); tservice.createIntervalTimer(1000, 1000, new TimerConfig()); } @Timeout public void timeout() { /* Adjust price and volume and send updates */ price += 1.0*(random.nextInt(100)-50)/100.0; volume += random.nextInt(5000) - 2500; ETFEndpoint.send(price, volume); } }
The enterprise bean calls the send
method of the ETFEndpoint
class in the timeout method. See Using the Timer Service in Chapter 34, "Running the Enterprise Bean Examples" for more information on the timer service.
The HTML page consists of a table and some JavaScript code. The table contains two fields referenced from JavaScript code:
<!DOCTYPE html> <html> <head>...</head> <body> ... <table> ... <td id="price">--.--</td> ... <td id="volume">--</td> ... </table> </body> </html>
The JavaScript code uses the WebSocket API to connect to the server endpoint and to designate a callback method for incoming messages. The callback method updates the page with the new information.
var wsocket; function connect() { wsocket = new WebSocket("ws://localhost:8080/dukeetf2/dukeetf"); wsocket.onmessage = onMessage; } function onMessage(evt) { var arraypv = evt.data.split("/"); document.getElementById("price").innerHTML = arraypv[0]; document.getElementById("volume").innerHTML = arraypv[1]; } window.addEventListener("load", connect, false);
The WebSocket API is supported by most modern browsers, and it is widely used in HTML5 web client development.
This section describes how to run the dukeetf2
example application using NetBeans IDE and from the command line.
Make sure that GlassFish Server has been started (see Starting and Stopping GlassFish Server).
From the File menu, choose Open Project.
In the Open Project dialog box, navigate to:
tut-install/examples/web/websocket
Select the dukeetf2
folder.
Click Open Project.
In the Projects tab, right-click the dukeetf2
project and select Run.
This command builds and packages the application into a WAR file (dukeetf2.war
) located in the target/
directory, deploys it to the server, and launches a web browser window with the following URL:
http://localhost:8080/dukeetf2/
Open the same URL on a different web browser tab or window to see how both pages get price and volume updates simultaneously.
Make sure that GlassFish Server has been started (see Starting and Stopping GlassFish Server).
In a terminal window, go to:
tut-install/examples/web/websocket/dukeetf2/
Enter the following command to deploy the application:
mvn install
Open a web browser window and enter the following URL:
http://localhost:8080/dukeetf2/
Open the same URL on a different web browser tab or window to see how both pages get price and volume updates simultaneously.
The websocketbot
example application, located in the tut-install/examples/web/websocket/websocketbot/
directory, demonstrates how to use a WebSocket endpoint to implement a chat. The example resembles a chat room in which many users can join and have a conversation. Users can ask simple questions to a bot agent that is always available in the chat room.
The websocketbot
example application consists of the following elements:
A CDI bean (BotBean
) that contains the logic for the bot agent to reply to messages
A WebSocket endpoint (BotEndpoint
) that implements the chat room
A set of classes (Message
, ChatMessage
, InfoMessage
, JoinMessage
, and UsersMessage
) that represent application messages
A set of classes (ChatMessageEncoder
, InfoMessageEncoder
, JoinMessageEncoder
, and UsersMessageEncoder
) that encode application messages into WebSocket text messages as JSON data
A class (MessageDecoder
) the parses WebSocket text messages as JSON data and decodes them into JoinMessage
or ChatMessage
objects
An HTML page (index.html
) that uses JavaScript code to implement the client for the chat room
The CDI bean (BotBean
) is a Java class that contains the respond
method. This method compares the incoming chat message with a set of predefined questions and returns a chat response.
@Named public class BotBean { public String respond(String msg) { ... } }
The WebSocket endpoint (BotEndpoint
) is an annotated endpoint that performs the following functions:
Receives messages from clients
Forwards messages to clients
Maintains a list of connected clients
Invokes the bot agent functionality
The endpoint specifies its deployment URI and the message encoders and decoders using the ServerEndpoint
annotation. The endpoint obtains an instance of the BotBean
class and a managed executor service resource through dependency injection:
@ServerEndpoint( value = "/websocketbot", decoders = { MessageDecoder.class }, encoders = { JoinMessageEncoder.class, ChatMessageEncoder.class, InfoMessageEncoder.class, UsersMessageEncoder.class } ) /* There is a BotEndpoint instance per connection */ public class BotEndpoint { private static final Logger logger = Logger.getLogger("BotEndpoint"); /* Bot functionality bean */ @Inject private BotBean botbean; /* Executor service for asynchronous processing */ @Resource(name="comp/DefaultManagedExecutorService") private ManagedExecutorService mes; @OnOpen public void openConnection(Session session) { logger.log(Level.INFO, "Connection opened."); } ... }
The message
method processes incoming messages from clients. The decoder converts incoming text messages into JoinMessage
or ChatMessage
objects, which inherit from the Message
class. The message
method receives a Message
object as a parameter:
@OnMessage public void message(Session session, Message msg) { logger.log(Level.INFO, "Received: {0}", msg.toString()); if (msg instanceof JoinMessage) { /* Add the new user and notify everybody */ JoinMessage jmsg = (JoinMessage) msg; session.getUserProperties().put("name", jmsg.getName()); session.getUserProperties().put("active", true); logger.log(Level.INFO, "Received: {0}", jmsg.toString()); sendAll(session, new InfoMessage(jmsg.getName() + " has joined the chat")); sendAll(session, new ChatMessage("Duke", jmsg.getName(), "Hi there!!")); sendAll(session, new UsersMessage(this.getUserList(session))); } else if (msg instanceof ChatMessage) { /* Forward the message to everybody */ ChatMessage cmsg = (ChatMessage) msg; logger.log(Level.INFO, "Received: {0}", cmsg.toString()); sendAll(session, cmsg); if (cmsg.getTarget().compareTo("Duke") == 0) { /* The bot replies to the message */ mes.submit(new Runnable() { @Override public void run() { String resp = botbean.respond(cmsg.getMessage()); sendAll(session, new ChatMessage("Duke", cmsg.getName(), resp)); } }); } } }
If the message is a join message, the endpoint adds the new user to the list and notifies all connected clients. If the message is a chat message, the endpoint forwards it to all connected clients.
If a chat message is for the bot agent, the endpoint obtains a response using the BotBean
instance and sends it to all connected clients. The sendAll
method is similar to the example in Sending Messages to All Peers Connected to an Endpoint.
Asynchronous Processing and Concurrency Considerations
The WebSocket endpoint calls the BotBean.respond
method to obtain a response from the bot. In this example, this is a blocking operation; the user that sent the associated message would not be able to send or receive other chat messages until the operation completes. To avoid this problem, the endpoint obtains an executor service from the container and executes the blocking operation in a different thread using the ManagedExecutorService.submit
method from Concurrency Utilities for Java EE.
The Java API for WebSocket specification requires that Java EE implementations instantiate endpoint classes once per connection. This facilitates the development of WebSocket endpoints, because you are guaranteed that only one thread is executing the code in a WebSocket endpoint class at any given time. When you introduce a new thread in an endpoint, as in this example, you must ensure that variables and methods accessed by more than one thread are thread safe. In this example, the code in BotBean
is thread safe, and the BotEndpoint.sendAll
method has been declared synchronized
.
Refer to Chapter 56, "Concurrency Utilities for Java EE" for more information on the managed executor service and Concurrency Utilities for Java EE.
The classes that represent application messages (Message
, ChatMessage
, InfoMessage
, JoinMessage
, and UsersMessage
) contain only properties and getter and setter methods. For example, the ChatMessage
class looks like this:
public class ChatMessage extends Message { private String name; private String target; private String message; /* ... Constructor, getters, and setters ... */ }
The encoder classes convert application message objects into JSON text using the Java API for JSON Processing. For example, the ChatMessageEncoder
class is implemented as follows:
/* Encode a ChatMessage as JSON. * For example, (new ChatMessage("Peter","Duke","How are you?")) * is encoded as follows: * {"type":"chat","target":"Duke","message":"How are you?"} */ public class ChatMessageEncoder implements Encoder.Text<ChatMessage> { @Override public void init(EndpointConfig ec) { } @Override public void destroy() { } @Override public String encode(ChatMessage chatMessage) throws EncodeException { // Access properties in chatMessage and write JSON text... } }
See Chapter 19, JSON Processing for more information on the Java API for JSON Processing.
The message decoder (MessageDecoder
) class converts WebSocket text messages into application messages by parsing JSON text. It is implemented as follows:
/* Decode a JSON message into a JoinMessage or a ChatMessage. * For example, the incoming message * {"type":"chat","name":"Peter","target":"Duke","message":"How are you?"} * is decoded as (new ChatMessage("Peter", "Duke", "How are you?")) */ public class MessageDecoder implements Decoder.Text<Message> { /* Stores the name-value pairs from a JSON message as a Map */ private Map<String,String> messageMap; @Override public void init(EndpointConfig ec) { } @Override public void destroy() { } /* Create a new Message object if the message can be decoded */ @Override public Message decode(String string) throws DecodeException { Message msg = null; if (willDecode(string)) { switch (messageMap.get("type")) { case "join": msg = new JoinMessage(messageMap.get("name")); break; case "chat": msg = new ChatMessage(messageMap.get("name"), messageMap.get("target"), messageMap.get("message")); } } else { throw new DecodeException(string, "[Message] Can't decode."); } return msg; } /* Decode a JSON message into a Map and check if it contains * all the required fields according to its type. */ @Override public boolean willDecode(String string) { // Convert JSON data from the message into a name-value map... // Check if the message has all the fields for its message type... } }
The HTML page (index.html
) contains a field for the user name. After the user types a name and clicks Join, three text areas are available: one to type and send messages, one for the chat room, and one with the list of users. The page also contains a WebSocket console that shows the messages sent and received as JSON text.
The JavaScript code on the page uses the WebSocket API to connect to the endpoint, send messages, and designate callback methods. The WebSocket API is supported by most modern browsers and is widely used for web client development with HTML5.
This section describes how to run the websocketbot
example application using NetBeans IDE and from the command line.
Make sure that GlassFish Server has been started (see Starting and Stopping GlassFish Server).
From the File menu, choose Open Project.
In the Open Project dialog box, navigate to:
tut-install/examples/web/websocket
Select the websocketbot
folder.
Click Open Project.
In the Projects tab, right-click the websocketbot
project and select Run.
This command builds and packages the application into a WAR file, websocketbot.war
, located in the target/
directory; deploys it to the server; and launches a web browser window with the following URL:
http://localhost:8080/websocketbot/
See To Test the websocketbot Example Application for more information.
Make sure that GlassFish Server has been started (see Starting and Stopping GlassFish Server).
In a terminal window, go to:
tut-install/examples/web/websocket/websocketbot/
Enter the following command to deploy the application:
mvn install
Open a web browser window and type the following address:
http://localhost:8080/websocketbot/
See To Test the websocketbot Example Application for more information.
On the main page, type your name on the first text field and press the Enter key.
The list of connected users appears on the text area on the right. The text area on the left is the chat room.
Type a message on the text area below the login button. For example, type the messages in bold and press enter to obtain responses similar to the following:
[--Peter has joined the chat--] Duke: @Peter Hi there!! Peter: @Duke how are you? Duke: @Peter I'm doing great, thank you! Peter: @Duke when is your birthday? Duke: @Peter My birthday is on May 23rd. Thanks for asking!
Join the chat from another browser window by copying and pasting the URI on the address bar and joining with a different name.
The new user name appears in the list of users in both browser windows. You can send messages from either window and see how they appear in the other.
Click Show WebSocket Console.
The console shows the messages sent and received as JSON text.


|
Congestion Threshold = {{cong_threshold}}
|
Free Flow Speed = {{freeflow_speed}}
|
| Current Speed | {{current_speed}} |
| Free Flow Speed | {{freeflow_speed}} |
| Congestion Percentage | {{congestion_value}} |
| Traffic Condition | {{congType}} {{congType}} {{congType}} |


| Class | GraphMapConfig |
| In: |
lib/graph_map_config.rb
|
| Parent: | Object |
Basic configuration of the plugin
Gets plugin configuration
# File lib/graph_map_config.rb, line 5 5: def self.config 6: @graph_map_config ||= {} 7: end
Gets where to look for javascript. Default: /javascripts
# File lib/graph_map_config.rb, line 50 50: def self.js 51: config[:js] || '/javascripts' 52: end
Sets where to look for javascript
# File lib/graph_map_config.rb, line 55 55: def self.js=(params) 56: config[:js] = params 57: end
Gets where the generated maps will be saved. Default: /public/graph_maps
# File lib/graph_map_config.rb, line 30 30: def self.maps_dir 31: config[:maps_dir] || File.join(root, 'public', 'graph_maps') 32: end
Sets where the generated maps will be saved
# File lib/graph_map_config.rb, line 35 35: def self.maps_dir=(params) 36: config[:maps_dir] = params 37: end
Where to look for maps. Default: /graph_maps
# File lib/graph_map_config.rb, line 40 40: def self.maps_path 41: config[:maps_path] || '/graph_maps' 42: end
Sets where to look for maps
# File lib/graph_map_config.rb, line 45 45: def self.maps_path=(params) 46: config[:maps_path] = params 47: end


| DOSE: |
|
oral |
MDMA |
(pill / tablet) |
There's a hell of a lot really I could say about this subject...crazy times indeed.
I arrived in London from New Zealand, Summer 1996. From the onset, comfort with this amazing city was extreme. Never before had life felt so good, it was the perfect place to be at the perfect time. Partying, albeit shortened hours (due to the UK's enlightened lisencing hours), was reaching new heights...I already loved London...I felt like I had lived there forever.
Then, one crazy Friday, a good mate of mine from many scallywag missions back home (NZ is the bollocks to grow up in) pulled the little white pill on me. Drugs at this stage were not a big deal, standard behaviour so to speak. However, this little white pill held nothing but fascination for me. It certainly changed that evening, and sitting here now, definitely my life.
To cut a long story.... It was an amazing evening. I discovered cranking house music, dancing (man, never before without 12 or so lagers), mass euphoria and madness...all of it sensationally beautiful. We walked across the Thames at 7am on the most beautiful summer day I reckon that city has seen. My thoughts raced between absolute, joyous interest in my friends, and the totally illogical but sincere belief that every person on earth, young and old, should try this drug. It was a spiritual experience, profound is an understatement. If you could bottle that original feeling and sell it, the world would be a better place, of that I held little doubt.
Winter2000, New Zealand. Looking back, I was an 'e-monster.'  Clubbing became everything. I still do it now and then, loving it every time. However, I know the dangers. Like anything, so the old cliche goes, moderation is the key. Moderation wasn't a strength of mine for quite a while. And it does take a while to fully come right. Young people, i.e under 21, should be cautious.
I wouldn't swap that period for anything. As I sit here, loud UK dance music is on the stereo. Pearl Jam, Smashing Pumpkins, etc. went to the wayside somewhere. I love the music now probably more than the culture, although that's pretty good too.
Been there, clubbed it. A little bit razzled at 27 maybe but getting back up there...and immense amounts of fun in the meantime.
There are big downsides, believe me.
Be realistic--it is a drug. What goes up must come...well, you know where.
What I'm probably trying to say is, 'Treat with respect.' The thing about e is it feels soooo good, you begin to think, how can this be bad. It is if you abuse it, as with anything--beer ain't that flash at 100 cans a week. Treat with caution, self-respect and maturity.
There's more to life than dancing...
Although it can certainly be a part of it.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


NAME
zip_set_archive_flag —
set zip archive
flag
LIBRARY
libzip (-lzip)
SYNOPSIS
#include <zip.h>
int
zip_set_archive_flag(
zip_t
*archive,
zip_flags_t
flag,
int value);
DESCRIPTION
The
zip_set_archive_flag() function sets the flag
flag for the archive
archive to
the value
value.
Currently there are no supported flags.
RETURN VALUES
Upon successful completion 0 is returned, and -1 if an error occurred.
SEE ALSO
libzip(3),
zip_get_archive_flag(3)
HISTORY
zip_set_archive_flag() was added in libzip 0.9. In libzip 0.11
the type of
flag was changed from
int to
zip_flags_t.
AUTHORS
Dieter Baron
<
<EMAIL_ADDRESS>and
Thomas Klausner
<
tk@giga.or.at>


Shop IT - Search
Menu
Home
About
Contact
{% if not g.user.is_authenticated %}
Login
Register
{% else %}
Dashboard
Logout
{% endif %}
ShopIT
ShopIT is a Website that allows you to find nearby shops in your area.
{% if not g.user.is_authenticated %}
Get Started
{% else %}
Get Started
{% endif %}
{% if places %}
{% for place in places %}
Place Name: {{place.name}}
Business Type: {{place.type}}
Location: {{place.location}}
Like
|
Dislike
{% endfor %}
{% endif %}


These are some of my projects I have developed. Some of them are actually in working progress
Web development Templates
Made to start any web project using Node.js and Webpack plugins.
- Node.js, WebPack, UglifyJs
- Github Page
A starter template to use Vue as a frontend controller for a Bootstrap 4 site.
- HTML5, Bootstrap4, Vue.js Components
- Github Page
Web development Tools
An utility to generate HTML code for Search Engine Optimization (SEO) and Social media share (OpenGraph)
- HTML5, Ajax, Facebook Connect
- Github Page
An utility to generate resized images from a original source in multiple sizes.
- HTML5 Canvas, HTML5 File API
- Vue.js templates and components
- Github Page
Web games
A Javascript/HTML only game
- HTML5, Javascript DOM (no Canvas), LocalStorage
- Github Page
An defense game using a Javascript/HTML5/Canvas game engine.
- HTML5 Canvas, Phaser Js (Game Engine)
- Go to Page
Data Analysis
A PHP library to request, extract and parse data from HTML pages
An utility to create a JSON data file from a text file (CSV or tab-separated)
- AngujarJS, Bootstrap4, HTML5 File API
- Github Page


Ekoodi Contacts App
In GitHub
contacts-app-restful
Create contact
First name
Last name
Phone
Street address
City
Create
Contacts
First Name
Last Name
Phone
Address
Edit
Delete
No contacts


{% extends "soc/base.html" %} {% comment %} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. {% endcomment %} {% load forms_helpers %} {% block scripts %} {{ block.super }} {% if entity.feed_url %} {% endif %} {% endblock %} {% block header_title %} {{ page_name }} {{ entity.title }} for {{ entity.scope.name }} {% endblock %} {% block body %}


Cheese and wine bocconcini cheese and biscuits. The big cheese when the cheese comes out everybody's happy lancashire emmental cheesecake cheese strings taleggio hard cheese. Cheesy grin croque monsieur pepper jack everyone loves mozzarella babybel mozzarella say cheese. Cheeseburger caerphilly cheese strings melted cheese cheese strings bocconcini.
When the cheese comes out everybody's happy lancashire cheeseburger. Gouda cut the cheese blue castello manchego macaroni cheese when the cheese comes out everybody's happy the big cheese mozzarella. Cheddar stinking bishop queso melted cheese croque monsieur fromage babybel cottage cheese. Cheese strings.
Cheese and wine bocconcini cheese and biscuits. The big cheese when the cheese comes out everybody's happy lancashire emmental cheesecake cheese strings taleggio hard cheese. Cheesy grin croque monsieur pepper jack everyone loves mozzarella babybel mozzarella say cheese. Cheeseburger caerphilly cheese strings melted cheese cheese strings bocconcini.
Cheese and wine bocconcini cheese and biscuits. The big cheese when the cheese comes out everybody's happy lancashire emmental cheesecake cheese strings taleggio hard cheese. Cheesy grin croque monsieur pepper jack everyone loves mozzarella babybel mozzarella say cheese. Cheeseburger caerphilly cheese strings melted cheese cheese strings bocconcini.
When the cheese comes out everybody's happy lancashire cheeseburger. Gouda cut the cheese blue castello manchego macaroni cheese when the cheese comes out everybody's happy the big cheese mozzarella. Cheddar stinking bishop queso melted cheese croque monsieur fromage babybel cottage cheese. Cheese strings.
Cheese and wine bocconcini cheese and biscuits. The big cheese when the cheese comes out everybody's happy lancashire emmental cheesecake cheese strings taleggio hard cheese. Cheesy grin croque monsieur pepper jack everyone loves mozzarella babybel mozzarella say cheese. Cheeseburger caerphilly cheese strings melted cheese cheese strings bocconcini.


A certificate revocation list is a collection of certificates that can't be trusted anymore. The reasons of mistrust can be many:-
When we talk about client side certificates, we are not dealing with just a single certificate, but with a much larger volume of certificates that complicates their management. Automatic checks like email verification only guarantee that a certain email belongs to a certificate holder and not much else. Therefore when we talk about valid certificate what we mean is, that the certificate being presented to us is signed by a trusted CA. No more, no less. Once a connection has been established by a valid certificate we still need to authorize the actions of a certificate holder. Not all certificate holders should be able to perform all actions on our server.
A certificate itself provides very little information to us. For that purpose we need to map some attributes of a client certificate to our user table. That attribute could be a DN or a serial number. In doing that we are saying that a certificate with an attribute X belongs to a user Y. It should be the responsibility of the certificate issuer to make sure the the attribute that is being mapped is unique across the certificates.
A CRL invalidates a certificate during the establishment of a connection. But this presents some inconsistencies in our application design since even with a CRL it is important to define what actions are allowed for a user passing the CRL check. A rejection at the level of access control is much more manageable/intuitive than a rejection at CRL level.
Keep a clean nose
If a certificate holder is doing a suspicious activity with a valid certificate then revoking the certificate is an incorrect response because the certificate is genuine. Instead steps should be taken to either warn the user or ban him from performing certain actions within the application.
If the private key of the user has been stolen and the certificate issued has been compromised then the certificate serial number (or other attribute) can be unmapped from the user table and a notification can be issued to user to get a new certificate. Meanwhile all requests from the old certificate can be responded with a succinct 401.
If the CA's private key has been compromised then rather than invalidating all the client certificates it would be best to create a new CA and issue new certificates to your clients. A CRL does not make any sense here because all the certificates have been compromised.
"What about speed?"
A CRL is certainly faster since it rejects the user when he's about to establish the connection but if you take into account that a series of checks will have to be performed after establishment of the connection the equation changes somewhat. Add to this the inconvenience of maintaining two different levels of access control and consequently dealing with two data points when it comes to determine the validity of user, it becomes simpler and efficient to not keep a crl even at the cost of a tiny gain in performance.
-Akshat Jiwan Sharma