Overview
This example demonstrates some simple API requests and drawing a vehicle's trip on a map.
Work flow
Your vehicles are retrieved using an initial API request for all Device entities. Then when one is
selected, the current day's Trips
are retrieved. The trip's LogRecords are retrieved and displayed on the map.
Skill level
Beginner


--- layout: documentation title: IPInfoType ---
The IP_Info type specifies information about the IP address and its associated subnet mask used by a network interface.
| Field Name | Type | Description |
|---|---|---|
| IP_Address0..1 | AddressObjectType |
The IP_Address field specifies an IP address. |
| Subnet_Mask0..1 | AddressObjectType |
The Subnet_Mask field specifies a subnet mask. |


What is StephenPlautz.com?
StephenPlautz.com is a website created, maintained, and updated by me, Stephen Plautz. The purpose of this website is to give readers insight into my personality, creative capabilities, interests, and accomplishments.
About me
Who Am I?
Hi! My name is Stephen, the creator of this website. There are many different ways to answer this question, so I will default to the basics. I was born in the midwest, Illinois to be exact. Illinois was my home for the first (and longest) 18 years of my life. I am the middle child in a family of seven. I was born with the misfortune of being the third boy in the family. If you can imagine, having two older brothers in the 90's and early 2000's was pretty tough. These days it's all love though. For the entirety of my k-5 through senior Education I was enrolled in a small private school and participated in many extracurriculars ranging from choir to varsity sports. As a kid I never knew what to answer whenever we had vocation day and they asked the inevitable "what do you want to be?". I didn't know what I wanted to do for a living, there were simply too many things I liked (bugs being really high on the list, girls not so much).
Fortunately this limbo was not to last forever. I first developed my interest in programming during my junior year of high-school. My math teacher had students in our class go through a programming tutorial to make some rudimentary video-games on our TI-84 calculators, and I loved doing it. After experiencing that, I started to notice all kinds of interesting and useful things that I had taken entirely for granted before, and realized that there must have been some really smart, cool, and probably nerdy people that were programming these things.. Exactly my type of crowd. After that, everything else was really about leading up to college, a much needed change of scenery that has presented me with incredible opportunities and challenges. As of right now I am a 21 year old computer-science student at the University of Alabama. So far I have loved every bit of college minus the parking, and perhaps some *cough* English classes *cough*.
Why Did I Make This Website?
Being a computer-science student with time to spare, and an insatiable apetite for learning, I figured that I would apply some of that apetite to an area that isn't covered in the core curriculum of most computer-science programs: web development. This website has proven to be an excellent outlet for my creative capabilities, and an incredibly fun and rewarding challenge to create.  While I recognize the benefit of certain API's and templates to efficiently and stylishly build web pages, I would be remiss not to take the opportunity to learn web develoment at it's rawest form. Over the course of the next couple years I plan to update the site to include more functionality that will both increase the interactivity of the site, as well as presenting me with new and interesting challenges associated with web devlopment.


WordPress is a free and open source application designed primarily for blogging and creating websites. It is a content-management system (CMS) based on PHP and MySQL the following page provides detailed information for installing WordPress on Uniform Server Zero XIII. Note: At step 5 you are required to enter your e-mail address this is the e-mail address you set as default when configuring MSMTP, for details see Edit MSMTP Configuration Step 1: Download and ExtractDownload and unzip the WordPress package.
Before Wordpress can be installed a MySQL user and database are required for details see step2. Step 2: Create the Database and a User using phpMyAdminFollow these instructions to create your WordPress username and database using phpMyAdmin. Note: These instructions are written for phpMyAdmin 4.6.3; the phpMyAdmin user interface can vary slightly between versions.
Note: Other parts of this documentation assume you have set the following: WordPress database name = wordpress Username for WordPress = wordpress Password = fred123 remember to replace these with the values you have set in the above. Step 3: Set up wp-config.phpHow to create and edit a new Wordpress configuration file named wp-config.php
Replace the following using information from Step-2 // ** MySQL settings - You can get this info from your web host ** // /** The name of the database for WordPress */ define('DB_NAME', 'database_name_here'); /** MySQL database username */ define('DB_USER', 'username_here'); /** MySQL database password */ define('DB_PASSWORD', 'password_here'); /** MySQL hostname */ define('DB_HOST', 'localhost'); /** Database Charset to use in creating database tables. */ define('DB_CHARSET', 'utf8'); /** The Database Collate type. Don't change this if in doubt. */ define('DB_COLLATE', ''); To give the following: // ** MySQL settings - You can get this info from your web host ** // /** The name of the database for WordPress */ define('DB_NAME', 'wordpress'); /** MySQL database username */ define('DB_USER', 'wordpress'); /** MySQL database password */ define('DB_PASSWORD', 'fred123'); /** MySQL hostname */ define('DB_HOST', '<IP_ADDRESS>'); /** Database Charset to use in creating database tables. */ define('DB_CHARSET', 'utf8'); /** The Database Collate type. Don't change this if in doubt. */ define('DB_COLLATE', ''); Enter your secret key valuesReplace the following section: define('AUTH_KEY', 'put your unique phrase here'); define('SECURE_AUTH_KEY', 'put your unique phrase here'); define('LOGGED_IN_KEY', 'put your unique phrase here'); define('NONCE_KEY', 'put your unique phrase here'); define('AUTH_SALT', 'put your unique phrase here'); define('SECURE_AUTH_SALT', 'put your unique phrase here'); define('LOGGED_IN_SALT', 'put your unique phrase here'); define('NONCE_SALT', 'put your unique phrase here'); With the following example section: define( 'AUTH_KEY', 't`DK%X:>xy|e-Z(BXb/f(Ur`8#~UzUQG-^_Cs_GHs5U-&Wb?pgn^p8(2@}IcnCa|' ); define( 'SECURE_AUTH_KEY', 'D&ovlU#|CvJ##uNq}bel+^MFtT&.b9{UvR]g%ixsXhGlRJ7q!h}XWdEC[BOKXssj' ); define( 'LOGGED_IN_KEY', 'MGKi8Br(&{H*~&0s;{k0<S(O:+f#WM+q|npJ-+P;RDKT:~jrmgj#/-,[hOBk!ry^' ); define( 'NONCE_KEY', 'FIsAsXJKL5ZlQo)iD-pt??eUbdc{_Cn<4!d~yqz))&B D?AwK%)+)F2aNwI|siOe' ); define( 'AUTH_SALT', '7T-!^i!0,w)L#JK@pc2{8XE[DenYI^BVf{L:jvF,hf}zBf883td6D;Vcy8,S)-&G' ); define( 'SECURE_AUTH_SALT', 'I6`V|mDZq21-J|ihb u^q0F }F_NUcy`l,=obGtq*p#Ybe4a31R,r=|n#=]@]c #' ); define( 'LOGGED_IN_SALT', 'w<$4c$Hmd%/*]`Oom>(hdXW|0M=X={we6;Mpvtg+V.o<$|#_}qG(GaVDEsn,~*4i' ); define( 'NONCE_SALT', 'a|#h{c5|P &xWs4IZ20c2&%4!c(/uG}W:mAvy<I44`jAbup]t=]V<`}.py(wTP%%' ); Note: Do not use the above as is either change these to different unique phrases by changing a few characters in each line (keep the line length the same) or use the online generator. Save the wp-config.php file Step 4: Upload the filesNow you will need to decide where on your domain you'd like your WordPress-powered site to appear:
Note: In the Root DirectoryCopy all the contents of the wordpress directory (but not the directory itself) into the root directory of your web site.
In a SubdirectoryRename the wordpress directory to your desired name, then copy the directory to your desired location within the root directory of your web site
Step 5: Run the Install ScriptPoint a web browser to start the installation script.
Finishing installationEnter language, your site title, your desired user name, your choice of a password (twice) and your e-mail address. Also displayed is a check-box asking if you would like your blog to appear in search engines like Google. Leave the box checked if you would like your blog to be visible to everyone, including search engines, and uncheck the box if you want to block search engines, but allow normal visitors. Note all this information can be changed later in your Administration Panels
--oOo--
|


46
1 Bel bows down, Nebo stoops; their idols
weigh down the animals carrying them.
I made you, and I will support you, I will carry you to safety.
5 To whom will you compare me? And whom do I resemble, so that we may be compared?
6 People pour out gold from the bag and weigh silver on the scale.
They hire a metalsmith, and he makes it into a god; they bow down and worship it.
7 They lift it on their shoulder and carry it; they set it in its place, and it stands in its place and does not move from it.
They cry out to it, but it cannot answer nor save anyone from his trouble.
8 Think about these things; never ignore them, you rebels!
9 Think about the earlier things, those of times past,
for I am God, and there is no other, I am God, and there is no one like me.
10 I announce the end from the beginning, and beforehand what has not yet happened;
I say, "My plan will happen, and I will do as I desire."
11 I call a bird of prey from the east, the man of my choice from a distant land;
yes, I have spoken; I will also accomplish
it; I have purposed, I will also do it.
12 Listen to me, you stubborn people, who are far from doing what is right.
13 I am bringing my righteousness near; it is not far away, and my salvation does not wait;
and I will give salvation to Zion and my beauty to Israel.


LabelMe is a WEB-based image annotation tool that allows researchers to label images and share the annotations with the world.
LabelMe allows:
1. Start by creating a collection. Press the button on the
top-right corner of the screen.
2. To upload an image into the new collection, open the
collection that you have created by clicking on the collection icon
that will appear on the screen. Then you can upload an image by
clicking the icon . We only allow .jpg images.
3. Once an image is uploaded, you can annotate it by clicking on the
image thumbnail. This will open the annotation tool.
For navigation you can use the LabelMe hyperlinks or your web-browser navigation buttons.
There will be two settings for each collection: listed or unlisted. Unlisted collections are ones that anyone can view if they have access to the URL, but will not be displayed in the set of public folders.
Please make sure that the images you upload are copyright-free and do not contain inappropriate content. The images that you upload and annotate will be considered part of the public domain. As the goal of LabelMe is to provide a tool for research, the images and annotations are expected to become available to the research comunity without restrictions.
You are free to post your collected database of images and annotations on your own website. For example, you may do this when you release your database with your research publications.
If you use the dataset or any functions on this website, we would
appreciate it if you cite:
B. C. Russell, A. Torralba, K. P. Murphy, W. T. Freeman,
LabelMe: a database and web-based tool for image annotation.
International Journal of Computer Vision, pages 157-173, Volume 77, Numbers 1-3, May, 2008.
(paper.pdf)
Let us know if there are new features that you would like to see in the tool.


This is text message
This is text message
This is text message
This is text message
This is text message
This is text message
This is text message
This is text message
This is text message
This is text message
This is text message
This is text message
This is text message


| Opcode | Instruction | Op/En | 64-bit Mode | Compat/Leg Mode | Description |
|---|---|---|---|---|---|
| 66 0F AE /7 | CLFLUSHOPT m8 | M | Valid | Valid | Flushes cache line containing m8. |
| Op/En | Operand 1 | Operand 2 | Operand 3 | Operand 4 |
| M | ModRM:r/m (w) | NA | NA | NA |
Invalidates from every level of the cache hierarchy in the cache coherence domain the cache line that contains the linear address specified with the memory operand. If that cache line contains modified data at any level of the cache hierarchy, that data is written back to memory. The source operand is a byte memory location.
The availability of CLFLUSHOPT is indicated by the presence of the CPUID feature flag CLFLUSHOPT (CPUID.(EAX=7,ECX=0):EBX[bit 23]). The aligned cache line size affected is also indicated with the CPUID instruc-tion (bits 8 through 15 of the EBX register when the initial value in the EAX register is 1).
The memory attribute of the page containing the affected line has no effect on the behavior of this instruction. It should be noted that processors are free to speculatively fetch and cache data from system memory regions assigned a memory-type allowing for speculative reads (such as, the WB, WC, and WT memory types). PREFETCHh instructions can be used to provide the processor with hints for this speculative behavior. Because this speculative fetching can occur at any time and is not tied to instruction execution, the CLFLUSH instruction is not ordered with respect to PREFETCHh instructions or any of the speculative fetching mechanisms (that is, data can be specula-tively loaded into a cache line just before, during, or after the execution of a CLFLUSH instruction that references the cache line).
Executions of the CLFLUSHOPT instruction are ordered with respect to fence instructions and to locked read-modify-write instructions; they are also ordered with respect to the following accesses to the cache line being inval-idated: writes, executions of CLFLUSH, and executions of CLFLUSHOPT. They are not ordered with respect to writes, executions of CLFLUSH, or executions of CLFLUSHOPT that access other cache lines; to enforce ordering with such an operation, software can insert an SFENCE instruction between CFLUSHOPT and that operation.
The CLFLUSHOPT instruction can be used at all privilege levels and is subject to all permission checking and faults associated with a byte load (and in addition, a CLFLUSHOPT instruction is allowed to flush a linear address in an execute-only segment). Like a load, the CLFLUSHOPT instruction sets the A bit but not the D bit in the page tables.
In some implementations, the CLFLUSHOPT instruction may always cause transactional abort with Transactional Synchronization Extensions (TSX). The CLFLUSHOPT instruction is not expected to be commonly used inside typical transactional regions. However, programmers must not rely on CLFLUSHOPT instruction to force a transactional abort, since whether they cause transactional abort is implementation dependent.
CLFLUSHOPT operation is the same in non-64-bit modes and 64-bit mode.
Flush_Cache_Line_Optimized(SRC);
CLFLUSHOPT:void _mm_clflushopt(void const *p)
| #GP(0) | For an illegal memory operand effective address in the CS, DS, ES, FS or GS segments. |
| #SS(0) | For an illegal address in the SS segment. |
| #PF(fault-code) | For a page fault. |
| #UD |
If CPUID.(EAX=7,ECX=0):EBX.CLFLUSHOPT[bit 23] = 0. If the LOCK prefix is used. If an instruction prefix F2H or F3H is used. |
| #GP | If any part of the operand lies outside the effective address space from 0 to FFFFH. |
| #UD |
If CPUID.(EAX=7,ECX=0):EBX.CLFLUSHOPT[bit 23] = 0. If the LOCK prefix is used. If an instruction prefix F2H or F3H is used. |
Same exceptions as in real address mode.
| #PF(fault-code) | For a page fault. |
Same exceptions as in protected mode.
| #SS(0) | If a memory address referencing the SS segment is in a non-canonical form. |
| #GP(0) | If the memory address is in a non-canonical form. |
| #PF(fault-code) | For a page fault. |
| #UD |
If CPUID.(EAX=7,ECX=0):EBX.CLFLUSHOPT[bit 23] = 0. If the LOCK prefix is used. If an instruction prefix F2H or F3H is used. |


Different People Have Different Opinions
Forgot password?
Or
Continue with Email
Already a user?
"Everything we hear is an opinion, not a fact. Everything we see is a perspective, not the truth."
-Marcus Aurelius


The Walking Dead: Maggie's Return May Come Sooner Than You Expect
by Sundi RoseAhead of the Season 10 midseason finale, The Walking Dead showrunner Angela Kang revealed Lauren Cohen's Maggie Rhee is set to return for Season 11 -- but she could come back even sooner.
When asked if audiences might get a glimpse of the character before season 11, Kang told Deadline, "She will come back as a series regular in Season 11, but you know, we may see her before that."
She wouldn't elaborate on any more details about the character's return, but she was supportive about the circumstances surrounding Cohen's departure and her subsequent return. Kang stressed that, even though Cohen left to "spread her wings," the door was always open for her to return as Maggie.
Click the button below to start this article in quick view.
Without revealing anything specific about Maggie's future, Kang said, "I’m just excited to kind of write her next chapter because she’s just a lovely human being and a really compelling character, too, I think."
RELATED: The Walking Dead: Oceanside Finds a Stranger in Its Midst
Kang also spoke about Dani Gurira's last season playing fan favorite character Michonne and what this means for the future of the show. She promised there is still more to come for Michonne in the second half of the show, and her departure is the result of careful mapping on the part of Kang and the show's writers.
The Walking Dead stars Norman Reedus, Danai Gurira, Melissa McBride, Josh McDermitt, Christian Serratos, Jeffrey Dean Morgan, Seth Gilliam, Ross Marquand, Khary Payton, Cooper Andrews, Avi Nash, and Samantha Morton. The midseason finale will air Sunday at 9 p.m. ET/PT on AMC.
https://schema.orgBreadcrumbListListItem1Homehttps://www.cbr.com/ListItem2TVhttps://www.cbr.com/category/tv/ListItem3TV Newshttps://www.cbr.com/category/tv/news-tv/ListItem4The Walking Dead: Maggie's Return May Come Sooner Than You Expecthttps://www.cbr.com/walking-dead-maggie-return-soon/


|
cds
1.2.0
|
Array of retired pointers. More...
#include <cds/gc/hzp/details/hp_retired.h>
Public Types | |
|
typedef retired_vector_impl::iterator | iterator |
| Iterator. |
Public Member Functions | |
| retired_vector (const cds::gc::hzp::GarbageCollector &HzpMgr) | |
| Constructor. | |
| size_t | capacity () const |
| Vector capacity. | |
| size_t | size () const |
| Current vector size (count of retired pointers in the vector) | |
| void | size (size_t nSize) |
| Set vector size. Uses internally. | |
| void | push (const retired_ptr &p) |
| Pushes retired pointer to the vector. | |
| bool | isFull () const |
| Checks if the vector is full (size() == capacity() ) | |
| iterator | begin () |
| Begin iterator. | |
| iterator | end () |
| End iterator. | |
| void | clear () |
| Clears the vector. After clearing, size() == 0. |
Private Types | |
|
typedef cds::details::bounded_array < retired_ptr > | retired_vector_impl |
| Underlying vector implementation. |
Private Attributes | |
| retired_vector_impl | m_arr |
| the array of retired pointers | |
| size_t | m_nSize |
Current size of m_arr . |
Array of retired pointers.
The vector of retired pointer ready to delete.
The Hazard Pointer schema is build on thread-static arrays. For each HP-enabled thread the HP manager allocates array of retired pointers. The array belongs to the thread: owner thread writes to the array, other threads just read it.
|
inline |
Vector capacity.
The capacity is constant for any thread. It is defined by cds::gc::hzp::GarbageCollector.


Contact Information
Please feel free to contact us Monday through Friday during open business hours for any questions or concerns you may have. We would love your feedback as well!
- Customer Service: 1-800-911-1000
- Email<EMAIL_ADDRESS>Store Locations
- 1st and Pike
- 1st Ave & Pike StSeattle, WA 98101
- SeaTac Airport
- 17801 International Blvd, Seattle, WA 98158
- Seattle Center
- 305 Harrison St, Seattle, WA 98109
- Capital Hill
- Capitol HillSeattle, WA
- Alki
- 1702 Alki Ave SW, Seattle, WA 98127
Store Hours
- Monday through Friday
- 6am to 8pm
Merchandice
We are new company to the State of Washington, we hope that so far you have enjoyed our creative cookies and will help us spread the word! If you are loking to meet new people or new a conversation starter, order one of our fun shirts! Be the hit of the party while you rock that Salmon shirt and represent the best new cookies in the state! Immpress your friends and family with your new atttire, you'll be swimming in an ocean of compliments!
About Us
We are a new cookie shop, starting out in the Seattle area. Seattle is known for their world renowned seafood, especially when it comes to the pride we have for our Salmon. Have you ever been down to Pike Place Market and seen the flying fish? It's an amazing attraction and people come from all over to see the show! Well wanted to expand on that and come up with another attraction that would bring people from all over. Well thanks to our delicious Salmon we came up with an interestingly tasty treat!  Enjoy a Salmon cookie as you walk downtown on the waterfront and let the flavor swim around in your mouth! Our hope is to go state wide and spread the love of our Salmon cookies to all of Washington!


MENTERTAIN
Home
Celebrities
News & Gossip
Movies
Galleries
ALL
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
All Movies
Loading ...
Now In Theatres
Loading ...
Releasing Soon
Loading ...


The code for this tutorial can't run. It's all just example code. Please view source or open it in a text editor.


Interface IDxfSpec<T>
And interface that defines the members for the IDxfSpec type. This type is the interface between *.spec.json files and the application code.
Namespace: DxfLibrary.DxfSpec
Assembly: DxfLibrary.dll
Syntax
public interface IDxfSpec<T>
Type Parameters
| Name | Description |
|---|---|
| T | The type of the SpecProperty. This is usually just object however it was chosen to be a generic type because of the option that it might not always be benifitial to be just an object. |
Properties
| Improve this Doc View SourceProperties
A list of properties that the specification specifies
Declaration
List<DxfSpecProperty<T>> Properties { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Collections.Generic.List<DxfSpecProperty<T>> |
SpecName
The name of the specification
Declaration
string SpecName { get; }
Property Value
| Type | Description |
|---|---|
| System.String |
SpecType
The type that the specification is describing
Declaration
string SpecType { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String |
Methods
| Improve this Doc View SourceGet(String)
Gets a property from the Properties list using the name provided
Declaration
T Get(string name)
Parameters
| Type | Name | Description |
|---|---|---|
| System.String | name | The name of the property that is to be retrieved |
Returns
| Type | Description |
|---|---|
| T | A property |


The Westside of Manhattan between 125th Street and around 160th Street contains several pocket neighborhoods and can be called different names depending on who you talk to. Among these are Sugar Hill, The Grange, Hamilton Heights and way back when, it was also known as the Gold Coast. Most people who've been there a long time just call it West Harlem. But that may be because they don't want you to know where they live exactly.
Excerpted from, The Macaulay Messenger, The Official Student Newspaper of Macaulay Honors College at CUNY:
For over a hundred years, City College has defined the neighborhood’s landscape. Its neo-Gothic structures, decorated with terra cotta gargoyles, reach above the surrounding architecture. The sides of the campus are marked with four gates: Hudson Gate (Amsterdam Avenue), Alexander Hamilton Gate (Convent Avenue), George Washington Gate (138th Street and Convent Avenue), and Peter Stuyvesant Gate (St. Nicholas Terrace).
Of the several parks in the area, the largest and most impressive is certainly Riverbank State Park off of Riverside Drive, between 138th and 145th. Named for its place on the Hudson River. The park was constructed on top of a sewage treatment facility, in response to residents’ complaints about the facility’s location. Its design was inspired by Japanese urban rooftop architecture. The park’s twenty-eight acres hold a rink for ice-skating and roller-blading, carousel, running track, indoor and outdoor swimming pools, and a restaurant, among other attractions.


I've been a full-stack web software architect and system admin, or as they say these days, experienced in "DevOps", for over 18 years. I specialize in the architecture and design of applications using dynamic languages, using a service oriented approach. I have been a completely remote worker, or telecommuter, for the past 15 years and understand the high levels of communication and self discipline required. I'm a huge supporter of open source software and have contributed to many projects over the years on both github and SourceForge.
Bachelor of Fine Arts, Magna Cum Laude
Major: Visual Communication, Digital Design
Major: Computer Science, Major: Electrical Engineering, Minor: History
Major: Electrical and Computer Engineering
I have worked with Adam at two different companies and have known him for over a decade. Adam is the finest programmer I have ever had the pleasure to work with. His depth of knowledge of several languages and methodologies, most specifically Python, is astounding. He is a true self-starter and I have never known him to shy away from learning something new, often becoming an expert on the subject in a very short time. It should also be noted that he is one of the finest network security minds in the industry. I will always attempt to hire him whenever I'm in the position to do so.
Adam is a very capable leader and developer. I have worked alongside him for many years and have learned a lot not only about being a better developer but also about myself and what I can accomplish.
Adam is very gifted in his understanding of technology. Whenever I wanted something fixed I called Adam. He gets the job done right the first time!
I had the privilege to work with Adam at a time when PC networking was beggining to take hold at Advance Auto Parts (AAP.) Adam was instrumental in advocating, architecting and implementating critical infrastructure services. As an IT professional Adam is diverse and a true technical wiz who loves solving problems and making disparate systems work uniformaly. Problem solving, deep technical knowledge base, a strong foundation and Adam's personal commitment to his projects make him a bargain in consideration for employemt. I would highly recommend him for just about any IT related activity as I have seen him rise to the occasion in many times of critical need. If you have the opportuniuty to leverage Adam as a resource consider yourself fortunate and have confidence that what you are attempting will be complete and functional on time and in budget.


--- layout: resume title: Justin Williamson subtitle: Information Technology Engineer use-site-title: true bigimg: - /img/slider/boardman.jpg - /img/slider/path.jpg - /img/slider/mackinac-bridge-3573219_1920.jpg - /img/slider/clint-adair-68588-unsplash.jpg - /img/slider/nathan-anderson-141325-unsplash.jpg meta-description: Home page of the personal website for Justin Williamson skills: - Ubuntu/Debian/CentOS - VMWare/Proxmox - Ansible - Docker/LXC - Python/Bash - Powershell/Batch - Windows Domains - Office 365/G Suite - Windows 7/10 - TCP/IP Networking - pfSense/Sophos Firewalls/UTM - Trend Micro/Sophos/BitDefender ---
Hey! My name is Justin. I'm a technology professional with 6 years of work experience and over 20 years of self-study and passion. I currently reside in Traverse City and would love to make it my permanent home
As a young teen I was tinkering with a hand-me-down computer and learning the ins and outs of DOS, Windows 3.1, and hand typing code from a book into a QBASIC editor. Fast forward a few years and I was doing static HTML on a GeoCities site.
What really ignited my passion was the original Xbox and the moding community that surrounded it. By early 2000's I had a home network setup with a file server for all my "Linux ISO's" and was streaming them all around my network.
As time went on, my homelab grew and the technologies that I employed expanded to include virtualization and advanced networking.
{{- skill -}}


Try out our Premium Member services: Virtual Legal Assistant, Query Alert Service and an ad-free experience. Free for one month and pay only if you like it.
WP No. 862 of 2010 IN THE HIGH COURT AT CALCUTTA Constitutional Writ Jurisdiction ORIGINAL SIDE JAININD Petitioner Versus STATE OF WEST BENGAL & ORS. Respondents
For Petitioner : Ms. Manju Agarwal, Advocate For PCB : Mr. Kallol Bose, Advocate For State : Ms. Biswarupa Mitra, Advocate For CESC Ltd. : Mr. Somenath Bose, Advocate BEFORE:
The Hon'ble CHIEF JUSTICE The Hon'ble JUSTICE BHATTACHARYA Date : 20th August, 2010.
The Court : Learned Counsel appearing for the writ petitioner submits that she may be permitted to withdraw the writ petition to enable her client to prefer an appeal under Section 31 of the Air (Prevention and Control of Pollution) Act, 1981 against the impugned order and in the meantime the Court may continue with the statement made by the petitioner on 16th July, 2010, that is, the petitioner will not start the unit without permission of this 2 Court, which was accepted as an undertaking and this Court further directs the parties to preserve status quo till the next date of hearing, which has been extended from time to time.
We, therefore, permit the petitioner to withdraw this writ petition with liberty to file appeal under Section 31 of the said Act. It is made clear that if the petitioner prefers an appeal within two weeks from the date of passing of the order, till then the respondents would not take any action against the petitioner subject to the petitioner maintaining status quo as on the date of passing the impugned order, that is, it will not operate the unit.
It will be open for the petitioner to urge all the issues and contentions which are raised in this petition before the Appellate Authority.
The Appellate Authority shall decide the matter on merits in accordance with law.
Urgent photostat certified copy of this order, if applied for, be supplied to the parties subject to compliance with all requisite formalities.
(J.N. PATEL, CJ.) (BHATTACHARYA, J.) SN.
Asst.Registrar(CR)


Variable
| Static Public Summary | ||
| public |
The opposite of Before. |
|
| public |
The opposite of Before. |
|
| public |
Creates a function that invokes func, with up to n arguments, ignoring any additional arguments. |
|
| public |
Attempt(args: ...*): * Attempts to invoke func, returning either the result or the caught error object. |
|
| public |
Creates a function that invokes func, with the this binding and arguments of the created function, while it's called less than n times. Subsequent calls to the created function return the result of the last func invocation. |
|
| public |
Creates a function that invokes func, with the this binding and arguments of the created function, while it's called less than n times. Subsequent calls to the created function return the result of the last func invocation. |
|
| public |
Bind(partials: ...*): * Creates a function that invokes func with the this binding of thisArg and partials prepended to the arguments it receives. |
|
| public |
Creates a function that accepts arguments of func and either invokes func returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining func arguments, and so on. |
|
| public |
Creates a function that accepts arguments of func and either invokes func returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining func arguments, and so on. |
|
| public |
CurryRight(arity: number): * This method is like .curry except that arguments are applied to func in the manner of .partialRight instead of _.partial. |
|
| public |
CurryRightAll(arity: number): * This method is like .curry except that arguments are applied to func in the manner of .partialRight instead of _.partial. |
|
| public |
Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked. |
|
| public |
DebounceAll(wait: number, options: DebounceOptions): * Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked. |
|
| public |
|
|
| public |
Defer(args: ...*): * Defers invoking the func until the current call stack has cleared. |
|
| public |
Invokes func after wait milliseconds. |
|
| public |
Flip: * Creates a function that invokes func with arguments reversed. |
|
| public |
Flow: * Creates a function that returns the result of invoking the given functions with the this binding of the created function, where each successive invocation is supplied the return value of the previous. |
|
| public |
FlowRight: * Creates a function that returns the result of invoking the given functions with the this binding of the created function, where each successive invocation is supplied the return value of the previous. |
|
| public |
InstanceChainMap: buildDocs/utils.js~CompositeKeyWeakMap |
|
| public |
Memoize: * |
|
| public |
MemoizeAll(resolver: Function): * Memoizes a function on the prototype instead of the instance. |
|
| public |
Negate: * |
|
| public |
Once: * |
|
| public |
OnceAll: * |
|
| public |
OverArgs: * |
|
| public |
Partial: * |
|
| public |
PartialRight: * |
|
| public |
Rearg: * |
|
| public |
Rest: * |
|
| public |
Spread: * |
|
| public |
Tap: * Returns the first argument from the function regardless of the decorated functions return value. |
|
| public |
Throttle: * |
|
| public |
ThrottleAll: * |
|
| public |
|
|
| public |
|
|
| public |
Unary: * |
|
| public |
Wrap: * |
Static Public
public After(n: number): * source
import {After} from 'lodash-decorators/buildDocs/after.js'
The opposite of Before. This method creates a function that invokes once it's called n or more times.
Example:
class MyClass {
@After(2)
fn() {
return 10;
}
}
const myClass = new MyClass();
myClass.fn(); // => undefined
myClass.fn(); // => 10
public AfterAll(n: number): * source
import {AfterAll} from 'lodash-decorators/buildDocs/afterAll.js'
The opposite of Before. This method creates a function that invokes once it's called n or more times. This spans across all instances of the class instead of the instance.
Example:
class MyClass {
@AfterAll(2)
fn() {
return 10;
}
}
const myClass = new MyClass();
const myClass2 = new MyClass();
myClass.fn(); // => undefined
myClass.fn(); // => 10
myClass2.fn(); // => 10
myClass2.fn(); // => 10
public Ary(n: number): * source
import {Ary} from 'lodash-decorators/buildDocs/ary.js'
Creates a function that invokes func, with up to n arguments, ignoring any additional arguments.
Example:
class MyClass {
@Ary(1)
fn(...args) {
return args;
}
}
const myClass = new MyClass();
myClass.fn(1, 2, 3, 4); // => [ 1 ]
public Attempt(args: ...*): * source
import {Attempt} from 'lodash-decorators/buildDocs/attempt.js'
Attempts to invoke func, returning either the result or the caught error object. Any additional arguments are provided to func when it's invoked.
Example:
class MyClass {
@Attempt()
fn(value) {
if (typeof value === 'number') {
return value
}
throw new Error();
}
}
const myClass = new MyClass();
myClass.fn(10); // => 10;
myClass.fn(null); // => Error
public Before(n: number): * source
import {Before} from 'lodash-decorators/buildDocs/before.js'
Creates a function that invokes func, with the this binding and arguments of the created function, while it's called less than n times. Subsequent calls to the created function return the result of the last func invocation.
Example:
let calls = 0;
class MyClass {
@Before(3)
fn() {
calls++;
}
}
const myClass = new MyClass();
myClass.fn();
myClass.fn();
myClass.fn();
myClass.fn();
calls === 2; // => true
public BeforeAll(n: number): * source
import {BeforeAll} from 'lodash-decorators/buildDocs/beforeAll.js'
Creates a function that invokes func, with the this binding and arguments of the created function, while it's called less than n times. Subsequent calls to the created function return the result of the last func invocation.
Example:
let calls = 0;
class MyClass {
@BeforeAll(3)
fn() {
calls++;
}
}
const myClass = new MyClass();
const myClass2 = new MyClass();
myClass.fn();
myClass.fn();
myClass.fn();
myClass.fn();
myClass2.fn();
calls === 3; // => true
public Bind(partials: ...*): * source
import {Bind} from 'lodash-decorators/buildDocs/bind.js'
Creates a function that invokes func with the this binding of thisArg and partials prepended to the arguments it receives.
The .bind.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for partially applied arguments.
Note: Unlike native Function#bind, this method doesn't set the "length" property of bound functions.
Example:
class MyClass {
@Bind()
bound() {
return this;
}
unbound() {
return this;
}
}
const myClass = new MyClass();
myClass.bound.call(null); // => myClass {}
myClass.unbound.call(null); // => null
public Curry(arity: number): * source
import {Curry} from 'lodash-decorators/buildDocs/curry.js'
Creates a function that accepts arguments of func and either invokes func returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining func arguments, and so on.
The arity of func may be specified if func.length is not sufficient.
The original function is bound to the instance. If the method is needed to call in a different context use CurryAll
.
The .curry.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for provided arguments.
Note: This method doesn't set the "length" property of curried functions.
Example:
class MyClass {
multiplier = 2;
@Curry()
add(a, b) {
return (a + b) * this.multiplier;
}
}
const myClass = new MyClass();
const add5 = myClass.add(5);
add5AndMultiply(10); // => 30
public CurryAll(arity: number): * source
import {CurryAll} from 'lodash-decorators/buildDocs/curryAll.js'
Creates a function that accepts arguments of func and either invokes func returning its result, if at least arity number of arguments have been provided, or returns a function that accepts the remaining func arguments, and so on. The arity of func may be specified if func.length is not sufficient.
The .curry.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for provided arguments.
Note: This method doesn't set the "length" property of curried functions.
Note: The original function invoked will not be called in the context of the instance. Use Curry
to for using it bound.
Example:
class MyClass {
@CurryAll()
add(a, b) {
return (a + b);
}
}
const myClass = new MyClass();
const add5 = myClass.add(5);
add5AndMultiply(10); // => 15
public CurryRight(arity: number): * source
import {CurryRight} from 'lodash-decorators/buildDocs/curryRight.js'
This method is like .curry except that arguments are applied to func in the manner of .partialRight instead of _.partial.
The arity of func may be specified if func.length is not sufficient.
The original function is bound to the instance. If the method is needed to call in a different context use CurryAll
.
The .curryRight.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for provided arguments.
Note: This method doesn't set the "length" property of curried functions.
Example:
class MyClass {
multiplier = 2;
@CurryRight()
add(a, b) {
return (a + b) * this.multiplier;
}
}
const myClass = new MyClass();
const add5 = myClass.add(5);
add5AndMultiply(10); // => 30
public CurryRightAll(arity: number): * source
import {CurryRightAll} from 'lodash-decorators/buildDocs/curryRightAll.js'
This method is like .curry except that arguments are applied to func in the manner of .partialRight instead of _.partial.
The arity of func may be specified if func.length is not sufficient.
The original function is bound to the instance. If the method is needed to call in a different context use CurryAll
.
The .curryRight.placeholder value, which defaults to in monolithic builds, may be used as a placeholder for provided arguments.
Note: This method doesn't set the "length" property of curried functions.
Example:
class MyClass {
@CurryRightAll()
add(a, b) {
return (a + b);
}
}
const myClass = new MyClass();
const add5 = myClass.add(5);
add5AndMultiply(10); // => 15
public Debounce(wait: number, options: DebounceOptions): * source
import {Debounce} from 'lodash-decorators/buildDocs/debounce.js'
Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked. The debounced function comes with a cancel method to cancel delayed func invocations and a flush method to immediately invoke them. Provide options to indicate whether func should be invoked on the leading and/or trailing edge of the wait timeout. The func is invoked with the last arguments provided to the debounced function. Subsequent calls to the debounced function return the result of the last func invocation.
Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if the debounced function is invoked more than once during the wait timeout.
If wait is 0 and leading is false, func invocation is deferred until to the next tick, similar to setTimeout with a timeout of 0.
Example:
class MyClass {
value = 100;
@Debounce(10)
add(a) {
this.value += a;
}
}
const myClass = new MyClass();
myClass.add(10);
myClass.add(50);
myClass.add(20);
myClass.value; // => 100;
setTimeout(() => {
myClass.value; // => 120;
}, 11);
public DebounceAll(wait: number, options: DebounceOptions): * source
import {DebounceAll} from 'lodash-decorators/buildDocs/debounceAll.js'
Creates a debounced function that delays invoking func until after wait milliseconds have elapsed since the last time the debounced function was invoked. The debounced function comes with a cancel method to cancel delayed func invocations and a flush method to immediately invoke them. Provide options to indicate whether func should be invoked on the leading and/or trailing edge of the wait timeout. The func is invoked with the last arguments provided to the debounced function. Subsequent calls to the debounced function return the result of the last func invocation.
The debounce state is shared across all instances of the class.
Note: If leading and trailing options are true, func is invoked on the trailing edge of the timeout only if the debounced function is invoked more than once during the wait timeout.
If wait is 0 and leading is false, func invocation is deferred until to the next tick, similar to setTimeout with a timeout of 0.
Example:
class MyClass {
value = 100;
@DebounceAll(10)
add(a) {
this.value += a;
}
}
const myClass = new MyClass();
myClass.add(10);
myClass.add(50);
myClass.add(20);
myClass.value; // => 100;
setTimeout(() => {
myClass.value; // => 120;
}, 11);
public DecoratorFactory: InternalDecoratorFactory source
import {DecoratorFactory} from 'lodash-decorators/buildDocs/factory/DecoratorFactory.js'
public Defer(args: ...*): * source
import {Defer} from 'lodash-decorators/buildDocs/defer.js'
Defers invoking the func until the current call stack has cleared. Any additional arguments are provided to func when it's invoked.
Example:
class MyClass {
value = 100;
@Defer()
add(a) {
this.value += a;
}
}
const myClass = new MyClass();
myClass.add(10);
myClass.value; // => 100;
setTimeout(() => {
myClass.value; // => 110;
}, 0);
public Delay(wait: number, args: ...*): * source
import {Delay} from 'lodash-decorators/buildDocs/delay.js'
Invokes func after wait milliseconds. Any additional arguments are provided to func when it's invoked.
Example:
class MyClass {
value = 100;
@Delay(20)
add(a) {
this.value += a;
}
}
const myClass = new MyClass();
myClass.add(10);
myClass.value; // => 100;
setTimeout(() => {
myClass.value; // => 110;
}, 30);
public Flip: * source
import {Flip} from 'lodash-decorators/buildDocs/flip.js'
Creates a function that invokes func with arguments reversed. Honestly, there is probably not much use for this decorator but maybe you will find one?
Example:
class MyClass {
value = 100;
@Flip()
fn(a, b) {
return [ a, b ];
}
}
const myClass = new MyClass();
myClass.fn(10, 20); // => [ 20, 10 ]
public Flow: * source
import {Flow} from 'lodash-decorators/buildDocs/flow.js'
Creates a function that returns the result of invoking the given functions with the this binding of the created function, where each successive invocation is supplied the return value of the previous.
Example:
class MyClass {
name = 'Ted';
@Flow('getName', toUpperCase)
getUpperCaseName: () => string;
getName() {
return this.name;
}
}
const myClass = new MyClass();
myClass.getUpperCaseName(); // => 'TED'
public FlowRight: * source
import {FlowRight} from 'lodash-decorators/buildDocs/flowRight.js'
Creates a function that returns the result of invoking the given functions with the this binding of the created function, where each successive invocation is supplied the return value of the previous.
Example:
class MyClass {
name = 'Ted';
@FlowRight(toUpperCase, 'getName')
getUpperCaseName: () => string;
getName() {
return this.name;
}
}
const myClass = new MyClass();
myClass.getUpperCaseName(); // => 'TED'
public InstanceChainMap: buildDocs/utils.js~CompositeKeyWeakMap source
import {InstanceChainMap} from 'lodash-decorators/buildDocs/factory/common.js'
public MemoizeAll(resolver: Function): * source
import {MemoizeAll} from 'lodash-decorators/buildDocs/memoizeAll.js'
Memoizes a function on the prototype instead of the instance. All instances of the class use the same memoize cache.
public PartialRight: * source
import {PartialRight} from 'lodash-decorators/buildDocs/partialRight.js'
public Tap: * source
import {Tap} from 'lodash-decorators/buildDocs/tap.js'
Returns the first argument from the function regardless of the decorated functions return value.
public ThrottleGetter: * source
import {ThrottleGetter} from 'lodash-decorators/buildDocs/throttle.js'
public ThrottleSetter: * source
import {ThrottleSetter} from 'lodash-decorators/buildDocs/throttle.js'


Camel
Introduction
The akka-camel module allows Untyped Actors to receive and send messages over a great variety of protocols and APIs. In addition to the native Scala and Java actor API, actors can now exchange messages with other systems over large number of protocols and APIs such as HTTP, SOAP, TCP, FTP, SMTP or JMS, to mention a few. At the moment, approximately 80 protocols and APIs are supported.
Apache Camel
The akka-camel module is based on Apache Camel, a powerful and light-weight integration framework for the JVM. For an introduction to Apache Camel you may want to read this Apache Camel article. Camel comes with a large number of components that provide bindings to different protocols and APIs. The camel-extra project provides further components.
Consumer
Here's an example of using Camel's integration components in Akka.
import akka.camel.CamelMessage;
import akka.camel.javaapi.UntypedConsumerActor;
public class MyEndpoint extends UntypedConsumerActor{
private String uri;
public String getEndpointUri() {
return uri;
}
public void onReceive(Object message) throws Exception {
if (message instanceof CamelMessage) {
/* ... */
} else
unhandled(message);
}
// Extra constructor to change the default uri,
// for instance to "jetty:http://localhost:8877/example"
public MyEndpoint(String uri) {
this.uri = uri;
}
public MyEndpoint() {
this.uri = "mina2:tcp://localhost:6200?textline=true";
}
}
The above example exposes an actor over a TCP endpoint via Apache Camel's Mina component. The actor implements the getEndpointUri method to define an endpoint from which it can receive messages. After starting the actor, TCP clients can immediately send messages to and receive responses from that actor. If the message exchange should go over HTTP (via Camel's Jetty component), the actor's getEndpointUri method should return a different URI, for instance "jetty:http://localhost:8877/example". In the above case an extra constructor is added that can set the endpoint URI, which would result in the getEndpointUri returning the URI that was set using this constructor.
Producer
Actors can also trigger message exchanges with external systems i.e. produce to Camel endpoints.
import akka.camel.javaapi.UntypedProducerActor;
public class Orders extends UntypedProducerActor {
public String getEndpointUri() {
return "jms:queue:Orders";
}
}
In the above example, any message sent to this actor will be sent to the JMS queue Orders. Producer actors may choose from the same set of Camel components as Consumer actors do. Below an example of how to send a message to the Orders producer.
ActorSystem system = ActorSystem.create("some-system");
Props props = Props.create(Orders.class);
ActorRef producer = system.actorOf(props, "jmsproducer");
producer.tell("<order amount=\"100\" currency=\"PLN\" itemId=\"12345\"/>",
ActorRef.noSender());
CamelMessage
The number of Camel components is constantly increasing. The akka-camel module can support these in a plug-and-play manner. Just add them to your application's classpath, define a component-specific endpoint URI and use it to exchange messages over the component-specific protocols or APIs. This is possible because Camel components bind protocol-specific message formats to a Camel-specific normalized message format. The normalized message format hides protocol-specific details from Akka and makes it therefore very easy to support a large number of protocols through a uniform Camel component interface. The akka-camel module further converts mutable Camel messages into immutable representations which are used by Consumer and Producer actors for pattern matching, transformation, serialization or storage. In the above example of the Orders Producer, the XML message is put in the body of a newly created Camel Message with an empty set of headers. You can also create a CamelMessage yourself with the appropriate body and headers as you see fit.
CamelExtension
The akka-camel module is implemented as an Akka Extension, the CamelExtension object. Extensions will only be loaded once per ActorSystem, which will be managed by Akka. The CamelExtension object provides access to the Camel interface. The Camel interface in turn provides access to two important Apache Camel objects, the CamelContext and the ProducerTemplate. Below you can see how you can get access to these Apache Camel objects.
ActorSystem system = ActorSystem.create("some-system");
Camel camel = CamelExtension.get(system);
CamelContext camelContext = camel.context();
ProducerTemplate producerTemplate = camel.template();
One CamelExtension is only loaded once for every one ActorSystem, which makes it safe to call the CamelExtension at any point in your code to get to the Apache Camel objects associated with it. There is one CamelContext and one ProducerTemplate for every one ActorSystem that uses a CamelExtension. By Default, a new CamelContext is created when the CamelExtension starts. If you want to inject your own context instead, you can implement the ContextProvider interface and add the FQCN of your implementation in the config, as the value of the "akka.camel.context-provider". This interface define a single method getContext() used to load the CamelContext.
Below an example on how to add the ActiveMQ component to the CamelContext, which is required when you would like to use the ActiveMQ component.
ActorSystem system = ActorSystem.create("some-system");
Camel camel = CamelExtension.get(system);
CamelContext camelContext = camel.context();
// camelContext.addComponent("activemq", ActiveMQComponent.activeMQComponent(
// "vm://localhost?broker.persistent=false"));
The CamelContext joins the lifecycle of the ActorSystem and CamelExtension it is associated with; the CamelContext is started when the CamelExtension is created, and it is shut down when the associated ActorSystem is shut down. The same is true for the ProducerTemplate.
The CamelExtension is used by both Producer and Consumer actors to interact with Apache Camel internally. You can access the CamelExtension inside a Producer or a Consumer using the camel method, or get straight at the CamelContext using the getCamelContext method or to the ProducerTemplate using the getProducerTemplate method. Actors are created and started asynchronously. When a Consumer actor is created, the Consumer is published at its Camel endpoint (more precisely, the route is added to the CamelContext from the Endpoint to the actor). When a Producer actor is created, a SendProcessor and Endpoint are created so that the Producer can send messages to it. Publication is done asynchronously; setting up an endpoint may still be in progress after you have requested the actor to be created. Some Camel components can take a while to startup, and in some cases you might want to know when the endpoints are activated and ready to be used. The Camel interface allows you to find out when the endpoint is activated or deactivated.
import akka.actor.ActorRef;
import akka.actor.ActorSystem;
import akka.actor.Props;
import akka.camel.Camel;
import akka.camel.CamelExtension;
import akka.camel.javaapi.UntypedConsumerActor;
import akka.testkit.JavaTestKit;
import akka.testkit.TestKit;
import akka.util.Timeout;
import docs.AbstractJavaTest;
import scala.concurrent.Future;
import scala.concurrent.duration.Duration;
import static java.util.concurrent.TimeUnit.SECONDS;
// ..
ActorSystem system = ActorSystem.create("some-system");
Props props = Props.create(MyConsumer.class);
ActorRef producer = system.actorOf(props,"myproducer");
Camel camel = CamelExtension.get(system);
// get a future reference to the activation of the endpoint of the Consumer Actor
Timeout timeout = new Timeout(Duration.create(10, SECONDS));
Future<ActorRef> activationFuture = camel.activationFutureFor(producer,
timeout, system.dispatcher());
The above code shows that you can get a Future to the activation of the route from the endpoint to the actor, or you can wait in a blocking fashion on the activation of the route. An ActivationTimeoutException is thrown if the endpoint could not be activated within the specified timeout. Deactivation works in a similar fashion:
// ..
system.stop(producer);
// get a future reference to the deactivation of the endpoint of the Consumer Actor
Future<ActorRef> deactivationFuture = camel.deactivationFutureFor(producer,
timeout, system.dispatcher());
Deactivation of a Consumer or a Producer actor happens when the actor is terminated. For a Consumer, the route to the actor is stopped. For a Producer, the SendProcessor is stopped. A DeActivationTimeoutException is thrown if the associated camel objects could not be deactivated within the specified timeout.
Consumer Actors
For objects to receive messages, they must inherit from the UntypedConsumerActor class. For example, the following actor class (Consumer1) implements the getEndpointUri method, which is declared in the UntypedConsumerActor class, in order to receive messages from the file:data/input/actor Camel endpoint.
import akka.camel.CamelMessage;
import akka.camel.javaapi.UntypedConsumerActor;
import akka.event.Logging;
import akka.event.LoggingAdapter;
public class Consumer1 extends UntypedConsumerActor {
LoggingAdapter log = Logging.getLogger(getContext().system(), this);
public String getEndpointUri() {
return "file:data/input/actor";
}
public void onReceive(Object message) {
if (message instanceof CamelMessage) {
CamelMessage camelMessage = (CamelMessage) message;
String body = camelMessage.getBodyAs(String.class, getCamelContext());
log.info("Received message: {}", body);
} else
unhandled(message);
}
}
Whenever a file is put into the data/input/actor directory, its content is picked up by the Camel file component and sent as message to the actor. Messages consumed by actors from Camel endpoints are of type CamelMessage. These are immutable representations of Camel messages.
Here's another example that sets the endpointUri to jetty:http://localhost:8877/camel/default. It causes Camel's Jetty component to start an embedded Jetty server, accepting HTTP connections from localhost on port 8877.
import akka.camel.CamelMessage;
import akka.camel.javaapi.UntypedConsumerActor;
public class Consumer2 extends UntypedConsumerActor {
public String getEndpointUri() {
return "jetty:http://localhost:8877/camel/default";
}
public void onReceive(Object message) {
if (message instanceof CamelMessage) {
CamelMessage camelMessage = (CamelMessage) message;
String body = camelMessage.getBodyAs(String.class, getCamelContext());
getSender().tell(String.format("Received message: %s",body), getSelf());
} else
unhandled(message);
}
}
After starting the actor, clients can send messages to that actor by POSTing to http://localhost:8877/camel/default. The actor sends a response by using the getSender().tell method. For returning a message body and headers to the HTTP client the response type should be CamelMessage. For any other response type, a new CamelMessage object is created by akka-camel with the actor response as message body.
Delivery acknowledgements
With in-out message exchanges, clients usually know that a message exchange is done when they receive a reply from a consumer actor. The reply message can be a CamelMessage (or any object which is then internally converted to a CamelMessage) on success, and a Failure message on failure.
With in-only message exchanges, by default, an exchange is done when a message is added to the consumer actor's mailbox. Any failure or exception that occurs during processing of that message by the consumer actor cannot be reported back to the endpoint in this case. To allow consumer actors to positively or negatively acknowledge the receipt of a message from an in-only message exchange, they need to override the autoAck method to return false. In this case, consumer actors must reply either with a special akka.camel.Ack message (positive acknowledgement) or a akka.actor.Status.Failure (negative acknowledgement).
import akka.actor.Status;
import akka.camel.Ack;
import akka.camel.CamelMessage;
import akka.camel.javaapi.UntypedConsumerActor;
public class Consumer3 extends UntypedConsumerActor{
@Override
public boolean autoAck() {
return false;
}
public String getEndpointUri() {
return "jms:queue:test";
}
public void onReceive(Object message) {
if (message instanceof CamelMessage) {
getSender().tell(Ack.getInstance(), getSelf());
// on success
// ..
Exception someException = new Exception("e1");
// on failure
getSender().tell(new Status.Failure(someException), getSelf());
} else
unhandled(message);
}
}
Consumer timeout
Camel Exchanges (and their corresponding endpoints) that support two-way communications need to wait for a response from an actor before returning it to the initiating client. For some endpoint types, timeout values can be defined in an endpoint-specific way which is described in the documentation of the individual Camel components. Another option is to configure timeouts on the level of consumer actors.
Two-way communications between a Camel endpoint and an actor are initiated by sending the request message to the actor with the ask pattern and the actor replies to the endpoint when the response is ready. The ask request to the actor can timeout, which will result in the Exchange failing with a TimeoutException set on the failure of the Exchange. The timeout on the consumer actor can be overridden with the replyTimeout, as shown below.
import akka.camel.CamelMessage;
import akka.camel.javaapi.UntypedConsumerActor;
import scala.concurrent.duration.Duration;
import scala.concurrent.duration.FiniteDuration;
import java.util.concurrent.TimeUnit;
public class Consumer4 extends UntypedConsumerActor {
private final static FiniteDuration timeout =
Duration.create(500, TimeUnit.MILLISECONDS);
@Override
public FiniteDuration replyTimeout() {
return timeout;
}
public String getEndpointUri() {
return "jetty:http://localhost:8877/camel/default";
}
public void onReceive(Object message) {
if (message instanceof CamelMessage) {
CamelMessage camelMessage = (CamelMessage) message;
String body = camelMessage.getBodyAs(String.class, getCamelContext());
getSender().tell(String.format("Hello %s",body), getSelf());
} else
unhandled(message);
}
}
Producer Actors
For sending messages to Camel endpoints, actors need to inherit from the UntypedProducerActor class and implement the getEndpointUri method.
import akka.camel.javaapi.UntypedProducerActor;
public class Producer1 extends UntypedProducerActor {
public String getEndpointUri() {
return "http://localhost:8080/news";
}
}
Producer1 inherits a default implementation of the onReceive method from the UntypedProducerActor class. To customize a producer actor's default behavior you must override the UntypedProducerActor.onTransformResponse and UntypedProducerActor.onTransformOutgoingMessage methods. This is explained later in more detail. Producer Actors cannot override the UntypedProducerActor.onReceive method.
Any message sent to a Producer actor will be sent to the associated Camel endpoint, in the above example to http://localhost:8080/news. The UntypedProducerActor always sends messages asynchronously. Response messages (if supported by the configured endpoint) will, by default, be returned to the original sender. The following example uses the ask pattern to send a message to a Producer actor and waits for a response.
ActorSystem system = ActorSystem.create("some-system");
Props props = Props.create(FirstProducer.class);
ActorRef producer = system.actorOf(props,"myproducer");
Future<Object> future = Patterns.ask(producer, "some request", 1000);
The future contains the response CamelMessage, or an AkkaCamelException when an error occurred, which contains the headers of the response.
Custom Processing
Instead of replying to the initial sender, producer actors can implement custom response processing by overriding the onRouteResponse method. In the following example, the response message is forwarded to a target actor instead of being replied to the original sender.
import akka.actor.UntypedActor;
import akka.camel.CamelMessage;
public class ResponseReceiver extends UntypedActor{
public void onReceive(Object message) {
if(message instanceof CamelMessage) {
// do something with the forwarded response
}
}
}
import akka.actor.ActorRef;
import akka.camel.javaapi.UntypedProducerActor;
public class Forwarder extends UntypedProducerActor {
private String uri;
private ActorRef target;
public Forwarder(String uri, ActorRef target) {
this.uri = uri;
this.target = target;
}
public String getEndpointUri() {
return uri;
}
@Override
public void onRouteResponse(Object message) {
target.forward(message, getContext());
}
}
ActorSystem system = ActorSystem.create("some-system");
Props receiverProps = Props.create(ResponseReceiver.class);
final ActorRef receiver = system.actorOf(receiverProps,"responseReceiver");
ActorRef forwardResponse = system.actorOf(Props.create(
Forwarder.class, "http://localhost:8080/news/akka", receiver));
// the Forwarder sends out a request to the web page and forwards the response to
// the ResponseReceiver
forwardResponse.tell("some request", ActorRef.noSender());
Before producing messages to endpoints, producer actors can pre-process them by overriding the UntypedProducerActor.onTransformOutgoingMessage method.
import akka.camel.CamelMessage;
import akka.camel.javaapi.UntypedProducerActor;
import akka.dispatch.Mapper;
import akka.japi.Function;
public class Transformer extends UntypedProducerActor{
private String uri;
public Transformer(String uri) {
this.uri = uri;
}
public String getEndpointUri() {
return uri;
}
private CamelMessage upperCase(CamelMessage msg) {
return msg.mapBody(new Mapper<String,String>() {
@Override
public String apply(String body) {
return body.toUpperCase();
}
});
}
@Override
public Object onTransformOutgoingMessage(Object message) {
if(message instanceof CamelMessage) {
CamelMessage camelMessage = (CamelMessage) message;
return upperCase(camelMessage);
} else {
return message;
}
}
}
Producer configuration options
The interaction of producer actors with Camel endpoints can be configured to be one-way or two-way (by initiating in-only or in-out message exchanges, respectively). By default, the producer initiates an in-out message exchange with the endpoint. For initiating an in-only exchange, producer actors have to override the isOneway method to return true.
import akka.camel.javaapi.UntypedProducerActor;
public class OnewaySender extends UntypedProducerActor{
private String uri;
public OnewaySender(String uri) {
this.uri = uri;
}
public String getEndpointUri() {
return uri;
}
@Override
public boolean isOneway() {
return true;
}
}
Message correlation
To correlate request with response messages, applications can set the Message.MessageExchangeId message header.
ActorSystem system = ActorSystem.create("some-system");
Props props = Props.create(Orders.class);
ActorRef producer = system.actorOf(props,"jmsproducer");
Map<String,Object> headers = new HashMap<String, Object>();
headers.put(CamelMessage.MessageExchangeId(),"123");
producer.tell(new CamelMessage("<order amount=\"100\" currency=\"PLN\" " +
"itemId=\"12345\"/>",headers), ActorRef.noSender());
ProducerTemplate
The UntypedProducerActor class is a very convenient way for actors to produce messages to Camel endpoints. Actors may also use a Camel ProducerTemplate for producing messages to endpoints.
import akka.actor.UntypedActor;
import akka.camel.Camel;
import akka.camel.CamelExtension;
import org.apache.camel.ProducerTemplate;
public class MyActor extends UntypedActor {
public void onReceive(Object message) {
Camel camel = CamelExtension.get(getContext().system());
ProducerTemplate template = camel.template();
template.sendBody("direct:news", message);
}
}
For initiating a two-way message exchange, one of the ProducerTemplate.request* methods must be used.
import akka.actor.UntypedActor;
import akka.camel.Camel;
import akka.camel.CamelExtension;
import org.apache.camel.ProducerTemplate;
public class RequestBodyActor extends UntypedActor {
public void onReceive(Object message) {
Camel camel = CamelExtension.get(getContext().system());
ProducerTemplate template = camel.template();
getSender().tell(template.requestBody("direct:news", message), getSelf());
}
}
Asynchronous routing
In-out message exchanges between endpoints and actors are designed to be asynchronous. This is the case for both, consumer and producer actors.
- A consumer endpoint sends request messages to its consumer actor using the tell method and the actor returns responses with getSender().tell once they are ready.
- A producer actor sends request messages to its endpoint using Camel's asynchronous routing engine. Asynchronous responses are wrapped and added to the producer actor's mailbox for later processing. By default, response messages are returned to the initial sender but this can be overridden by Producer implementations (see also description of the onRouteResponse method in Custom Processing).
However, asynchronous two-way message exchanges, without allocating a thread for the full duration of exchange, cannot be generically supported by Camel's asynchronous routing engine alone. This must be supported by the individual Camel components (from which endpoints are created) as well. They must be able to suspend any work started for request processing (thereby freeing threads to do other work) and resume processing when the response is ready. This is currently the case for a subset of components such as the Jetty component. All other Camel components can still be used, of course, but they will cause allocation of a thread for the duration of an in-out message exchange. There's also Examples that implements both, an asynchronous consumer and an asynchronous producer, with the jetty component.
If the used Camel component is blocking it might be necessary to use a separate dispatcher for the producer. The Camel processor is invoked by a child actor of the producer and the dispatcher can be defined in the deployment section of the configuration. For example, if your producer actor has path /user/integration/output the dispatcher of the child actor can be defined with:
akka.actor.deployment {
/integration/output/* {
dispatcher = my-dispatcher
}
}
Custom Camel routes
In all the examples so far, routes to consumer actors have been automatically constructed by akka-camel, when the actor was started. Although the default route construction templates, used by akka-camel internally, are sufficient for most use cases, some applications may require more specialized routes to actors. The akka-camel module provides two mechanisms for customizing routes to actors, which will be explained in this section. These are:
- Usage of Akka Camel components to access actors. Any Camel route can use these components to access Akka actors.
- Intercepting route construction to actors. This option gives you the ability to change routes that have already been added to Camel. Consumer actors have a hook into the route definition process which can be used to change the route.
Akka Camel components
Akka actors can be accessed from Camel routes using the actor Camel component. This component can be used to access any Akka actor (not only consumer actors) from Camel routes, as described in the following sections.
Access to actors
To access actors from custom Camel routes, the actor Camel component should be used. It fully supports Camel's asynchronous routing engine.
This component accepts the following endpoint URI format:
- [<actor-path>]?<options>
where <actor-path> is the ActorPath to the actor. The <options> are name-value pairs separated by & (i.e. name1=value1&name2=value2&...).
URI options
The following URI options are supported:
| Name | Type | Default | Description |
|---|---|---|---|
| replyTimeout | Duration | false | The reply timeout, specified in the same way that you use the duration in akka, for instance 10 seconds except that in the url it is handy to use a + between the amount and the unit, like for example 200+millis See also Consumer timeout. |
| autoAck | Boolean | true | If set to true, in-only message exchanges are auto-acknowledged when the message is added to the actor's mailbox. If set to false, actors must acknowledge the receipt of the message. See also Delivery acknowledgements. |
Here's an actor endpoint URI example containing an actor path:
akka://some-system/user/myconsumer?autoAck=false&replyTimeout=100+millis
In the following example, a custom route to an actor is created, using the actor's path.
import akka.actor.UntypedActor;
import akka.camel.CamelMessage;
import akka.dispatch.Mapper;
import akka.japi.Function;
public class Responder extends UntypedActor{
public void onReceive(Object message) {
if (message instanceof CamelMessage) {
CamelMessage camelMessage = (CamelMessage) message;
getSender().tell(createResponse(camelMessage), getSelf());
} else
unhandled(message);
}
private CamelMessage createResponse(CamelMessage msg) {
return msg.mapBody(new Mapper<String,String>() {
@Override
public String apply(String body) {
return String.format("received %s", body);
}
});
}
}
import akka.actor.ActorRef;
import akka.camel.internal.component.CamelPath;
import org.apache.camel.builder.RouteBuilder;
public class CustomRouteBuilder extends RouteBuilder{
private String uri;
public CustomRouteBuilder(ActorRef responder) {
uri = CamelPath.toUri(responder);
}
public void configure() throws Exception {
from("jetty:http://localhost:8877/camel/custom").to(uri);
}
}
ActorSystem system = ActorSystem.create("some-system");
try {
Camel camel = CamelExtension.get(system);
ActorRef responder = system.actorOf(Props.create(Responder.class), "TestResponder");
camel.context().addRoutes(new CustomRouteBuilder(responder));
The CamelPath.toCamelUri converts the ActorRef to the Camel actor component URI format which points to the actor endpoint as described above. When a message is received on the jetty endpoint, it is routed to the Responder actor, which in return replies back to the client of the HTTP request.
Intercepting route construction
The previous section, Akka Camel components, explained how to setup a route to an actor manually. It was the application's responsibility to define the route and add it to the current CamelContext. This section explains a more convenient way to define custom routes: akka-camel is still setting up the routes to consumer actors (and adds these routes to the current CamelContext) but applications can define extensions to these routes. Extensions can be defined with Camel's Java DSL or Scala DSL. For example, an extension could be a custom error handler that redelivers messages from an endpoint to an actor's bounded mailbox when the mailbox was full.
The following examples demonstrate how to extend a route to a consumer actor for handling exceptions thrown by that actor.
import akka.actor.Status;
import akka.camel.CamelMessage;
import akka.camel.javaapi.UntypedConsumerActor;
import akka.dispatch.Mapper;
import org.apache.camel.builder.Builder;
import org.apache.camel.model.ProcessorDefinition;
import org.apache.camel.model.RouteDefinition;
import scala.Option;
public class ErrorThrowingConsumer extends UntypedConsumerActor{
private String uri;
private static Mapper<RouteDefinition, ProcessorDefinition<?>> mapper =
new Mapper<RouteDefinition, ProcessorDefinition<?>>() {
public ProcessorDefinition<?> apply(RouteDefinition rd) {
// Catch any exception and handle it by returning the exception message
// as response
return rd.onException(Exception.class).handled(true).
transform(Builder.exceptionMessage()).end();
}
};
public ErrorThrowingConsumer(String uri){
this.uri = uri;
}
public String getEndpointUri() {
return uri;
}
public void onReceive(Object message) throws Exception{
if (message instanceof CamelMessage) {
CamelMessage camelMessage = (CamelMessage) message;
String body = camelMessage.getBodyAs(String.class, getCamelContext());
throw new Exception(String.format("error: %s",body));
} else
unhandled(message);
}
@Override
public Mapper<RouteDefinition,
ProcessorDefinition<?>> getRouteDefinitionHandler() {
return mapper;
}
@Override
public void preRestart(Throwable reason, Option<Object> message) {
getSender().tell(new Status.Failure(reason), getSelf());
}
}
The above ErrorThrowingConsumer sends the Failure back to the sender in preRestart because the Exception that is thrown in the actor would otherwise just crash the actor, by default the actor would be restarted, and the response would never reach the client of the Consumer.
The akka-camel module creates a RouteDefinition instance by calling from(endpointUri) on a Camel RouteBuilder (where endpointUri is the endpoint URI of the consumer actor) and passes that instance as argument to the route definition handler *). The route definition handler then extends the route and returns a ProcessorDefinition (in the above example, the ProcessorDefinition returned by the end method. See the org.apache.camel.model package for details). After executing the route definition handler, akka-camel finally calls a to(targetActorUri) on the returned ProcessorDefinition to complete the route to the consumer actor (where targetActorUri is the actor component URI as described in Access to actors). If the actor cannot be found, a ActorNotRegisteredException is thrown.
*) Before passing the RouteDefinition instance to the route definition handler, akka-camel may make some further modifications to it.
Examples
The Lightbend Activator tutorial named Akka Camel Samples with Java contains 3 samples:
- Asynchronous routing and transformation - This example demonstrates how to implement consumer and producer actors that support Asynchronous routing with their Camel endpoints.
- Custom Camel route - Demonstrates the combined usage of a Producer and a Consumer actor as well as the inclusion of a custom Camel route.
- Quartz Scheduler Example - Showing how simple is to implement a cron-style scheduler by using the Camel Quartz component
Configuration
There are several configuration properties for the Camel module, please refer to the reference configuration.
Additional Resources
For an introduction to akka-camel 2, see also the Peter Gabryanczyk's talk Migrating akka-camel module to Akka 2.x.
For an introduction to akka-camel 1, see also the Appendix E - Akka and Camel (pdf) of the book Camel in Action.
Other, more advanced external articles (for version 1) are:
Contents


:: GRADUATE QUICK SEARCH
::
Minimum length of characters for searching is 5.
1.
Student ID :
or
2.
Identity Card No :
or
3.
Name
:
Search
This information is accurate for graduate from 2003 onward. For more information please contact
Bahagian Rekod Pelajar dan Konvokesyen UiTM
Search Result
( top 20 records only )
Show
10
25
50
100
entries
Search:
No
NAME
PROGRAMME
SEMESTER GRADUATE
CONVOCATION
1
AZMAN ALI M. HABIB RAHMAN
MASTER OF SCIENCE IN THE SPECIALISMS OF THE BUILT ENVIRONMENT
Semester1 2010/2011
MAY 2011
Showing 1 to 1 of 1 entries
Previous
1
Next


Education & Training
Certifications
WeCan{Code}IT
2645 North High Street
Columbus, OH 43202
Full Stack Java
Software Developer
*** April 2018 ***
College of the Albemarle
1208 N Road St
Elizabeth City, NC 27909
Computer Engineering Technology
PC Technician
*** May 2013 ***
Online Learning
Team Treehouse
Team Treehouse is an online learning course that I take advantage of during my free time to gain some extra knowledge and broaden my views within the programming world.
Udemy
Udemy is like an online library with all sorts of resources waiting for you dig into and learn. I
discovered Udemy some time after my time on Team Treehouse and Udemy was so much more. The courses
are expensive but they go on sale a lot throughout the year. If a course I am interested is $100 one
day, it could be on sale for between $9.99 and $13.99 soon.
With Udemy, I can find multiple sources on a certain subject that I am wanting to learn and be
able to read reviews for that particular course and make a decision on whether or not it is worth
it. With Udemy, I find myself starting multiple new courses but primarily to get the information I
am needing to learn and moving on with my next task.
Books
Head First Java
Teaches the basics of Java and Object Oriented Programming.
Reading Status: Used in Class
Murach's Java Programming 5th Edition
An excellent training & reference book on Core Java, Object Oriented Programming (OOP), GUI Programming and Database Programming. Great source when learning to study Java via IDE or old school Notepad & Command Line.
Reading Status: Used As Reference
JavaScript: The Good Parts
Has words of wisdom to start off and then leads into a more in depth description of definitions and how to better understand JavaScript.
Reading Status: Used As Reference
PHP & MYSQL IN EASY STEPS
Picked up at a Local Library to see what PHP is all about.
Reading Status: Used As Reference (Library Book)


About DAppThis DApp is exactly what it sounds like it is, an app wher you can purchase tickets for the movies through the blockchain.Users can purchase movie tickets with cryptocurrency! |
About DAppThis DApp is exactly what it sounds like it is, an app wher you can purchase tickets for the movies through the blockchain.Users can purchase movie tickets with cryptocurrency! |


Juno <IP_ADDRESS> is a minor update.
Core API changes
- New
ObjectMap.findKeyIgnoreCase(String)method.
- HtmlSerializer will now create 2-dimensional tables for collections of mixed beans/maps if all object have the same set of property names/keys.
REST server API changes
- New RestServletProperties class that defines all the class-level properties that can be set on the servlet.
- Properties can be set through
@RestResource.propertiesannotation, or new RestServlet.setProperty(String,Object)method.
- New "?noTrace" URL parameter to prevent stack traces from being logged (for JUnit testing of error conditions).
- New RestServletProperties.REST_useStackTraceHashes property to prevent the same stack trace from being logged multiple times.
- New RestServletProperties.REST_renderResponseStackTraces property for preventing stack traces in responses for security reasons.
- New overridable RestServlet.onError(HttpServletRequest,HttpServletResponse,RestException,boolean) and
RestServlet.onSuccess(RestRequest,RestResponse,long)methods for plugging in your own logging and peformance monitoring.
- Eliminated RestServlet.getInitParams() method, since it's now redundant with
RestServlet.getProperties().
- Header parameters passed as URL parameters are now case-insensitive.


Architecture Pictures
general architecture
sender architecture
both recipient architecture
sender-recipient-keyserver architecture
user display architecture
API Network Diagrams


Bill Gates and Elizabeth Warren are tweeting at each other about wealth inequality
Maybe they’ll have a beer summit?
by Jay PetersBill Gates and Elizabeth Warren are tweeting at each other — and it seems possible they could have an IRL conversation soon.
But let’s first back up to why they’re @-ing each other. Yesterday, the Microsoft co-founder was interviewed at The New York Times’ DealBook Conference. The very first thing CNBC host Andrew Ross Sorkin asked Gates was his position on Warren’s proposed 6 percent wealth tax on billionaires, which is designed to help pay for Medicare for All.
As part of his response, he discusses how a wealth tax could affect him, and if he’s ever met with Elizabeth Warren:
His comment about paying over $10 billion in taxes can only be described as a tax flex (he seemed to be joking, but maybe not really). And he didn’t seem confident that Warren would want to sit down with him.
Here’s a video of his comments, with the tweeted quotes coming in just after the six-minute mark:
Well, last night Elizabeth Warren tweeted to say that, actually, she’d be happy to discuss her wealth tax further with Gates:
And this morning, Gates tweeted back — though he doesn’t exactly agree to meet up. But he at least sounds interested in having some kind of conversation with Warren to discuss how to fight wealth inequality:
So, it doesn’t seem as if the Elizabeth Warren Bill Gates Wealth Inequality Beer Summit Extravaganza will be happening imminently — but perhaps the two will talk soon. Since they’re already chatting on Twitter, maybe they’ll just keep tweeting back and forth, because that’s a thing a Democratic candidate and one of the richest men in the world will do in 2019.
Update November 7th, 5:54PM ET: Linked to a different video of Bill Gates’ comments, as the one we originally linked to was made private.


Preparation time
less than 30 mins
Cooking time
1 to 2 hours
Serves
Serves 4
Dietary
For the meringue nests, preheat the oven to 150C/300F/Gas 2 and line a baking tray with non-stick greaseproof paper.
Place the egg whites in a mixing bowl and whisk until they form soft peaks when the whisk is removed.
Add the caster sugar, a spoonful at a time, constantly whisking. When the sugar is absorbed, the meringue should look shiny, glossy and stiff.
Using a tablespoon, spoon the mixture onto non-stick baking tray to make little mounds. Place in the oven and bake for 15 minutes.
Lower the oven temperature to 110C/225F/Gas ¼ and cook for a further 1-1½ hours until crisp on the outside and gooey in the middle. Leave to cool.
For the fruit, place the cherries in a pan with the orange juice, redcurrant jelly, pomegranate molasses and soft brown sugar, and simmer for a few minutes. Add the dessert wine.
When the cherries are soft remove them from the pan with a slotted spoon, set them aside and keep warm.
Simmer the sauce until it has reduced to a consistency to lightly coat the back of a spoon. Place the cherries back in the sauce, set aside and keep warm.
For the butterscotch sauce, melt the butter in a pan.
When the butter has melted, add the soft brown sugar. Stir until the sugar has dissolved.
When the sugar has been absorbed into the butter, add the double cream and vanilla. Bring to the boil and beat vigorously. Keep the sauce warm until you are ready to serve.
To serve, decorate the meringue nests with the cream, cherries and butterscotch sauce.


---
layout: post
type: post
comments: true
title: SOMETIMES IN LIFE
sub-title: You should just buy a one way ticket and enjoy the ride.
category: Storytime
tags: [new-experiences, short movie]
location: Pattaya | Thailand
date: January 11 2017
thumbnail: https://img.youtube.com/vi/2-TaDuvss44/0.jpg
link: https://youtu.be/2-TaDuvss44
share: https://youtu.be/2-TaDuvss44
---
This is our very first short story we created. It's the start of our journey, where we've left the Netherlands (our home country). Our first stop is Thailand. In Thailand, we start exploring with film making, editing and doing creative work abroad. We explore countries and peoples stories involving culture & arts, food & drinks and entrepreneurship.
Let us know what you think about our first movie in the comments below.


Trump says he will strongly consider testifying in impeachment hearing
U.S. President tweets he may go through with it in order to get Congress focused again
by ReutersU.S. President Donald Trump on Monday said he might be willing to testify in the impeachment inquiry “even though I did nothing wrong,” although House Democrats leading the investigation have not publicly called him as a witness.
“Even though I did nothing wrong, and don’t like giving credibility to this No Due Process Hoax, I like the idea and will, in order to get Congress focused again, strongly consider it!” Trump tweeted.


Flappy Bird Genetic Algorithm - Learning How to Adjust Parameters
Scroll down, choose a framerate, enter values for the given fields, click submit and sit back.
Frame Rate:
x1
x2
x3
x5
MAX
Population:
Mutation Rate:
Elitism:
Number of Children:
Number of Hidden Layers:
Crossover Rate:
Submit


com.jme3.input
package is used for all input handling in
jMonkeyEngine. User code should use the {@link com.jme3.input.InputManager} to register
for and receive input events. The InputManager
can be
retrieved for an application by using {@link com.jme3.app.Application#getInputManager()}.
Using ActionListener:
// Retrieve an input manager for the application "app"
InputManager inputManager = app.getInputManager();
// Adds a new mapping "PrintHello" that will be invoked when the Return/Enter key is pressed
inputManager.addMapping("PrintHello", new KeyTrigger(KeyInput.KEY_RETURN));
// Adds a new ActionListener to get an event when enter is pressed.
inputManager.addListener(new ActionListener() {
public void onAction(String name, boolean isPressed, float tpf) {
// Only invoke the event when the mapping is "PrintHello"
// and isPressed is true, meaning it was a key press and not release.
if (name.equals("PrintHello") && isPressed){
System.out.println("Hello!");
}
}
}, "PrintHello");


Volunteers from all over the world are contributing to eliminating Malaria by mapping buildings of the people in need. Start mapping!
Over 1.5 million buildings have been mapped as part of the Malaria elimination campaign since 2016.


From the dawn of time we came, moving silently among you, down through the centuries...Immortals. Living many secret lives, struggling to reach the time of the Final Gathering, when the few who remain will battle to the last. No one has ever known we were among you...Until now.


---
layout: page
title: "Contact"
description: "Why hello there."
header-img: "img/sunrise-bg.jpg"
---
Want to get in touch with me? Try one of the following methods, and I'll get back to you as soon as I can.
- Twitter: A good way to make an introduction.
- Facebook: Friends and family mostly.
- LinkedIn: Professional relationships can be found here.
- GitHub: I'm not a coder by nature, but I work on a couple things here (including this site).


Wherever Life Takes You — Stay Connected
Shop Now
Commercial
Home
Auto
RV
Learn More
Enterprise
Office
School
Hospital
Learn More


Event manager pro
Log out
Dashboard
Create events
Events
Create events
Page 2
Page 3
Portfolio
FAQ
Contact
Create event
Create your upcoming event in few simple steps.
Manage events
Create your upcoming event in few simple steps.
Edit profile
Create your upcoming event in few simple steps.
Event Name
Event Category
Select category here..
Corporate
Private
Social
Event type
Select type here..
Wedding
Haldi
Reception
Birthday
Engagement
Event city
Event location
Select location here..
Mohammadpur
Haldi
Reception
Birthday
Engagement
Event budget
Event date
I agree that I have read and accepted the
Terms of use
Hi test


--- title: "Info!" date: 2016-11-11 20:55:23 categories: [jekyll] tags: [jekyll] layout: default ---
I use Shareville alot for following trends an debate strategies and stock, below I have list the most wieghted stock in my 4 prefered groups


About the algorithm:
Huffman coding is a lossless data compression algorithm. In this algorithm, a variable-length code is assigned to input different characters. The code length is related to how frequently characters are used. Most frequent characters have the smallest codes and longer codes for least frequent characters.
There are mainly two parts:
First one to create a Huffman tree, and another one to traverse the tree to find codes.
For an example, consider some strings “YYYZXXYYX”, the frequency of character Y is larger than X and the character Z has the least frequency. So the length of the code for Y is smaller than X, and code for X will be smaller than Z.


|
Class Summary |
| BasicAnnotationOrthography |
|
| MatchRule0 |
RULE #0: If the two names are listed in table of
spurius matches then they do NOT match
Condition(s): -
Applied to: all name annotations |
| MatchRule1 |
RULE #1: If the two names are identical then they are the same
no longer used, because I do the check for same string via the
hash table of previous annotations
Condition(s): depend on case
Applied to: annotations other than names |
| MatchRule10 |
RULE #10: is one name the reverse of the other
reversing around prepositions only? |
| MatchRule11 |
RULE #11: does one name consist of contractions
of the first two tokens of the other name? |
| MatchRule12 |
RULE #12: do the first and last tokens of one name
match the first and last tokens of the other? |
| MatchRule13 |
RULE #12: do the first and last tokens of one name
match the first and last tokens of the other? |
| MatchRule14 |
RULE #13: do multi-word names match except for
one token e.g. |
| MatchRule15 |
RULE #14: if the last token of one name
matches the second name
e.g. |
| MatchRule16 |
RULE #15: Does every token in the shorter name appear in the longer name? |
| MatchRule17 |
RULE #16: Conservative match rule
Require every token in one name to match the other except for tokens that are on a stop word list |
| MatchRule2 |
RULE #2: if the two names are listed as equivalent in the
lookup table (alias) then they match
Condition(s): -
Applied to: all name annotations |
| MatchRule3 |
RULE #3: adding a possessive at the end
of one name causes a match
e.g. |
| MatchRule4 |
RULE #4: Does the first non-punctuation token from the long string match
the first token from the short string? |
| MatchRule5 |
RULE #4Name: Does all the non-punctuation tokens from the long string match the corresponding tokens
in the short string? |
| MatchRule6 |
RULE #5: if the 1st token of one name
matches the second name
e.g. |
| MatchRule7 |
RULE #6: if one name is the acronym of the other
e.g. |
| MatchRule8 |
RULE #7: if one of the tokens in one of the
names is in the list of separators eg. "&"
then check if the token before the separator
matches the other name
e.g. |
| MatchRule9 |
RULE #9: does one of the names match the token
just before a trailing company designator
in the other name? |
| OrthoMatcher |
|
| OrthoMatcherHelper |
|


--- layout: page description: "" background: "img/yoda_home.jpg" ---
|
Hello! I'm Iryna, or Ira for short. I am a Research Engineer at DeepMind. I did my PhD at Ghent University, half of which I spent as a visitor at the Gatsby Unit, UCL supervised by Arthur Gretton. If you're interested in the BRUNO family of generative exchangeable meta-learning models, my thesis is here. During my PhD, I won a couple of Kaggle competitions with friends from Ghent, interned at Twitter, DeepMind, and Facebook, and wrote a bunch of papers. Apart from research, I'm into woodworking, playing cello, yacht sailing, and cold water swimming. |