| lv. | When you grow to that level, spend points here. | ||
| Rohane | Mipsy | Talinia | |
| 21 | Innate Melee Haste | Innate Casting Haste | |
| 22 | Damage Increase | Direct Damage | |
| 23 | Stunning Strikes | Innate Casting Haste | |
| 24 | Stunning Strikes | Direct Damage | |
| 25 | Stunning Strikes | Innate Casting Haste | Shockwave |
| 26 | Critical Attacks | Direct Damage | Innate Melee Haste |
| 27 | Critical Attacks | Direct Damage | Shockwave |
| 28 | Stunning Strikes | Innate Casting Haste | Shockwave |
| 29 | Critical Attacks | Innate Melee Defense | Shockwave |
| 30 | Critical Attacks | Innate Casting Haste | Innate Melee Haste |
| 31 | Stunning Strikes | Innate Melee Defense | Shockwave |
| 32 | Stunning Strikes | Innate Casting Haste | Increased Bow Damage |
Hey, you're back. You've finished the Act 1, Part 2 guide by now, right? (Cause if you haven't, go ahead and follow that link. I won't tell anyone.) If you have finished Act 1, bookmark this page or whatever you want since you'll be coming back here from now on. Well, at least until you finish the act.
Have I ever told you you're nearly pro? Yeah, you're getting closer to beating up that fat dragon at the end of the game... you're a third of the way there. But this act is gonna fly by like that. *pig flies by*
Well, what are you waiting for? We've got more lupes/fat stuff to beat up... so let's get to it!
Smell that mountain air? Refreshing. And cold. So equip the stuff Ramtor gave you if you haven't already.  Shoulda learned Esperanto.
At any rate, switch to Hunting mode and go west a bit from town. Start training here until you're level 21/22/23. (While I'm at it, I'd like to reintroduce you to our old buddy the skills table. He hasn't changed much, but he's had to go on a diet. I trust you'll get along.) The baddies here hit pretty hard, so don't be afraid to use healing potions if you need to. The area around that town is a no-encounter zone (remember that grassy patch south of Phorofor? Yeah, just like that) so you can grab some free HP there using the Walk-Heal method. Just walk around to gain HP.
Once you've leveled up, open your map site again. Go to the maps and click on Act 2 or Terror Mountain. Whoa! That shows all the maps for this act. You can bookmark this page if you like, but just know you'll need to come here each time you look for maps. Open up the Southern Pass map. You're in the southwest corner. See the Dirty, Smelly Cave a little to your east? Go there and enter it.
Once you've entered, switch to Normal mode and go southeast. After a bit you'll see some winged dude with glasses on. If you beat him, you can talk to the Chias in that town back there. Besides, he looks kinda annoying... so heal up and then attack him.
| Recommended Level: | 21 on Normal 22 on Evil 23 on Insane |
| HP: | 150 on Normal 187 on Evil 220 on Insane |
| Special Abilities: | Stunning Strikes Very magic-resistant |
| Prizes: | the Wordstone (lets you talk to those Chias) 2 Potions of Regeneration 1 weapon/armor 200 gold 500 NP |
Keep hacking away and the Nimmo with specs will die, though you might burn a lot of potions in the process. Once he's dead, exit the cave and walk back to that town we saw earlier (it's just west from the cave.) Good news, you can finally talk to the Chias there. *woohoo*
It's Chia time! Once you enter town, open up your map of it. (I think that goes without saying from now on.) Look for Jarasth, the green guy in the north building. He sells weapons, armor, AND potions. Pretty nifty, huh? Well, sorry, we won't be buying any weapons/armor here (they're more or less the same as the ones from Seaside.) And we don't need to buy any potions here, since there's another town before the next boss. Just sell your old weapons/armor to him. Poor guy.
Glance at your map again. See Ullistl in the northwestern house? Yeah, talk to him and he'll let you rest for free. So keep that in mind. You can talk to the Chia dudes here if you like, but we have to leave town for now.
Now that we have a free inn, we can start fighting carelessly and hoard potions. Walk a little west from town and train to level 22/23/24. If you're hurt, run back to the inn. Don't use potions unless someone's about to die.
Once you level up, you can start moving away from town. Open up your map to Southern Pass and look for the cave at the eastern end of the pass. That's where we need to go, and we need to gain 1 level on the way. Walk there using that Fight-As-You-Go method (remember? Just stay on Hunting mode and walk, beating up any baddies you run into.) If you're hurt, use Healing Bottles or Potions of Regeneration. If you reach the cave before you level up, train just outside the cave until you're level 23/24/25.
Once you're ready, you can enter the Caves of Terror (you start in the south.) If you've already opened up your map to that page, good for you. If you haven't... *hits you with fish* Now that that's done, we need to train here until we're at level 24/25/26. The baddies here are tough, so don't hesitate to use healing potions. Once you've leveled up, switch to Normal mode and make your way through the cave. Run away from any baddies you run into, because they're even tougher than the ones at the start of the cave.
Once you get out of the cave, you'll be on Eastern Pass, Sector 1. Walk north a bit and you'll see a gingerbread house inn. Civilization that's not Chias! YEAH! Enter the building.
Once you enter the inn, walk a bit south from the entrance until you see... what? Talinia?! Neato. Ask her to join you, and she will. Congrats! You've just added a good chunk of coolness factor to your squad (cause, let's face it, an arrogant Blumaroo and a violent Acara aren't the coolest guys in the world.) Before you start stunning monsters with your new coolness, we need to spend Talinia's skill points first. Cue the table.
No, the OTHER table. Geez, they don't pay me enough for this job.
| On this difficulty... | Spend Talinia's skill points here. |
| Normal | 9 points in Increased Bow Damage 6 points in Multiple Targets 3 points in Shockwave 5 points in Innate Melee Haste |
| Evil | 9 points in Increased Bow Damage 6 points in Multiple Targets 4 points in Shockwave 5 points in Innate Melee Haste |
| Insane | 9 points in Increased Bow Damage 6 points in Multiple Targets 4 points in Shockwave 6 points in Innate Melee Haste |
You've done this before, right? Spend Talinia's skill points according to which difficulty you're on. Now that that's done, talk to the Tuskaninny in the middle of the room if you want to rest.  Now talk to Borhal, the guy in the southeast corner of the building.
Grab 20 Frost Potions and about 10 Chill Potions. If you're low on slowing potions, grab some of those. The Drowsiness Potions are more or less the same as the potions from Seaside. That's all we need to do here. Everyone else in the inn is comic relief, if you're into that sort of thing. Leave the inn when you're done.
Good news! Now we can test-drive Talinia (try saying that 5 times fast.) Fighting with Talinia isn't too different from what you've been doing up till now.  Practice fighting with Talinia a bit... hang around the inn so you can heal if you get hurt.
Once that's done, we need to get moving. We're going to use the Fight-As-You-Go method to gain a level before the next boss. Walk northish from where you are and open up your map to Eastern Pass - Sector 2. You need to walk over all the way west (oh yeah, remember the Walk-Heal method? Just walk around a bit on Normal after each battle to regain HP. Use this while you're walking.)
Once you level up to level 25/26/27, switch to Normal mode and walk on over to Kolvars, the crabby spidery thingy. Well, I guess it doesn't really matter what he is. But still.
| Recommended Level: | 25 on Normal 26 on Evil 27 on Insane |
| HP: | 225 on Normal 281 on Evil 337 on Insane |
| Special Abilities: |
Quick Feet - 28% Haste Dormancy - 44% Slow Critical Attacks |
| Prizes: |
2 Potions of Fortitude 2 weapons/armor 300 gold 600 NP |
Once you've sent Kolvars to that big snowdrift in the sky, make sure you equipped the stuff he dropped and walk south from where he stood and you'll see the town of Happy Valley. Don't enter yet, though... walk around so that you're directly south of town. Then, walk north into town. You'll see why soon.
Fun fact: Happy Valley is the biggest town in NQII, at least people-wise.
In other news, you've just entered town from the south. Open up your map to the page for this town. See Jualie in the south-central part of town? Walk north to get to her house, and then enter it. The door faces east, so you might need to walk around a bit to get to the entrance. Talk to her, and she'll tell you that her kid fled the tyranny of his home got lost. You to the rescue!
Look in the southwest corner of your map. Niacha, the lost kid I just told you about, is the one you need to talk to. Go south to leave town, then once you've left town take one step west. Then go northeast. This'll put you just a few steps away from Niacha (if you haven't noticed already, the direction you enter town from determines where you start off.) Talk to him and he'll run back to his mom.
Go southwest to leave town, then re-enter town from the south. Now go back to Jualie (working up a sweat yet? Interestingly, sweating in the cold is a bad thing since the sweat freezes... I can tell you're not interested so I'll stop.)  You're now on Main Street, so to speak... this is a big city, after all. Head north till you see some signs for the potion/weapon/armor shop and the inn. Here's a new addition: the Shopping List. Everything you'll need to buy is right there. Get shopping.
Once you've finished buying everything, sell your old weapons and such. You can then leave town.
Once you leave town, switch to Hunting mode and start walking. You guessed it, we're going to use that Fight-As-You-Go method. Walk southeast-ish until the road forks to your east. At that point, open up your map to Eastern Pass: Sector 4. It doesn't matter which path you take as long as you get to the Adventurers' Camp (the tent thingy in the northeast corner of the map.)
By the time you get to that camp I just mentioned, make sure you're at least at level 26/27/28. The area around the camp is a no-encounter zone (remember the no-encounter zone around Chia Oscuro?) so you might need to walk south a bit to train.
At any rate, walk onto the tent when you get to it. Turns out it's actually 4 tents. Why must you lie to us, NQII?!? Oh well. The dude holding a mace is a free inn, and you know what that means. Head north from the camp until you see a cave entrance. Well, don't enter yet. Train outside the mouth of the cave until you're level 27/28/29. Run back to the camp if you need to rest.
Once you've gained that level, you can enter the cave. Like we haven't been through enough caves already.
But don't go too far. We have to gain another level at the mouth of the cave. Beat up the dudes at the mouth of the cave until you're level 27/28/29. If you're badly hurt, run back to the camp, but otherwise you can use potions. Just don't use them all in one place, y'hear.
Now that that's done, we're going to get through the rest of the cave while using the Fight-As-You-Go method. Open up your map to Lost Caves: Level 1. You have to get from the southeast corner to the stairs in that building in the northwest. Try to get to level 28/29/30 before you climb those stairs. If you're not there yet, train a bit.
Now you're on Level 2. Train here till you're level 29/30/31 (oh come on, it's not THAT bad. Remember the cave before Zombom?) Once that's done, switch to Normal mode and make your way through the rest of this level. Level 3 is an absolute joke... you'll see when you see the map. Just walk through it.
You're now on Level 4. We're going to use the - you guessed it - Fight-As-You-Go method through this last level. If you're not at level 30/31/32 by the time you're at the mouth of the cave, train till you're at that level. You know what to do.
Switch to Normal mode the minute you get onto the mountaintop (leave the cave.) Why?  You don't want to waste your time and potions fighting them, do ya? Didn't think so. I don't think you'll need a map to find Scuzzy, your next boss. Just heal up and pick a fight with the big hairy primate.
| Recommended Level: | 30 on Normal 31 on Evil 32 on Insane |
| HP: | 400 on Normal 500 on Evil 600 on Insane |
| Special Abilities: | Cyclone - 36HP Group Damage Indifference - 32% Slow Very ugly |
| Prizes: |
3 weapons/armor 1000 gold 1000 NP |
Keep slugging away and Scuzzy will go bye-bye. Speaking of which, you can now say bye to this page. Now that you're done Act 2, you should start visiting DiabolicalChia's page for Act 3 stuff. I'll see you back here on the next difficulty. Don't get eaten till then, y'hear.


Hi
I'm looking for a mountable CT.
The SCT-013-000 works great, but the clamp-on design isn't ideal when it comes to keeping the fuse cabinet tidy.
I'm wondering if anyone knows of some good alternatives for (DIN) mountable CT's?
Been looking at this one:
TA1610P/TA1610FP (http://www.yhdc.com/english/productshow.asp?id=158)
Seems like it's similar to the SCT-013-0xx (Vout)
Will this work? Any thoughts?
Re: Mountable CT
Depending on the laws where you live, that one might require a certified/registered electrician, and thus be very costly to fit (depending of course on which wire(s) you will be fitting it). Other than that, it looks as if it should be usable. You should get 1 V rms at 80 A with the recommended 10 Ohm burden, which is fractionally low for an emonTx but certainly usable (and higher than you get with the standard 100 A split-core one at the same current with its 18 Ohm burden).
Bear in mind that as it has a steel core, not ferrite, you MUST make sure you never operate it without a burden, otherwise - besides the danger of a flash-over - you will need to demagnetise it to restore its performance.
Re: Mountable CT
Depending on the laws where you live, that one might require a certified/registered electrician.
I'm resident in Norway, so the above mentioned rules does apply. (But that's not a problem)
Bear in mind that as it has a steel core, not ferrite, you MUST make sure you never operate it without a burden
Thanks for pointing that out, I failed to see that myself!
Is it enough with an appropriate resistor between S1-S2 as a safety/fallback burden?
Might this be a better choice?
T22-100 (http://www.yhdc.com/english/productshow.asp?id=202)
Re: Mountable CT
Obviously the TA22-100 is somewhat larger and has a higher VA rating because it can develop more voltage, so you would have a wider choice of burden resistor - any value up to 50 Ohms - to give you the output you require at the current you want to measure. I'm sorry if that sounds nebulous but I don't know what your maximum current is nor anything about the input you are feeding into.
If there is any risk of detaching the burden resistor, then it is best moved and soldered directly across the terminals, alternatively (or as well) you could put a pair of zener diodes at the c.t. terminals to clamp the voltage at a little above the maximum peak voltage that you expect. If you do move the burden to the c.t and connect with a plug (as in the emonTx), then you could replace the 18 Ohm resistor on the pcb with a high valued one (say 18 KOhms) which would make no measurable difference to the calibration but would leave the analogue input biassed correctly if the c.t. were to be unplugged.
Re: Mountable CT
Thanks for your help so far. I've ordered one of each for further testing/tinkering.
I'm sorry if that sounds nebulous
Not at all. It's a general answer to a general question ;)
I don't know what your maximum current is nor anything about the input you are feeding into.
Probably maybe possibly the wrong forum thread to elaborate on that one, but in the absence of a "My Project" thread, here goes:
I'm in the process of renovating my house, including the electrical wiring. I'm also changing my fuse box. I was lucky enough to get a couple of these ones for free: "Schneider Prisma plus G" (floor standing type)
This gave me loads of free space to play with.
There will be some 16-20 circuits, and I intend to monitor each one separately + incoming supply, delivering fine grained data to my home automation system. To do this, I'll need to make a custom shield to accommodate all the CT's.
The circuits will be 16A@230V with the exeption of a couple of 25A ones. Intake breaker is 63A
Re: Mountable CT
Don't worry about this thread being inappropriate.
Now, I have a better picture of what you are doing. Because you are starting from new, I would certainly suggest you get lower rated c.t's for the outgoing circuits. The Atmel processor ADC is 10 bits wide, which basically means it can measure with reasonable accuracy down to 1% of full scale (10 counts peak-peak). So an 80 or 100 A c.t. is not the best choice for a 16 A circuit! (Though OK for the incomer).
You need to think about the input voltage you need and the voltage that your ADC will run at. If you have a 5 V supply and use 5 V for the ADC reference, then for maximum resolution you need 5 V p-p at max current (16 A). The problem here is small c.t's have small VA ratings and distort the wave shape when they saturate, which happens if you increase the resistance of the burden to get more voltage. You can run at 3.3 V like the emonTx, or run the ADC reference at 1.1 V like Atmel's application note AVR465: Single-Phase Power/Energy Meter with Tamper Detection. You will have a wider choice of c.t. if you have a 1.1 V p-p input, because there are many cheap c.t's designed to give a voltage output of 0.33 V rms. And of course you do not need split-core c.t's, so there is yet more choice.
If you design your own shield, you must take great care to separate the analogue and digital circuits. There is some evidence that people who have used prototype pcb's read powers of up to about 50 W when no current is flowing, due to noise pickup.


All Classes
-
All Classes Interface Summary Class Summary Exception Summary Annotation Types Summary Class Description AbstractAuditingEntity Base abstract class for entities which will hold definitions for created, last modified, created by, last modified by attributes.AccountResource REST controller for managing the current user's account.AccountResourceIT Integration tests for theAccountResource
REST controller.ApplicationProperties Properties specific to Manager.ApplicationWebXml This is a helper Java class that provides an alternative to creating aweb.xml
.AsyncConfiguration AuditEventConverter AuditEventService Service for managing audit events.AuditEventServiceIT Integration tests forAuditEventService
.AuditResource REST controller for getting theAuditEvent
s.AuditResourceIT Integration tests for theAuditResource
REST controller.AuthoritiesConstants Constants for Spring Security authorities.Authority An authority (a security role) used by Spring Security.AuthorityRepository Spring Data MongoDB repository for theAuthority
entity.BadRequestAlertException ClientForwardController ClientForwardControllerTest Unit tests for theClientForwardController
REST controller.ClientForwardControllerTest.TestController CloudDatabaseConfiguration Constants Application constants.CustomAuditEventRepository An implementation of Spring Boot'sAuditEventRepository
.CustomAuditEventRepositoryIT Integration tests forCustomAuditEventRepository
.DatabaseConfiguration DateTimeFormatConfiguration Configure the converters to use the ISO format for dates by default.DomainUserDetailsService Authenticate a user from the database.DomainUserDetailsServiceIT Integrations tests forDomainUserDetailsService
.EmailAlreadyUsedException EmailAlreadyUsedException ErrorConstants ExceptionTranslator Controller advice to translate the server side exceptions to client-friendly json structures.ExceptionTranslatorIT Integration testsExceptionTranslator
controller advice.ExceptionTranslatorTestController ExceptionTranslatorTestController.TestDTO ExceptionTranslatorTestController.TestResponseStatusException FieldErrorVM InitialSetupMigration Creates the initial database setup.InvalidPasswordException InvalidPasswordException Item A Item.ItemRepository Spring Data MongoDB repository for the Item entity.ItemResource REST controller for managingItem
.ItemResourceIT Integration tests for theItemResource
REST controller.ItemTest JacksonConfiguration KafkaProperties KeyAndPasswordVM View Model object for storing the user's key and password.LocaleConfiguration LoggingAspect Aspect for logging execution of service and repository Spring components.LoggingAspectConfiguration LoggingConfiguration LoginAlreadyUsedException MailService Service for sending emails.MailServiceIT Integration tests forMailService
.ManagedUserVM View Model extending the UserDTO, which is meant to be used in the user management UI.ManagerApp ManagerKafkaResource NoOpMailConfiguration PasswordChangeDTO A DTO representing a password change required data - current and new password.PersistenceAuditEventRepository Spring Data MongoDB repository for thePersistentAuditEvent
entity.PersistentAuditEvent Persist AuditEvent managed by the Spring Boot actuator.PersistentToken Persistent tokens are used by Spring Security to automatically log in users.PersistentTokenRememberMeServices Custom implementation of Spring Security's RememberMeServices.PersistentTokenRepository Spring Data MongoDB repository for thePersistentToken
entity.SecurityConfiguration SecurityUtils Utility class for Spring Security.SecurityUtilsUnitTest Test class for theSecurityUtils
utility class.SpringSecurityAuditorAware Implementation ofAuditorAware
based on Spring Security.StaticResourcesWebConfiguration StaticResourcesWebConfigurerTest TestUtil Utility class for testing REST controllers.TestUtil.ZonedDateTimeMatcher A matcher that tests that the examined string represents the same instant as the reference datetime.User A user.UserDTO A DTO representing a user, with his authorities.UserMapper UserMapperTest Unit tests forUserMapper
.UsernameAlreadyUsedException UserNotActivatedException This exception is thrown in case of a not activated user trying to authenticate.UserRepository Spring Data MongoDB repository for theUser
entity.UserResource REST controller for managing users.UserResourceIT Integration tests for theUserResource
REST controller.UserService Service class for managing users.UserServiceIT Integration tests forUserService
.WebConfigurer Configuration of web application with Servlet 3.0 APIs.WebConfigurerTest Unit tests for theWebConfigurer
class.WebConfigurerTestController WithUnauthenticatedMockUser WithUnauthenticatedMockUser.Factory


Zend Framework
LICENSE
This source file is subject to the new BSD license that is bundled with this package in the file LICENSE.txt. It is also available through the world-wide-web at this URL: http://framework.zend.com/license/new-bsd If you did not receive a copy of the license and are unable to obtain it through the world-wide-web, please send an email to<EMAIL_ADDRESS>so we can send you a copy immediately.
Zend_Service_Delicious_Post represents a post of a user that can be edited
__construct(
\Zend_Service_Delicious $service, \DOMElement|array $values
)
:
void
Constructs a new del.icio.us post
| Name | Type | Description |
|---|---|---|
| $service | \Zend_Service_Delicious | Service that has downloaded the post |
| $values | \DOMElement|array | Post content |
| Exception | Description |
|---|---|
| \Zend_Service_Delicious_Exception |
getNotes(
)
:
string
Getter for notes
Inherited from: \Zend_Service_Delicious_SimplePost::getNotes()| Type | Description |
|---|---|
| string |
getOthers(
)
:
int
Getter for others
This property is only populated when posts are retrieved with getPosts() method. The getAllPosts() and getRecentPosts() methods will not populate this property.
| Type | Description |
|---|---|
| int |
getTags(
)
:
array
Getter for tags
Inherited from: \Zend_Service_Delicious_SimplePost::getTags()| Type | Description |
|---|---|
| array |
getTitle(
)
:
string
Getter for title
Inherited from: \Zend_Service_Delicious_SimplePost::getTitle()| Type | Description |
|---|---|
| string |
getUrl(
)
:
string
Getter for URL
Inherited from: \Zend_Service_Delicious_SimplePost::getUrl()| Type | Description |
|---|---|
| string |
setNotes(
string $newNotes
)
:
\Zend_Service_Delicious_Post
Setter for notes
| Name | Type | Description |
|---|---|---|
| $newNotes | string |
| Type | Description |
|---|---|
| \Zend_Service_Delicious_Post |
setShared(
bool $isShared
)
:
\Zend_Service_Delicious_Post
Setter for shared
| Name | Type | Description |
|---|---|---|
| $isShared | bool |
| Type | Description |
|---|---|
| \Zend_Service_Delicious_Post |
setTitle(
string $newTitle
)
:
\Zend_Service_Delicious_Post
Setter for title
| Name | Type | Description |
|---|---|---|
| $newTitle | string |
| Type | Description |
|---|---|
| \Zend_Service_Delicious_Post |


The maximum number of containers, based on this template, that this provider is allowed to run in total.
Note that containers which have not been created by Jenkins are not included in this total.
A negative value, or zero, or<PHONE_NUMBER> all mean "no limit" is imposed on the this template, although the overall cloud instance limit (if any) will still apply.
Deprecated you should configure template with memory/cpu constraints, so docker infrastructure can manage resource consumption.


The scheduler controls the execution of concurrent threads. Computation within a thread is organized into tasks. Each task corresponds to a stack frame pushed on the thread's task stack. Each stack frame carries a reference to its evaluator responsible for execution, with arbitrarily many evaluators supported. Computation is performed through this interface indirection.
The scheduler controls the execution of concurrent threads.
class Scheduler { public: static void SetNArgs(u_int n); static u_int GetNArgs(); static void SetCurrentArg(u_int n, word w); static word GetCurrentArg(u_int n); static void SetCurrentData(word w); static word GetCurrentData(void); static void SetCurrentBacktrace(Backtrace *b); static Backtrace *GetCurrentBacktrace(void); static void SetCurrentTaskStack(TaskStack *t); static TaskStack *GetCurrentTaskStack(void); static void SetStackTop(word *w); static word *GetStackTop(void); static void SetStackMax(word *w); static word *GetStackMax(void); static void Init(); static int Run(); static Thread *GetCurrentThread(); static u_int GetCurrentStackTop(); static Thread *NewThread(u_int nArgs, word args); static Thread *NewThread(word closure, nArgs, word args); static void ScheduleThread(Thread *thread); static void WakeupThread(Thread *thread); static void SuspendThread(Thread *thread); static void ResumeThread(Thread *thread); static void EnlargeTaskStack(); static StackFrame *PushFrame(u_int size); static StackFrame *GetFrame(); static void PopFrame(); static void PopFrame(u_int size); static void PushHandler(word data); static void PopHandler(); static Worker::Result PushCall(word closure); };
The static constructor.
This is the main function of the scheduler. It is invoked once the core system has been initialized. It returns only if the currently running thread asks for system termination via the EXIT message.
Returns the pointer of the thread object currently executed.
Returns the topmost index of the stack
.Creates a new runnable thread and enqueues to the main thread queue. The latter variant also pushes a call to the closure closure onto the task stack of the freshly created thread.
.Schedules the thread denoted by thread.
Wakes up the thread denoted by thread.
Suspends/Resumes the thread denoted by thread.
Enlarges the task stack of the currently executed thread by factor 1,5.
Creates a stack frame of size size on top of the task stack of the currently executed thread.
Returns the topmost stack frame of the task stack of the currently executed thread.
Removes the topmost stack frame of the task stack of the currently executed thread. The first variant automatically computes the size of the stack frame, whereas the latter takes size as input.
Pushes an exception handler frame for the topmost stack frame of the currently executed thread. The data is stored to be given as argument in case of a handle event. PopHandler removes a previously installed exception handler. Both functions operate on the exception handler stack of the thread currently executed.
Pushes a call to the closure closure on top of the stack of the currently executed thread. This function takes care of requesting everything that is required in order to complete the call.
Computation within a thread is organized into tasks pushed on the task stack. In addition, each thread provides an exception handler stack allowing for constant time handling of exceptions.
class Thread : private Block { public: enum priority { HIGH, NORMAL, LOW }; enum state {BLOCKED, RUNNABLE, TERMINATED }; priority GetPriority(); state GetState(); bool IsSuspended(); TaskStack *GetTaskStack(); void SetTaskStack(TaskStack *taskStack); word GetArgs(u_int & nArgs); void SetArgs(u_int nArgs, word args); void SetTerminated(); void BlockOn(word future); word GetFuture(); void Wakeup(); StackFrame *PushFrame(u_int size); void PushHandler(word data); void PushHandler(u_int frame, word data); void GetHandler(u_int & frame, word & data); void PopHandler(); void Purge(); using Block::ToWord; static Thread *New(u_int nArgs, word args); static Thread *FromWord(word x); static Thread *FromWordDirect(word x); };
Returns the pritority of the thread thread, which is one of the following:
The current implementation of SEAM only supports normal priority threads.
Returns the state of the thread thread, which is one of the following:
Returns a boolean value indicating whether the thread is suspended or not.
Returns the current task stack of the thread.
Updates the task stack associated with the thread.
Returns/Updates the arguments cached in the thread. This is required to allow the seamless continuation of previously interrupted computation.
Updates the thread state to TERMINATED.
Blocks the thread on the future future.
Returns the future the thread currently blocks on.
Wakes up a thread by setting its state to RUNNABLE again.
Pushes a stack frame of size size on top of the threads task stack.
Pushes a exception handler frame on the threads exception handler stack, that is referring to the topmost stack frame of the threads task stack. The latter variant installs a handler that refers to the stack frame denoted by frame. data is stored in the freshly created exception handler frame. PopHandler pops the topmost exception handler from the threads exception handler stack. Implementors must take care to always pair calls to PushHandler and PopHandler or ensure the raising of an exception.
Creates a new thread with nArgs cached arguments stored in args.
Conversion from/to tagged representation.
The task stack provides a resizable array of flatly arranged stack frames.
class TaskStack : private DynamicBlock { public: using DynamicBlock::GetSize; using DynamicBlock::GetArg; using DynamicBlock::ReplaceArg; static void Init(); u_int GetTop(); void SetTop(u_int top); StackFrame *GetFrame(u_int index); static TaskStack *New(u_int size); static TaskStack *New(); TaskStack *Enlarge(); void Purge(); void Dump(u_int top, std::ostream& = std::cerr); using DynamicBlock::ToWord; static TaskStack *FromWordDirect(word x); };
Static constructor.
Returns the stack size.
Sets the stack size to top.
Returns the stack frame located at index index.
Retuns a freshly allocated task stack with initial size size. The latter variant uses a implementation dependent default size.
Returns a 1.5 times sized clone of the current task stack.
Purges the task stack, that is, for every stack frame the Purge method of the associated worker is invoked.
.Dumps the content of the stack frame starting from stack top top.
Conversion from/to tagged representation.
SEAM stack frames are indices into the task stack array. For convenience, however, they are temporarily translated into object pointers that have limited scope. In particular, these object pointers become invalid if the stack frame they refer to has been popped from the stack. Thus, it is required to read all required stack frame elements from the stack frame prior to popping it from the stack.
class StackFrame { public: void New(Worker *worker); u_int GetSize(); Worker *GetWorker(); word GetArg(u_int pos); void InitArg(u_int pos, s_int value); void InitArg(u_int pos, word value); void ReplaceArg(u_int pos, s_int value); void ReplaceArg(u_int pos, word value); word Clone(); }; #define NEW_STACK_FRAME(frame, worker, size) ... #define NEW_THREAD_STACK_FRAME(frame, thread, worker, size) ...
This macro creates a new stack frame on top of the task stack of the current tread and introduces a new variable frame of type StackFrame. The size of the frame is given by size and the worker assigned to the freshly created frame is denoted by worker. This macro implicitly invokes the New constructor of the StackFrame class.
NEW_THREAD_STACK_FRAME behaves like NEW_STACK_FRAME except that the task stack of thread thread is used.
Returns the total size of the stack frame including the one field used for the mandatory worker.
Returns the worker object associated with the stack frame.
Returns the value located at pos in the stack frame.
Initializes/Overwrites the pos-th field of the stack frame with value value.
Returns the a first class clone of the stack frame.
Execution in SEAM is modelled through the worker indirection. That is, for the topmost stack frame on the task stack of the currently executed thread the scheduler invokes the Run or Handle method of the worker object stored in the stack frame. Computation proceeds according to the message returned by the invoked method.
The worker is used for computations that do not involve execution of language specific code as for example the pickler and unpickler.
class Worker { public: enum Result { CONTINUE, PREEMPT, SUSPEND, RAISE, REQUEST, TERMINATE, EXIT }; Worker(); static void Construct(); static u_int Deconstruct(); virtual u_int GetFrameSize(StackFrame *sFrame) = 0; virtual void PurgeFrame(StackFrame *sFrame); virtual Result Run(StackFrame *sFrame) = 0; virtual Result Handle(word data); virtual const char *Identify() = 0; virtual void DumpFrame(StackFrame *sFrame) = 0; };
SEAM supports arity raising by means of runtime calling convention conversion, that is, the explicit construction/deconstruction of arguments. If Scheduler::nArgs denotes a value greater than one this function constructs a tuple containing the arguments stored in Scheduler::currentArgs and rewrites the argument registers accordingly. Scheduler::nArgs and Scheduler::currentArgs are available through the corresponding accessor functions.
SEAM supports arity raising by means of runtime calling convention conversion, that is, the explicit construction/deconstruction of arguments. This function tries to deconstruct the tuple given as first argument. In case the tuple needs to be requested, the function returns one, with Scheduler::currentData set as a side effect. Otherwise, the function returns zero to indicate successful deconstruction.
This function returns the size of the stack frame denoted by sFrame.
This function implements the purging of the stack frame denoted by sFrame. It defaults to the noop function.
This function implements the regular execution associated with the stack frame denoted by sFrame. After computation succeeded, it indicates on of the following conditions to the scheduler:
This function implements the exception handling associated with the stack frame denoted by sFrame. It defaults to the usual reraising function. A handler is free to decide how to proceed computation. See Run for possible return values.
This function returns a c string containing symbolic identification information.
This functions implements the dump function of associated with the stack frame. This function will be used by the default exception handler to construct a exception backtrace.
The interpreter extends the worker interface with language code execution, in particular the creation of a new closure-specific activation record on the task stack and argument passing support.
class Interpreter : public ConcreteRepresentationHandler, public Worker { public: Interpreter(); typedef Result (*function)(); virtual Transform *GetAbstractRepresentation(ConcreteRepresentation *); virtual void PushCall(Closure *closure) = 0; virtual u_int GetInArity(ConcreteCode *concreteCode) = 0; virtual u_int GetOutArity(ConcreteCode *concreteCode) = 0; virtual function GetCFunction(); };
Constructor.
Implements the construction of a activation record on the task stack of the currently executed thread for the closure denoted by closure.
Returns the number of input arguments of the closure denoted by closure. Returns INVALID_INT to signal unknown.
Returns the number of output arguments of the closure denoted by closure. Returns INVALID_INT to signal unknown.
Returns the function associated with the interpreter, with NULL indicating that there is no such function.
SEAM supports the notion of concrete, that is internal, and abstract, that is serializable, representation. This is implemented by means of the ConcreteRepresentation that is associated with a handler that implements the type specific conversion to the abstract representation, if any.
The abstract representation consists of a pair of a name and a value and is named Transform. The name will be used by the unpickler to apply the appropriate internalization function associated with this name.
class ConcreteRepresentationHandler { public: virtual Transform *GetAbstractRepresentation(ConcreteRepresentation *) = 0; }; class Transform : private Block { public: static Transform *New(Chunk *name, word argument); Chunk *GetName(); word GetArgument(); using Block::ToWord; static Transform *FromWord(word x); static Transform *FromWordDirect(word x); }; class ConcreteRepresentation : private Block { public: static ConcreteRepresentation *New(ConcreteRepresentationHandler *handler, u_int size); ConcreteRepresentationHandler *GetHandler(); u_int GetSize(); void Init(u_int index, word value); void Replace(u_int index, word value); word Get(u_int index); using Block::ToWord; static ConcreteRepresentation *FromWord(word x); static ConcreteRepresentation *FromWordDirect(word x); };
This abstract function models the transformation from a concrete representation to a serializable abstract representation. Returning an INVALID_POINTER denotes that the object cannot be serialized.
Returns a freshly allocated concrete representation object that provides size data fields and is associated with handler. Note that the handler must be a non-null pointer.
Returns the abstract transformation handler associated with the concrete representation.
Returns the number of data fields available.
The usual data field accessors.
Conversion from/to tagged representation.
The concrete code is the generic code container. Its main task is to specify access to the interpreter responsible for executing code. Code is derived from a concrete representation to support the runtime conversion from internal to external representation.
class ConcreteCode : private ConcreteRepresentation { public: static ConcreteCode *New(Interpreter *interpreter, u_int size); Interpreter *GetInterpreter(); using ConcreteRepresentation::Init; using ConcreteRepresentation::Get; using ConcreteRepresentation::ToWord; static ConcreteCode *FromWord(word x); static ConcreteCode *FromWordDirect(word x); };
Returns a freshly allocated concrete code object of size size that is associated with interpreter interpreter.
Returns the interpreter associated with the concrete code object.
The usual data field accessors.
Conversion from/to tagged representation.
The closure allows to associate data with code, a common pattern in functional programming languages.
class Closure : private Block { public: static Closure *New(word concreteCode, u_int size); word GetConcreteCode(); void SetConcreteCode(word concreteCode); u_int GetSize(); void Init(u_int index, word value); void Update(u_int index, s_int value); void Update(u_int index, word value); word Sub(u_int index); using Block::Toword; static Closure *FromWord(word x); static Closure *FromWordDirect(word x); };
Returns a freshly allocated closure with size data fields that is associated with concrete code concreteCode.
Returns/Updates the concrete code associated with the closure.
Returns the number of data fields available.
The usual data field accessors. The integer variants are present for optimization reasons.
.Conversion from/to tagged representation.
The RootSet is a convenience abstraction allowing for static variables to be added to the root set.
class RootSet { public: static void Init(); static void Add(word & root); static void Remove(Word & root); static void DoGarbageCollection(); };
Static constructor.
Adds root to the root set.
Removes root from the root set.
Performs garbage collection with respect to the defined root set.
The broker is reponsible for loading different language layers and provides a method to share arbitrary store values between languages based on string identifiers. It does not, however, provide language-specific value conversion.
class Broker { public: static word BrokerError; static void Init(); static void Start(String *languageId, int argc, char *argv[]); static Worker::Result Load(String *languageId, String *key = NULL); static void Register(String *name, word value); static word Lookup(String *name); };
Static constructor.
This method starts a language layer denoted by languageId by invoking the Start method of the language layer with the SEAM process arguments passed to it. In case the language layer cannot be started, the SEAM process exits with the error condition given.
This method loads a language layer denoted by languageId, with the optional argument key passed to the Load function of the language layer. In case of failure, the exception BrokerError is raised.
This method calls the Destroy method on each active language layer. This is normally called just before SEAM exits.
Enters the value denoted by value into the shared values table using key key.
Tries to lookup the value stored under key key in the shared values table. In case of failure, a implementation dependent default value is returned.
As noted above, SEAM supports the notion of internal and external representation. Externalized representations that require a different internal representation are stored as transforms, that is, a pair consisting of a name and the external representation of the value. Tthe unpickler now works with respect to a mapping of names to internalization handlers. Each time a transform is encountered, the corresponding name will be used to perform the lookup in the handler map. If an entry exists, the result of the application of the handler to the external representation will be linked into the value graph in place of the transform. Note that internalization handlers must return a concrete representation to allow for appropriate serialization again.
class Unpickler { public: static word Corrupt; static void Init(); typedef word (*handler)(word); static void RegisterHandler(String *name, handler handler); static Worker::Result Unpack(String *string); static Worker::Result Load(String *filename); };
The exception that will be raised in case the unpickler encounters an error.
The static constructor.
Registers the handler handler under name name. Each time, the pickler encounters a transform with the same name, it applies the registered handler to the external representation.
The current implementation does not support multiple handlers stored under the same name. Instead, the old handler will be overwritten.
If successful, stores the restored value read from the string into the first argument register of the scheduler.
If successful, stores the restored value read from the file denoted by filename into the first argument register of the scheduler.
The pickler creates a bytecode program from any pickable store values.
class Pickler { public: static word Sited; static void Init(); static Worker::Result Pack(word x); static Worker::Result Save(String *filename, word x); };
The Sited exception is raised by the pickler whenever a non serializable value is encountered. For example, this is the case if the externalization of a concrete represenation returns an INVALID_POINTER.
The static constructor.
If successful, the resulting bytecode program created from value x is returned as a string in the first argument register.
If successful, the resulting bytecode program created from value x is stored into the file denoted by filename.


New
|
Save
|
Print
File 1
File 2
File 3
function foo(items) { var x = "All this is syntax highlighted"; return x; }


Contents
I like languages that can be explained within few pages of a book. Besides C, Lua, Erlang - Javascript is one such language to have that simplicity. This post is a quick reference guide to javascript, highlighted through examples and all of them can be found here.
literals
All languages are defined as collection of tokens and tokens are normally classified as literals, keywords, operators or identifiers. Literals are data-objects that are hard-coded in the program, they are baked into the language for sake of efficiency.
other than primitive types - Number, String, Boolean, rest of them are javascript objects. Javascript Object is the parent type for all user-defined types. Supports constructor pattern, prototype inheritance etc...
keywords
Keywords are special tokens that give additional structure to the program. Following is a basic set of keywords in Javascript
note that typeof is unreliable in most implementation of Javascript. It is better to use - Object.prototype.toString(10) to retrieve the type of an object, although you will have to process the returned string to remove the prefix.
To remove a property name from object, use delete instead of assigning null.
Keywords that add conditional structure,
only the ternary operator can be treated as expression rest every thing are statements.
Keywords that add looping structure,
all keywords that add looping structure are to be treated as statements.
Now let us move on to operators. While literals bake data values directly into the language, for the sake of efficiency, operators are functions on data values that are baked into the language.
arithmetic-operators
keep in mind that Javascript does lot of implicit type-coercions.
comparison-operators
there is no real way to compare equality of non-primitive objects and in many cases it is better to stick with === instead of ==. Former compares for both value and type, while the later compares only the value.
bitwise-operators
comments on the right side explain the output by demonstrating the operation in binary-format. Conceptually, the bitwise logical operators work as follows:
- the operands are converted to 32-bit integers and expressed by a series of bits (zeros and ones).
- each bit in the first operand is paired with the corresponding bit in the second operand: first bit to first bit, second bit to second bit, and so on.
- the operator is applied to each pair of bits, and the result is constructed bitwise.
If you are a C programmer, you might already be knowing the difference between between arithmetic >> and logical >>> right shift. Otherwise, just remember the following points,
- right-shift matters only to negative numbers that can be represented in 32-bit 2's complement.
- arithmetic right-shift preserves the sign while logical does-not.
- logical right-shift will stuff as many binary 0s on the left as that are shifted out on the right.
Looks like bitwise operations on large integers are left undefined in Javascript.
assignment operators
normally assignments are statement in many languages. In Javascript an assignment is treated like an expression, and based on the scope of the expression, the context where the side effects are created varies. It is explained in a separate section below.
There is also membership operator . that can be used to access property names on objects.
types
Javascript is weakly typed. Please note that values and objects in Javascript are strongly typed and values are always associated with same type. It is the reference to values that are weakly typed - in the sense that same variable name can refer to different types of value while the program is executing. It also means that programmers can interpret a variable as particular type which can be wrong and it is difficult to catch this problem at compile time.
in the end of above gist, we demonstrate two other ways of creating a number-value 10 and n === m give false because the former is number-type while the later is object-type.
function and scope
following gist shows some name-resolution gymnastics with javascript functions.
in javascript functions are the only means of code-abstraction and thereby only form of scoping available for programmers. By default every function act as a closure, making its local namespace available for enclosed function definitions. And only those functions that are enclosed within the scope of an outer-function can access the outer function's local namespace.
Make a note that parent function's namespaces are only referred by enclosed function, parent function's namespace is not copied to enclosed function's namespace.
Function arguments can be accessed within a function like,
And some gymnastics with scope.
it is always a good practice to declare variables with var, so that it gets contained in the enclosing scope. Javascript can hoists declarations, that is, both var statements and function declarations will be moved to the top of the enclosing scope.
name resolution order,
- In case there is a var foo statement in the current scope, use that.
- If one of the function parameters is named foo, use that.
- If the function itself is called foo, use that.
- Go to the next outer scope, and start again.
Another thing about scoping is that there is only one global namespace. That is Javascript does not have the notion of modules, hence everything is executed in the context of the same single global namespace.
evaluation
Since Javascript is byte-code interpreted language, program text can be parsed compiled to virtual-machine byte code and executed on the fly.
a curious aspect here is that even statements like if blocks are executed as expression and value is returned. Note that it is not legal to do a = if(true) {100} else {200} in your .js file or under <script> tag of html.
Normally eval function will execute the script in the local-scope of the caller. However, it only executes in the local scope when called directly.


Class: Puma::MiniSSL::Socket
| Relationships & Source Files | |
| Inherits: | Object |
| Defined in: | lib/puma/minissl.rb |
Class Method Summary
- .new(socket, engine) ⇒ Socket constructor
Instance Attribute Summary
- #closed? ⇒ Boolean readonly
- #should_drop_bytes? ⇒ Boolean readonly
Instance Method Summary
-
#<<(data)
Alias for #write.
- #close
- #engine_read_all
- #flush
- #peeraddr
- #peercert
- #read_and_drop(timeout = 1)
- #read_nonblock(size, *_)
- #readpartial(size)
-
#syswrite(data)
Alias for #write.
- #to_io
- #write(data) (also: #syswrite, #<<)
-
#write_nonblock(data, *_)
This is a temporary fix to deal with websockets code using write_nonblock.
Constructor Details
.new(socket, engine) ⇒ Socket
# File 'lib/puma/minissl.rb', line 11
def initialize(socket, engine) @socket = socket @engine = engine @peercert = nil end
Instance Attribute Details
#closed? ⇒ Boolean
(readonly)
[ GitHub ]
# File 'lib/puma/minissl.rb', line 21
def closed? @socket.closed? end
#should_drop_bytes? ⇒ Boolean
(readonly)
[ GitHub ]
# File 'lib/puma/minissl.rb', line 135
def should_drop_bytes? @engine.init? ||<EMAIL_ADDRESS>end
Instance Method Details
#<<(data)
Alias for #write.
# File 'lib/puma/minissl.rb', line 107
alias_method :<<, :write
#close
[ GitHub ]# File 'lib/puma/minissl.rb', line 139
def close begin # Read any drop any partially initialized sockets and any received bytes during shutdown. # Don't let this socket hold this loop forever. # If it can't send more packets within 1s, then give up. while should_drop_bytes? return if [:timeout, :eof].include?(read_and_drop(1)) end rescue IOError, SystemCallError Thread.current.purge_interrupt_queue if Thread.current.respond_to? :purge_interrupt_queue # nothing ensure @socket.close end end
#engine_read_all
[ GitHub ]# File 'lib/puma/minissl.rb', line 42
def engine_read_all output = @engine.read while output and additional_output = @engine.read output << additional_output end output end
#flush
[ GitHub ]# File 'lib/puma/minissl.rb', line 122
def flush @socket.flush end
#peeraddr
[ GitHub ]# File 'lib/puma/minissl.rb', line 155
def peeraddr @socket.peeraddr end
#peercert
[ GitHub ]#read_and_drop(timeout = 1)
[ GitHub ]# File 'lib/puma/minissl.rb', line 126
def read_and_drop(timeout = 1) return :timeout unless IO.select([@socket], nil, nil, timeout) return :eof unless read_nonblock(1024) :drop rescue Errno::EAGAIN # do nothing :eagain end
#read_nonblock(size, *_)
[ GitHub ]# File 'lib/puma/minissl.rb', line 50
def read_nonblock(size, *_) # *_ is to deal with keyword args that were added # at some point (and being used in the wild) while true output = engine_read_all return output if output data = @socket.read_nonblock(size, exception: false) if data == :wait_readable || data == :wait_writable # It would make more sense to let @socket.read_nonblock raise # EAGAIN if necessary but it seems like it'll misbehave on Windows. # I don't have a Windows machine to debug this so I can't explain # exactly whats happening in that OS. Please let me know if you # find out! # # In the meantime, we can emulate the correct behavior by # capturing :wait_readable & :wait_writable and raising EAGAIN # ourselves. raise IO::EAGAINWaitReadable elsif data.nil? return nil end @engine.inject(data) output = engine_read_all return output if output while neg_data = @engine.extract @socket.write neg_data end end end
#readpartial(size)
[ GitHub ]# File 'lib/puma/minissl.rb', line 25
def readpartial(size) while true output = @engine.read return output if output data = @socket.readpartial(size) @engine.inject(data) output = @engine.read return output if output while neg_data = @engine.extract @socket.write neg_data end end end
#syswrite(data)
Alias for #write.
# File 'lib/puma/minissl.rb', line 106
alias_method :syswrite, :write
#to_io
[ GitHub ]# File 'lib/puma/minissl.rb', line 17
def to_io @socket end
#write(data) Also known as: #syswrite, #<<
[ GitHub ]# File 'lib/puma/minissl.rb', line 84
def write(data) return 0 if data.empty? need = data.bytesize while true wrote = @engine.write data enc = @engine.extract while enc @socket.write enc enc = @engine.extract end need -= wrote return data.bytesize if need == 0 data = data[wrote..-1] end end
#write_nonblock(data, *_)
This is a temporary fix to deal with websockets code using write_nonblock. The problem with implementing it properly is that it means we’d have to have the ability to rewind an engine because after we write+extract, the socket write_nonblock call might raise an exception and later code would pass the same data in, but the engine would think it had already written the data in. So for the time being (and since write blocking is quite rare), go ahead and actually block in write_nonblock.
# File 'lib/puma/minissl.rb', line 118
def write_nonblock(data, *_) write data end


This program extends the functionality of the Windows 7 [Win][Arrow Keys] hotkeys, allowing you more control over your window layout.
This software is licensed under the MIT License.
Acquire the full source from GitHub.
Note: All keybindings in stated by document are configurable. You can change them in the Configuration File . The defaults are listed here for simplicity.
By default, [Alt][Arrow Keys] will expand the window in the specified direction. By default, the window expands:
Using [Alt][WASD] will move the window in a similar way.
You can change these settings in the Configuration File . The window will never expand over monitor's border. To move a window over the edge of on monitor to another, use [Win][Arrow Keys].
| A window will expand until it hits the edge of the nearest window, or... | ... it will expand to the next grid cell of the screen. |
You can make smaller increments to the grid-based movement by using [Shift][Alt][Arrow Keys].
Take the case where you have a nice setup going, but one half of the monitor isn't quite wide enough. Using [Alt][Arrow Keys] on the blue window below will cause the window to overlap the brown, and the pink would no longer be aligned.
Instead, use [Ctrl][Alt][Arrow Keys] to keep them all in sync:
| Using [Ctrl][Alt][Arrow Keys] allows you to adjust the size of a window while preserving your window layout. |
The configuration file allows you to adjust some of the keys and behaviour of AWHK.
It is a plain text file consisting of a set of key-value pairs. It doesn't exist by default. You can find it or create it at the following location on disk:
%LOCALAPPDATA%\AWHK.ini
If you create or make changes to this file, you can reload the configuration with the Alt+F2 binding (by default). You'll see this prompt:
AWHK can also create this file for you, and/or open it in your default text editor, using the Shift+Alt+F2 binding (by default).
| Key Name | Default Value | Purpose |
| LaunchOnStartUp | false | Configures AWHK to run on Windows start-up. This only takes effect if the configuration file is parsed, either on AWHK start-up or after you reload the configuration file. |
| AllowSnapToOthers | false | Snaps window movements and resizes to the edges of other windows. (Caution: this can be annoying if you have many overlapping or obscured windows, so it is disabled by default.) |
| MaxEdgeSearchSize | 128 | The number of window edges to consider when searching for an edge to snap to. You generally should never need to change this, but if you have hundreds of windows, you might want to increase it. |
| GridX | 8 | Partitions the screen into N segments to snap to in the horizontal axis. |
| GridY | 4 | Partitions the screen into N segments to snap to in the vertical axis. |
| FineX | 32 | Partitions the screen into N segments to snap to in the horizontal axis when using the Fine modifier. |
| FineY | 16 | Partitions the screen into N segments to snap to in the vertical axis when using the Fine modifier. |
| HelpCombo | ALT | Launch this help. |
| ReloadConfigCombo | ALT+F2 | Prompt to reload the configuration file. |
| EditConfigCombo | SHIFT+ALT+F2 | Launch the configuration file in your default text editor. If it doesn't exist, it is created. |
| QuitCombo | SHIFT+ALT+F4 | Prompts to quit AWHK. |
| MoveKeyMod | ALT | Hold this to enable the movement keys. |
| NextKeyMod | CONTROL | Hold this to also push or pull other windows touching the current window edge. |
| FineKeyMod | SHIFT | Hold this to snap to the finer grid. |
| ResizeKeys | LEFT,RIGHT,UP,DOWN | Use these with the modifiers to resize the current window. |
| MoveKeys | A,D,W,S | Use these with the modifiers to move the current window. |
| MediaPrev | SHIFT+ALT+F11 | Skip back to the previous media track. |
| MediaNext | SHIFT+ALT+F12 | Skip to the next media track. |
| MediaStop | not bound | |
| MediaPlayPause | ALT+F9 | Play or pause the current media track. |
| MediaVolumeMute | ALT+F10 | Mute the volume. |
| MediaVolumeDown | ALT+F11 | Reduce the volume. |
| MediaVolumeUp | ALT+F12 | Increase the volume. |
Copyright © 2022 Peter J. B. Lewis


{% extends "census/base.html" %} {% load static %} {% block content %}
You have verified the following copies.
Please view copy details to see if anything needs to be edited.
Edits will be automatically submitted to an administrator for approval.
For information on how to use each field, please see the Cataloging Guide.
| Copies at {{ affiliation }} | |||
|---|---|---|---|
| {{ copy.issue.edition.title }} ({{ copy.issue.year }}) -- STC/Wing: {{ copy.issue.STC_Wing }} | View details | Edit details |


COЯE - Computer Obsessed Radical Enthusiasts,
is the computer and technology club of Delhi Public School, Dwarka.
Instituted in 2008 by the students of DPS dwarka, COЯE was established with the aim of promoting competence and excellence in the field of computer and information technology at school, as well as various inter-school symposia. COЯE hosted its first Inter School Symposium in 2008. Since then, we have not looked back.
Over the years, the club has progressed phenomenally, dominating several competitions and attaining victory. We have set high standards and ensure that we not only conform to these year after year, but set the bar a few notches higher. It takes a radical attitude, love for computers and an exceptional set of skills to be a part of the club.
COЯE 10 was held on 1st-2nd November. Certainly one of the best symposiums last year, it consisted of various events like Programming, Web Design, Gaming, Quiz etc. The overall trophy was bagged by DPS Vasant Kunj.


The Best of the Best
Best Wireless PlayStation 4 Headsets in 2019: Black Friday 2019 - Deals & Buyer's Guide
by Jennifer LockeBest Wireless PlayStation 4 Headsets Android Central 2019
When you're playing a game you want the very best audio quality possible. Using a good headset is almost like experiencing a whole new universe once you put it on. If you want the best of the best wireless options for your PlayStation 4, you'll want the SteelSeries Arctis 7 for its form factor, affordability, and audio quality. But there are plenty of others out there to choose from depending on your tastes.
- Best Overall: SteelSeries Arctis 7
- Runner-up: HyperX Cloud Flight
- Best Value: Turtle Beach Stealth 600
- Best Premium: Astro A50
- Surround Sound: Razer Thresher Ultimate
- Multi-source Audio: Logitech G933 Artemis Spectrum
Black Friday is the best time of the year to get a new headset. If you're finally looking to take the plunge into the wonderful world of wireless headsets, you'll want to do so soon. Wireless headsets tend to get expensive, so don't miss out on any Black Friday deals. We'll be sure to update you when we come across the best discounts.
Best Overall: SteelSeries Arctis 7
Let's be honest, gaming headsets tend to be gaudy. You've seen the unwieldy ones that light up in every color imaginable and look like they can be used as bludgeoning weapons. That's not to say they aren't good headphones, but they certainly aren't the most stylish. The SteelSeries Arctis 7 benefits from its sleek design. You won't be embarrassed to wear this one no matter the occasion, and its style only scratches the surface of its favorable features.
Headsets are more than just about looks, though. The Arctis 7 features what is widely regarded as one of the best microphones in the business, and its 7.1 surround sound audio is second to none—but only available when using it on PC. Should you want to finely adjust it, SteelSeries also offers customization software so that you can get the most out of your Arctis 7.
And you won't need to worry about charging it often either. This headset provides up to 24 hours of gaming on a single charge thanks to its rechargeable Li-ion battery, and it's fairly comfortable to wear for long periods of time. You'll find most other headsets tend to provide anywhere between 10 and 20 hours.
Pros:
- Stylish
- Affordable
- Great audio quality
- 24-hour battery life
- ClearCast retractable microphone
- Customization software
- Additional 3.5mm cable included
Cons:
- 7.1 surround sound only on PC
- Adjustable ChatMix for PC only
Best Overall
SteelSeries Arctis 7
Affordable, stylish, and impeccable audio
There's not a lot wrong with the SteelSeries Arctis 7. It takes the best features and an attractive form factor and bundles it into an affordable package.
Runner-up: HyperX Cloud Flight
When you're looking for comfort and quality at an affordable price, you'll want to consider the HyperX Cloud Flight. It may not be as great all-around as the SteelSeries Arctis 7, but it gives the latter pair of headsets a run for its money. The HyperX Cloud Flight sports a detachable microphone, 90-degree rotating ear cups, and an adjustable steel slider for durability.
HyperX Cloud Flight by far provides the longest battery life on a single charge—boasting up to 30 hours—but there is a caveat. This number is assuming that you don't use its LED lighting. If you turn the LEDs completely on, it cuts the battery life to just 13 hours. When the LEDs are on with its breathing effect, you can get roughly 18 hours.
Its biggest downside is that it only offers stereo audio as opposed to 7.1 surround sound. While its audio quality may not be as impressive as a result, it's still good nonetheless.
Pros:
- Up to 30-hour battery life
- Rotating ear cups
- Detachable microphone
- Additional 3.5mm cable included
Cons:
- No 7.1 surround sound
- LED mode cuts battery life to 13 hours
Runner-up
HyperX Cloud Flight
Long battery life
The HyperX Cloud Flight provides the longest gaming session on a single charge and sports comfortable rotating ear cups.
Best value: Turtle Beach Stealth 600
Turtle Beach is usually a brand name you can't beat for its price. The company's Stealth 600 is perfect for those wanting a budget-friendly quality headset without breaking the bank. Wireless headsets tend to err on the expensive side, but the Turtle Beach Stealth 600 is incredibly affordable at just $100.
Its microphone is flip-to-mute, meaning you won't need to worry about pressing the wrong button on your headset when you want to mute yourself. And its mic monitoring allows you to hear your own voice through the headset and adjust the volume accordingly. Turtle Beach's "Superhuman Hearing" technology that emphasizes subtle in-game sounds is also present.
Though the Stealth 600 advertises "surround sound," it's only Turtle Beach's own virtual surround sound and not Dolby 7.1. Because of this, the audio quality tends to suffer, but it's still better than stereo most of the time. And the battery life is acceptable at 15-hours, even if it's only half of what the SteelSeries Arctis 7 offers.
Pros:
- Affordable
- Glasses-friendly design
- Flip-up to mute mic
Cons:
- Audio is just decent
- 15-hour battery life
Best Value
Turtle Beach Stealth 600
Budget-friendly for a brand name
When it comes to wireless headsets, you can't beat the price of the Turtle Beach Stealth 600. And it's a brand name that you can trust where headsets are concerned.
Best Premium: Astro A50
The Astro A50 provides crystal-clear Dolby 7.1 surround sound over a 5GHz wireless connection. It's hard to beat that when you're looking for the best audio experience possible. It even comes with its own charging station so you can easily display it on your desk.
Those looking for comfort will find it more than adequate in that regard with breathable fabric ear cups. A mod kit is available to purchase separately that allows you to swap out its parts for a synthetic leather headband and ear cups, improving its noise-canceling abilities. The downside to all of this is that no matter what you swap out the parts with, the Astro A50 still tends to be bulky and gaudy.
This beast is easily the best premium headset you can get for PlayStation 4, and it comes at a steep price because of that. You're going to be looking at spending a good chunk of change on the Astro A50. It packs some premium features to warrant the expensive price tag.
Pros:
- Dolby 7.1 surround sound
- 5GHz wireless connection
- Flip-to-mute mic
- Base station included
Cons:
- Expensive
- Batteries can degrade
- Bulky design
Best Premium
Astro A50
Premium quality at a cost
You'll be spending quite a sum if you want an Astro A50, but its wireless connection and Dolby 7.1 surround sound can't be beaten.
Surround Sound: Razer Thresher Ultimate
Razer makes some of the best headsets in the business, and it outdid itself with the Razer Thresher Ultimate for PlayStation 4. You're getting impeccable Dolby 7.1 surround sound with wireless connectivity up to 40 feet, so you don't need to worry about missing any of the conversation with your friends if you need to leave the room.
Its microphone is retractable so you can move it out of the way, and when you're not using the headset you can place it on its base station — that can be used to switch effortlessly between PS4 and PC — which is included. You can get up to 16-hours without needing to charge the Razer Thresher Ultimate. Its memory foam ear cups make this as comfortable as possible to make up for its heavy weight of 408g.
Again, this is another expensive one.There are cheaper Razer Thresher models out there, but the Ultimate is the best package out of the batch if you're looking for the most features.
Pros:
- Dolby 7.1 surround sound
- Connectivity up to 40ft
- Retractable microphone
- Base station included
Cons:
- 16-hour battery life
- Heavy (408g)
- Expensive
Surround Sound
Razer Thresher Ultimate
For the loyal Razer enthusiast
The Razer Thresher Ultimate has a decent enough battery life and great audio quality with Dolby 7.1 surround sound.
Multi-source Audio: Logitech G933 Artemis Spectrum
It's immediately apparent that this headset screams "gamer." You'll be hard-pressed to find one with a more gaudy design, but what it lacks in style it makes up for in audio delivery. This is another one that packs 7.1 surround sound with spatial awareness so that you're never missing any of the action in-game.
Being multi-platform compatible, you aren't even restricted to using it on just PlayStation 4 or PC. The Logitech G933 Artemis Spectrum is compatible with Xbox One, Nintendo Switch, and mobile as well. Its multiple source audio mixing support means that you can plug in up to three devices (one USB, two analog) to answer calls and play music. The programmable G-keys on the ear cup can be used to set custom controls for gaming and media.
It sports the lowest battery life at just 8-12 hours depending on whether you're using its RGB lighting or not, and it's not too budget-friendly, so this one's features outside of gaming will likely be the deciding factor in your purchase.
Pros:
- 7.1 surround sound
- Multi-platform compatibility
- Customization software
- Multiple source audio mixing
Cons:
- Gaudy design
- Only 8-12 hours of battery life
- Expensive
Multi-source Audio
Logitech G933 Artemis Spectrum
For all of your audio needs
Another gaudy headset with a low battery life, but the Logitech G933 Artemis Spectrum is good for just about anything thanks to its multiple source audio mixing support and 7.1 surround sound.
Bottom line
The best wireless headset all-around is easily the SteelSeries Arctis 7. It's quite affordable, stylish, and provides a wonderful audio experience whether you're concerned with its microphone or headset itself. On top of that, it has one of the best battery lives out there and comes with customization software to make it even better.
If you're looking for something a little more premium, you can't beat the Astro A50. Questionable-looking design aside, its 7.1 surround sound is crystal clear. Just be prepared for its higher price tag because of this. Wireless headsets don't come cheap, and though you aren't always paying for quality, it's a good indicator in this regard that you're getting a top-of-the-line product.
While the absolute best quality audio is found on a good wired headset, not everyone wants to deal with all of the cables that come with them. Wired might still be the best, but wireless can still provide an excellent audio experience, and you can't go wrong with any of the above wireless headsets.
How to find the best Black Friday deals on wireless PS4 headsets
When it comes to headsets, audio quality and comfort should be paramount. When shopping on Black Friday, be sure to check reviews and see what people have to say about a particular headset. A steep discount won't do you any good if you come to find out that headset you just bought isn't so comfortable when you're wearing glasses. For anyone looking to get into game streaming but who doesn't want to buy a separate microphone, try to get one that either retracts or that flips up to mute. Also, always try to find a pair with good battery life. Wireless means nothing if you constantly have to charge it.
Any brand that sells gaming accessories will likely have good deals on wireless headsets this Black Friday. It's rare to find a wireless headset bundled with a console or a few games, so you should look at grabbing a headset on its own. Remember that just because a headset may normally sell for $300, that doesn't mean it's the best out there. Plenty of wireless headsets get the job done for a fraction of that price.
We'll keep you updated on exact discounts for these headsets as we see them. For deals on other tech and accessories, be sure to check out the rest of our Black Friday shopping guides here on Android Central.
Credits — The team that worked on this guide
Jennifer Locke has been playing video games nearly her entire life, and is always on the lookout for new tech and accessories to make those experiences even better on whichever console you choose to play on.
We may earn a commission for purchases using our links. Learn more.


08 December 2000
Disease Outbreak Reported
As of 8 December, the Ugandan Ministry of Health has
reported the following new laboratory confirmed cases by district:
The cumulative figure for all affected districts in the country is 405 cases and 160 deaths.*
Since mid-October, partners in the Global Outbreak Alert and Response Network coordinated by WHO have been responding to the ebola outbreak in Gulu, Masindi and Mbarara districts. While the international response to the outbreak has progressed beyond the initial acute phase there is continued need for intensive measures to control and contain the outbreak.
The situation in Masindi requires particular attention and the Ugandan Ministry of Health has appealed for volunteers to assist in the following areas: disease surveillance and control tracing; transportation of the dead; social mobilization; infection control; clinical care of patients. WHO and its partners have moblized international staff to support this effort.
* Corrigendum: the cumulative figures in the update of 5 December (see previous report) reflect only those for Gulu district, not for all affected districts as stated.


Home
Test Name:
Sample Test
Test Date: Coming Soon
Test Description: Simulated example of a potential flight test
Selection Data


theory of electron and spin transport in three- and two-dimensional conducting systems
A number of effects which were predicted by the group members have been found experimentally in the research laboratories in Russia, Europe and the USA. Now the group is engaged in the following joint projects: (i) researches in the field of spin transport theory in collaboration with the group of Prof. Uzi Landman (Georgia Institute of Technology, Atlanta, USA); (ii) kinetic phenomena in a two-dimensional electron gas in heterostructures in collaboration with the experimental group of Prof. Laurens Molenkamp (Würzburg University, Würzburg, Germany).


-LogReview-
Notes:
-
This is an editable review of a collection of log messages that exist inside
the project. When editing messages, please be careful not to modify or remove
the markers for constant value "#?#" or
break "#/#". If the markers are missing the changes
will not match the corresponding sources and integrations of the review will fail
on the message.
-
Adjustments to this document can be made with any XML/XHTML aware editor, including
favourite word processors as long as they do not modify the general document
structure and are able to store the result as XHTML document. Any visual formatting
applied to the messages will be stripped when integrating the changes into the project.
When the document structure was modified or the resulting document is not valid XHTML,
it will be very likely not possible to integrate the changes into the project.
-
Depending on the settings that were applied when this review was created, the
collection of messages may be equal to all the log messages that exist inside the project.
-
It's not possible to change the log level or source file by editing the values inside
this review. Changes to these columns are ignored.
| INFO |
#LOG-1000010: |
Sample Message |
Path/To/Source |
Created with "Log Support" an IntelliJ IDEA Plugin by Juergen Kellerer


{% extends "base.html" %}
{% from "includes/common_macros.html" import for_contributors_sidebar %}
{% from "dashboards/includes/macros.html" import product_selector %}
{% from "dashboards/includes/macros.html" import category_filter with context %}
{% set title = 'Knowledge Base Overview' %}
{% set scripts = ('wiki', 'wiki.dashboard') %}
{% set crumbs = [(url(main_dash_view), main_dash_title), (None, title)] %}
{# TODO: Move required dashboard scripts out of wiki.js into their own #}
{% block content %}
{{ title }}


|
Returns the query parameter name under which a cancel button press
must be reported if form validation is to be skipped.
- Returns
-
The value of
org.apache.struts.taglib.html.Constants.CANCEL_PROPERTY
If a request contains a request parameter with key equal to the return value
of this method, then automatic form validation is skipped. A typical application
case is to use this magic string for the name attribute of a cancel button in a form.
If this button is pressed, automatic form validation is skipped. If automatic form
validation is not used, this magic string is irrelevant.
## A cancel button
<input type="submit" name="$form.getCancelName()" value="Cancel">
## Can also be written as
<input type="submit" name="$form.cancelName" value="Cancel">
|
|
This produces the following output:
<input type="submit" name="org.apache.struts.taglib.html.CANCEL"
value="Cancel">
|
|
|


Interface for accessing AmazonSimpleDB. More...
Inherits AmazonWebServiceClient.
Interface for accessing AmazonSimpleDB.
Amazon SimpleDB
Amazon SimpleDB is a web service providing the core database functions of data indexing and querying in the cloud. By offloading the time and effort associated with building and operating a web-scale database, SimpleDB provides developers the freedom to focus on application development.
A traditional, clustered relational database requires a sizable upfront capital outlay, is complex to design, and often requires extensive and repetitive database administration. Amazon SimpleDB is dramatically simpler, requiring no schema, automatically indexing your data and providing a simple API for storage and access. This approach eliminates the administrative burden of data modeling, index maintenance, and performance tuning. Developers gain access to this functionality within Amazon's proven computing environment, are able to scale instantly, and pay only for what they use.
Visit http://aws.amazon.com/simpledb/ for more information.
| - (SimpleDBBatchDeleteAttributesResponse * AmazonSimpleDBClient.)batchDeleteAttributes: | (SimpleDBBatchDeleteAttributesRequest *) | batchDeleteAttributesRequest |
Performs multiple DeleteAttributes operations in a single call, which reduces round trips and latencies. This enables Amazon SimpleDB to optimize requests, which generally yields better throughput.
NOTE: If you specify BatchDeleteAttributes without attributes or values, all the attributes for the item are deleted. BatchDeleteAttributes is an idempotent operation; running it multiple times on the same item or attribute doesn't result in an error. The BatchDeleteAttributes operation succeeds or fails in its entirety. There are no partial deletes. You can execute multiple BatchDeleteAttributes operations and other operations in parallel. However, large numbers of concurrent BatchDeleteAttributes calls can result in Service Unavailable (503) responses. This operation is vulnerable to exceeding the maximum URL size when making a REST request using the HTTP GET method. This operation does not support conditions using Expected.X.Name, Expected.X.Value, or Expected.X.Exists.
The following limitations are enforced for this operation:
25 item limit per BatchDeleteAttributes operation
| batchDeleteAttributesRequest | Container for the necessary parameters to execute the BatchDeleteAttributes service method on AmazonSimpleDB. |
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |
| - (SimpleDBBatchPutAttributesResponse * AmazonSimpleDBClient.)batchPutAttributes: | (SimpleDBBatchPutAttributesRequest *) | batchPutAttributesRequest |
The BatchPutAttributes
operation creates or replaces attributes within one or more items. By using this operation, the client can perform multiple PutAttribute operation with a single call. This helps yield savings in round trips and latencies, enabling Amazon SimpleDB to optimize requests and generally produce better throughput.
The client may specify the item name with the Item.X.ItemName
parameter. The client may specify new attributes using a combination of the Item.X.Attribute.Y.Name
and Item.X.Attribute.Y.Value
parameters. The client may specify the first attribute for the first item using the parameters Item.0.Attribute.0.Name
and Item.0.Attribute.0.Value
, and for the second attribute for the first item by the parameters Item.0.Attribute.1.Name
and Item.0.Attribute.1.Value
, and so on.
Attributes are uniquely identified within an item by their name/value combination. For example, a single item can have the attributes { "first_name", "first_value" }
and { "first_name", "second_value" }
. However, it cannot have two attribute instances where both the Item.X.Attribute.Y.Name
and Item.X.Attribute.Y.Value
are the same.
Optionally, the requester can supply the Replace
parameter for each individual value. Setting this value to true
will cause the new attribute values to replace the existing attribute values. For example, if an item I
has the attributes { 'a', '1' }, { 'b', '2'}
and { 'b', '3' }
and the requester does a BatchPutAttributes of {'I', 'b', '4' }
with the Replace parameter set to true, the final attributes of the item will be { 'a', '1' }
and { 'b', '4' }
, replacing the previous values of the 'b' attribute with the new value.
NOTE: You cannot specify an empty string as an item or as an attribute name. The BatchPutAttributes operation succeeds or fails in its entirety. There are no partial puts.
IMPORTANT: This operation is vulnerable to exceeding the maximum URL size when making a REST request using the HTTP GET method. This operation does not support conditions using Expected.X.Name, Expected.X.Value, or Expected.X.Exists.
You can execute multiple BatchPutAttributes
operations and other operations in parallel. However, large numbers of concurrent BatchPutAttributes
calls can result in Service Unavailable (503) responses.
The following limitations are enforced for this operation:
25 item limit per BatchPutAttributes
operation
| batchPutAttributesRequest | Container for the necessary parameters to execute the BatchPutAttributes service method on AmazonSimpleDB. |
| SimpleDBDuplicateItemNameException | ||
| SimpleDBInvalidParameterValueException | ||
| SimpleDBNumberDomainBytesExceededException | ||
| SimpleDBNumberSubmittedItemsExceededException | ||
| SimpleDBNumberSubmittedAttributesExceededException | ||
| SimpleDBNumberDomainAttributesExceededException | ||
| SimpleDBNoSuchDomainException | ||
| SimpleDBNumberItemAttributesExceededException | ||
| SimpleDBMissingParameterException | ||
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |
| - (SimpleDBCreateDomainResponse * AmazonSimpleDBClient.)createDomain: | (SimpleDBCreateDomainRequest *) | createDomainRequest |
The CreateDomain
operation creates a new domain. The domain name should be unique among the domains associated with the Access Key ID provided in the request. The CreateDomain
operation may take 10 or more seconds to complete.
NOTE: CreateDomain is an idempotent operation; running it multiple times using the same domain name will not result in an error response.
The client can create up to 100 domains per account.
If the client requires additional domains, go to http://aws.amazon.com/contact-us/simpledb-limit-request/ .
| createDomainRequest | Container for the necessary parameters to execute the CreateDomain service method on AmazonSimpleDB. |
| SimpleDBInvalidParameterValueException | ||
| SimpleDBNumberDomainsExceededException | ||
| SimpleDBMissingParameterException | ||
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |
| - (SimpleDBDeleteAttributesResponse * AmazonSimpleDBClient.)deleteAttributes: | (SimpleDBDeleteAttributesRequest *) | deleteAttributesRequest |
Deletes one or more attributes associated with an item. If all attributes of the item are deleted, the item is deleted.
NOTE: If DeleteAttributes is called without being passed any attributes or values specified, all the attributes for the item are deleted.
DeleteAttributes
is an idempotent operation; running it multiple times on the same item or attribute does not result in an error response.
Because Amazon SimpleDB makes multiple copies of item data and uses an eventual consistency update model, performing a GetAttributes or Select operation (read) immediately after a DeleteAttributes
or PutAttributes operation (write) might not return updated item data.
| deleteAttributesRequest | Container for the necessary parameters to execute the DeleteAttributes service method on AmazonSimpleDB. |
| SimpleDBInvalidParameterValueException | ||
| SimpleDBNoSuchDomainException | ||
| SimpleDBAttributeDoesNotExistException | ||
| SimpleDBMissingParameterException | ||
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |
| - (SimpleDBDeleteDomainResponse * AmazonSimpleDBClient.)deleteDomain: | (SimpleDBDeleteDomainRequest *) | deleteDomainRequest |
The DeleteDomain
operation deletes a domain. Any items (and their attributes) in the domain are deleted as well. The DeleteDomain
operation might take 10 or more seconds to complete.
NOTE: Running DeleteDomain on a domain that does not exist or running the function multiple times using the same domain name will not result in an error response.
| deleteDomainRequest | Container for the necessary parameters to execute the DeleteDomain service method on AmazonSimpleDB. |
| SimpleDBMissingParameterException | ||
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |
| - (SimpleDBDomainMetadataResponse * AmazonSimpleDBClient.)domainMetadata: | (SimpleDBDomainMetadataRequest *) | domainMetadataRequest |
Returns information about the domain, including when the domain was created, the number of items and attributes in the domain, and the size of the attribute names and values.
| domainMetadataRequest | Container for the necessary parameters to execute the DomainMetadata service method on AmazonSimpleDB. |
| SimpleDBNoSuchDomainException | ||
| SimpleDBMissingParameterException | ||
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |
| - (SimpleDBGetAttributesResponse * AmazonSimpleDBClient.)getAttributes: | (SimpleDBGetAttributesRequest *) | getAttributesRequest |
Returns all of the attributes associated with the specified item. Optionally, the attributes returned can be limited to one or more attributes by specifying an attribute name parameter.
If the item does not exist on the replica that was accessed for this operation, an empty set is returned. The system does not return an error as it cannot guarantee the item does not exist on other replicas.
NOTE: If GetAttributes is called without being passed any attribute names, all the attributes for the item are returned.
| getAttributesRequest | Container for the necessary parameters to execute the GetAttributes service method on AmazonSimpleDB. |
| SimpleDBInvalidParameterValueException | ||
| SimpleDBNoSuchDomainException | ||
| SimpleDBMissingParameterException | ||
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |
| - (SimpleDBListDomainsResponse * AmazonSimpleDBClient.)listDomains: | (SimpleDBListDomainsRequest *) | listDomainsRequest |
The ListDomains
operation lists all domains associated with the Access Key ID. It returns domain names up to the limit set by MaxNumberOfDomains. A NextToken is returned if there are more than MaxNumberOfDomains
domains. Calling ListDomains
successive times with the NextToken
provided by the operation returns up to MaxNumberOfDomains
more domain names with each successive operation call.
| listDomainsRequest | Container for the necessary parameters to execute the ListDomains service method on AmazonSimpleDB. |
| SimpleDBInvalidParameterValueException | ||
| SimpleDBInvalidNextTokenException | ||
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |
| - (SimpleDBPutAttributesResponse * AmazonSimpleDBClient.)putAttributes: | (SimpleDBPutAttributesRequest *) | putAttributesRequest |
The PutAttributes operation creates or replaces attributes in an item. The client may specify new attributes using a combination of the Attribute.X.Name
and Attribute.X.Value
parameters. The client specifies the first attribute by the parameters Attribute.0.Name
and Attribute.0.Value
, the second attribute by the parameters Attribute.1.Name
and Attribute.1.Value
, and so on.
Attributes are uniquely identified in an item by their name/value combination. For example, a single item can have the attributes { "first_name", "first_value" }
and { "first_name", second_value" }
. However, it cannot have two attribute instances where both the Attribute.X.Name
and Attribute.X.Value
are the same.
Optionally, the requestor can supply the Replace
parameter for each individual attribute. Setting this value to true
causes the new attribute value to replace the existing attribute value(s). For example, if an item has the attributes { 'a', '1' }
,
{ 'b', '2'}
and { 'b', '3' }
and the requestor calls PutAttributes
using the attributes { 'b', '4' }
with the Replace
parameter set to true, the final attributes of the item are changed to { 'a', '1' }
and { 'b', '4' }
, which replaces the previous values of the 'b' attribute with the new value.
NOTE: Using PutAttributes to replace attribute values that do not exist will not result in an error response.
You cannot specify an empty string as an attribute name.
Because Amazon SimpleDB makes multiple copies of client data and uses an eventual consistency update model, an immediate GetAttributes or Select operation (read) immediately after a DeleteAttributes operation (write) might not return the updated data.
The following limitations are enforced for this operation:
10 GB of total user data storage per domain
| putAttributesRequest | Container for the necessary parameters to execute the PutAttributes service method on AmazonSimpleDB. |
| SimpleDBInvalidParameterValueException | ||
| SimpleDBNumberDomainBytesExceededException | ||
| SimpleDBNumberDomainAttributesExceededException | ||
| SimpleDBNoSuchDomainException | ||
| SimpleDBNumberItemAttributesExceededException | ||
| SimpleDBAttributeDoesNotExistException | ||
| SimpleDBMissingParameterException | ||
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |
| - (SimpleDBSelectResponse * AmazonSimpleDBClient.)select: | (SimpleDBSelectRequest *) | selectRequest |
The Select
operation returns a set of attributes for ItemNames
that match the select expression. Select
is similar to the standard SQL SELECT statement.
The total size of the response cannot exceed 1 MB in total size. Amazon SimpleDB automatically adjusts the number of items returned per page to enforce this limit. For example, if the client asks to retrieve 2500 items, but each individual item is 10 kB in size, the system returns 100 items and an appropriate NextToken
so the client can access the next page of results.
For information on how to construct select expressions, see Using Select to Create Amazon SimpleDB Queries in the Developer Guide.
| selectRequest | Container for the necessary parameters to execute the Select service method on AmazonSimpleDB. |
| SimpleDBInvalidParameterValueException | ||
| SimpleDBInvalidQueryExpressionException | ||
| SimpleDBRequestTimeoutException | ||
| SimpleDBInvalidNumberPredicatesException | ||
| SimpleDBNoSuchDomainException | ||
| SimpleDBInvalidNextTokenException | ||
| SimpleDBTooManyRequestedAttributesException | ||
| SimpleDBMissingParameterException | ||
| SimpleDBInvalidNumberValueTestsException | ||
| AmazonClientException | If any internal errors are encountered inside the client while attempting to make the request or handle the response. For example if a network connection is not available. | |
| AmazonServiceException | If an error response is returned by AmazonSimpleDB indicating either a problem with the data in the request, or a server side issue. |


My Favorite Places
Continue reading for more information on each of those places:
I love visiting San Diego and have seriously considered moving there!
For more information on San Diego click here!
I head up to Seattle often to take advantage of some of the delicious food.
For more information on Seattle click here!
The coast is a quick drive away; I love heading there for a weekend getaway.
For more information on the Oregon Coast click here!
My in-laws live in and around Bend and I love when we drive over the mountain to enjoy the scenery and activities.
For more information on Bend click here!


@DoNotImplement interface ServiceLifecycleEvent
This is the parent interface for all service lifecycle events. This type is passed in the ServiceLifecycleObserver.onEvent method.
ServiceStart |
This event is dispatched once all corda services have been instantiated and registered as injectable services. interface ServiceStart : ServiceLifecycleEvent |
StateMachineStarted |
This event is dispatched when State Machine is fully started. interface StateMachineStarted : ServiceLifecycleEvent |


Back
Tolerance Area (Tolerance = 100px)
1
2
3
4
5
6
7
Where's the 4th div? Inspect it using the developer's console or firebug. :)


Super Cleaners provide services in cleaning and pest control. Our motto is cleanliness is everything
Click here to get more informationWe Provide Cleaning Services that nobody provide
Do you hate pests? So do we!
Get yourself updated with our external links about how to control pests
Contact us to get quote
Ready to clean your place? That's great! Give us a call or send us an email and we will get back to you as soon as possible!
408 6678 374


ClickTime | www.clicktime.com | Onsite San Francisco | Remote OK for Linux Administrator and DevOps Engineer Roles | Full Time
ABOUT US: We're ClickTime. We help businesses become more productive every day. We're a bootstrapped, profitable, 30-person company going through an exciting stage of growth.
HIRING PROCESS: Two phone interviews, an onsite interview, and reference checks. Most of our interviews also include a practical component (e.g. coding exercise, product demo, Excel exercise, etc) that would reflect your day-to-day work at ClickTime.
ROLES: - Senior Front End (JavaScript) Developer - Application Developer - Linux Administrator (Remote OK) - DevOps Engineer (Remote OK) - Product Manager - Sales Development Representative - Senior Account Manager - Summer 2017 Interns
APPLY: www.clicktime.com/jobs or email sdabby@clicktime.com