|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.webcurator.core.permissionmapping.PermissionMappingStrategy
public abstract class PermissionMappingStrategy
Generic class for the PermissionMappingStrategy. The strategy is used to find Permissions that match seeds. Different implementations may do this in different methods and may support different types of URL Patterns. In version 1.0 of the Web Curator Tool, the WCT uses the HierarchicalPermissionMappingStrategy.
HierarchicalPermissionMappingStrategy
| Constructor Summary | |
|---|---|
PermissionMappingStrategy()
|
| Method Summary | |
|---|---|
abstract void |
add(Permission aPermission,
UrlPattern aUrlPattern)
Add a mapping. |
abstract java.util.Set<Permission> |
getMatchingPermissions(Target aTarget,
Seed aSeed)
Get a Set of permissions that match the seed. |
abstract java.util.Set<Permission> |
getMatchingPermissions(Target aTarget,
java.lang.String aUrl)
Get a Set of permissions that match the URL. |
static PermissionMappingStrategy |
getStrategy()
Get the active Permission Mapping Strategy. |
abstract boolean |
isValidPattern(UrlPattern aUrlPattern)
Check if the URL pattern is acceptable to the strategy. |
abstract boolean |
matches(UrlPattern aUrlPattern,
Seed aSeed)
Check if a given Url Pattern matches a given seed. |
abstract void |
remove(Permission aPermission,
UrlPattern aUrlPattern)
Remove a mapping. |
abstract void |
removeMappings(Site aSite)
Remove all mappings for the site. |
abstract void |
saveMappings(Site aSite)
Save all mappings for a site. |
static void |
setStrategy(PermissionMappingStrategy aStrategy)
Set the strategy. |
| Methods inherited from class java.lang.Object |
|---|
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public PermissionMappingStrategy()
| Method Detail |
|---|
public static void setStrategy(PermissionMappingStrategy aStrategy)
aStrategy
- The strategy to use.public static PermissionMappingStrategy getStrategy()
public abstract void add(Permission aPermission, UrlPattern aUrlPattern)
aPermission
- The permission.aUrlPattern
- The mapping.public abstract void remove(Permission aPermission, UrlPattern aUrlPattern)
aPermission
- The permission.aUrlPattern
- The mapping.public abstract boolean isValidPattern(UrlPattern aUrlPattern)
aUrlPattern
- the url pattern to test.
public abstract java.util.Set<Permission> getMatchingPermissions(Target aTarget, Seed aSeed)
aSeed
- The seed to match.aTarget
- the target to match for.
public abstract java.util.Set<Permission> getMatchingPermissions(Target aTarget, java.lang.String aUrl)
aUrl
- The URL to match.aTarget
- the target to match for.
public abstract boolean matches(UrlPattern aUrlPattern, Seed aSeed)
aUrlPattern
- The URL Pattern.aSeed
- The seed.
public abstract void removeMappings(Site aSite)
aSite
- The site to remove mappings for.public abstract void saveMappings(Site aSite)
aSite
- The site to save mappings for.
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


| Fig. 4 |
Examples of commonly observed caribou movements in the vicin ... |
| Fig. 5 |
( a) Movement rates and ( b) turning angles of migratory car ... |
| Fig. 2 |
Proportion of ice and water on the largest water bodies used ... |
| Fig. 6 |
Relationship between ( a) advance in breakup or ( b) delay i ... |
| Fig. 3 |
Trends in thawing and freezing dates for the largest water b ... |
| Fig. 1 |
Study area in Northern Québec showing the range of the Riviè ... |


Juan Pablo Gonzalez P.
Spanish
English
French
Web Developer
& Designer
Download my
resume
here.
Contact me at
jp.gonzalez14@icloud.com


|
Basic
|
[[${salaryHistory.basic}]]
|
|
House Rent Allowance
|
[[${salaryHistory.hra}]]
|
|
Conveyance Allowance
|
[[${salaryHistory.conveyence}]]
|
|
Medical Allowance
|
[[${salaryHistory.medicalAllowance}]]
|
|
Gratuity
|
[[${salaryHistory.telephoneAllowance}]]
|
|
Night Shift Allowance
|
[[${salaryHistory.internetAllowance}]]
|
|
Travel Allowance
|
[[${salaryHistory.uniformAllowance}]]
|
|
Special Allowance
|
[[${salaryHistory.specialAllowance}]]
|
|
Performance Linked Pay
|
[[${salaryHistory.performanceLinkedPay}]]
|
|
Bonus
|
[[${salaryHistory.bonus}]]
|
|
Other Allowance
|
[[${salaryHistory.otherAllowance}]]
|
|
Performance Incentive
|
[[${salaryHistory.performanceIncentives}]]
|


We're sorry but qrcode2stl doesn't work properly without JavaScript enabled. Please enable it to continue.


An API of Ice And Fire is the world's greatest source for quantified and structured data from the universe of Ice and Fire (and the HBO series Game of Thrones). This App displays and parses all the data provided by the api in a structured and beautiful way.


Next generation digital banking Take your financial life online. Your
Easybank account will be a one-stop-shop for spending, saving, budgeting,
investing, and much more. Request Invite Why choose Easybank? We leverage
Open Banking to turn your bank account into your financial hub. Control your
finances like never before. Online Banking Our modern web and mobile
applications allow you to keep track of your finances wherever you are in
the world. Simple Budgeting See exactly where your money goes each month.
Receive notifications when you’re close to hitting your limits. Fast
Onboarding We don’t do branches. Open your account in minutes online and
start taking control of your finances right away. Open API Manage your
savings, investments, pension, and much more from one account. Tracking your
money has never been easier. Latest Articles By Claire Robinson Receive
money in any currency with no fees The world is getting smaller and we’re
becoming more mobile. So why should you be forced to only receive money in a
single … By Wilson Hutton Treat yourself without worrying about money Our
simple budgeting feature allows you to separate out your spending and set
realistic limits each month. That means you …  This is why
we don’t charge any fees on purchases while you’re abroad. We’ll even show
you … By Claire Robinson Our invite-only Beta accounts are now live! After a
lot of hard work by the whole team, we’re excited to launch our closed beta.
It’s easy to request an invite through the site ... About Us Contact Blog
Careers Support Privacy Policy Request Invite © Easybank. All Rights
Reserved


bootlegNinja.space
This is my blog of my adventures learning to build websites using Hugo and a few other tools.
By day I work as an executive recruiter in the banking and financial services sector. By night I am an avid coding enthusiast. My name is Andy and I am using this blog as a catalog of the things I'm learning. I really enjoy learning how to code, and have been learning for over 5 years. As the years have gone by, I've learned many different languages and techniques.
I started learning VBA as a way to make my old work easier many, many years ago. My interest and motivation has been a little up and down through the years and I have studyied quite a few different courses, including freecodecamp and Codecademy as well as several other online resources.
Most recently I've been teaching myself Python and have written many simple Python scripts to make my life easier. I've also been designing and hosting a few websites using WordPress and the Divi theme. WordPress is a good tool, but I didn't feel that I was able to increase my programming skills much by using it. I've recently decided I want to increase my skillset, and learn more about front-end web design, so I've been playing around with a few static site generators and CMS systems as well as different ways to get the pages online.
This blog is going to be my way of documenting what I'm doing. I'm using GitHub along with Atom IDE, ZEIT Now and Hugo at the same time to create this site. It's very different to WordPress, but I'm really enjoying it so far. I hope what I find out becomes useful for some people.
Github Gitlab Twitter Dev.to


VuePeople is being updated please try again later
You can check the status of the build here:
CircleCi


comm - A remote communication facility for Tcl (8.5 and later)
The comm command provides an inter-interpreter remote execution facility much like Tk's send(n), except that it uses sockets rather than the X server for the communication path. As a result, comm works with multiple interpreters, works on Windows and Macintosh systems, and provides control over the remote execution path.
These commands work just like send and winfo interps :
::comm::comm send ?-async? id cmd ?arg arg ...? ::comm::comm interps
This is all that is really needed to know in order to use comm
The package initializes ::comm::comm as the default chan.
comm names communication endpoints with an id unique to each machine. Before sending commands, the id of another interpreter is needed. Unlike Tk's send, comm doesn't implicitly know the id's of all the interpreters on the system. The following four methods make up the basic comm interface.
This invokes the given command in the interpreter named by id. The command waits for the result and remote errors are returned unless the -async or -command option is given. If -async is given, send returns immediately and there is no further notification of result. If -command is used, callback specifies a command to invoke when the result is received. These options are mutually exclusive. The callback will receive arguments in the form -option value, suitable for array set. The options are: -id, the comm id of the interpreter that received the command; -serial, a unique serial for each command sent to a particular comm interpreter; -chan, the comm channel name; -code, the result code of the command; -errorcode, the errorcode, if any, of the command; -errorinfo, the errorinfo, if any, of the command; and -result, the return value of the command. If connection is lost before a reply is received, the callback will be invoked with a connection lost message with -code equal to -1. When -command is used, the command returns the unique serial for the command.
Returns the id for this channel.
Returns a list of all the remote id's to which this channel is connected. comm learns a new remote id when a command is first issued it, or when a remote id first issues a command to this comm channel. ::comm::comm ids is an alias for this method.
Whereas ::comm::comm send will automatically connect to the given id, this forces a connection to a remote id without sending a command. After this, the remote id will appear in ::comm::comm interps.
The evaluation semantics of ::comm::comm send are intended to match Tk's send exactly. This means that comm evaluates arguments on the remote side.
If you find that ::comm::comm send doesn't work for a particular command, try the same thing with Tk's send and see if the result is different. If there is a problem, please report it. For instance, there was had one report that this command produced an error. Note that the equivalent send command also produces the same error.
% ::comm::comm send id llength {a b c} wrong # args: should be "llength list" % send name llength {a b c} wrong # args: should be "llength list"
The eval hook (described below) can be used to change from send's double eval semantics to single eval semantics.
More than one comm channel (or listener) can be created in each Tcl interpreter. This allows flexibility to create full and restricted channels. For instance, hook scripts are specific to the channel they are defined against.
This creates a new channel and Tcl command with the given channel name. This new command controls the new channel and takes all the same arguments as ::comm::comm. Any remaining arguments are passed to the config method. The fully qualified channel name is returned.
This lists all the channels allocated in this Tcl interpreter.
The default configuration parameters for a new channel are:
"-port 0 -local 1 -listen 0 -silent 0"
The default channel ::comm::comm is created with:
"::comm::comm new ::comm::comm -port 0 -local 1 -listen 1 -silent 0"
The config method acts similar to fconfigure in that it sets or queries configuration variables associated with a channel.
When given no arguments, config returns a list of all variables and their value With one argument, config returns the value of just that argument. With an even number of arguments, the given variables are set to the given values.
These configuration variables can be changed (descriptions of them are elsewhere in this manual page):
These configuration variables are read only:
When config changes the parameters of an existing channel (with the exception of -interp and -events), it closes and reopens the listening socket. An automatically assigned channel id will change when this happens. Recycling the socket is done by invoking ::comm::comm abort, which causes all active sends to terminate.
comm uses a TCP port for endpoint id. The interps (or ids) method merely lists all the TCP ports to which the channel is connected. By default, each channel's id is randomly assigned by the operating system (but usually starts at a low value around 1024 and increases each time a new socket is opened). This behavior is accomplished by giving the -port config option a value of 0. Alternately, a specific TCP port number may be provided for a given channel. As a special case, comm contains code to allocate a a high-numbered TCP port (>10000) by using -port {}. Note that a channel won't be created and initialized unless the specific port can be allocated.
As a special case, if the channel is configured with -listen 0, then it will not create a listening socket and will use an id of 0 for itself. Such a channel is only good for outgoing connections (although once a connection is established, it can carry send traffic in both directions). As another special case, if the channel is configured with -silent 0, then the listening side will ignore connection attempts where the protocol negotiation phase failed, instead of throwing an error.
A communication channel in its default configuration will use the current interpreter for the execution of all received scripts, and of the event scripts associated with the various hooks.
This insecure setup can be changed by the user via the two options -interp, and -events.
When -interp is set all received scripts are executed in the slave interpreter specified as the value of the option. This interpreter is expected to exist before configuration. I.e. it is the responsibility of the user to create it. However afterward the communication channel takes ownership of this interpreter, and will destroy it when the communication channel is destroyed. Note that reconfiguration of the communication channel to either a different interpreter or the empty string will release the ownership without destroying the previously configured interpreter. The empty string has a special meaning, it restores the default behaviour of executing received scripts in the current interpreter.
Also of note is that replies and callbacks (a special form of reply) are not considered as received scripts. They are trusted, part of the internal machinery of comm, and therefore always executed in the current interpreter.
Even if an interpreter has been configured as the execution environment for received scripts the event scripts associated with the various hooks will by default still be executed in the current interpreter. To change this use the option -events to declare a list of the events whose scripts should be executed in the declared interpreter as well. The contents of this option are ignored if the communication channel is configured to execute received scripts in the current interpreter.
By default, each channel is restricted to accepting connections from the local system. This can be overridden by using the -local 0 configuration option For such channels, the id parameter takes the form { id host }.
WARNING: The host must always be specified in the same form (e.g., as either a fully qualified domain name, plain hostname or an IP address).
These methods give control over closing connections:
This closes the connection to id, aborting all outstanding commands in progress. Note that nothing prevents the connection from being immediately reopened by another incoming or outgoing command.
This invokes shutdown on all open connections in this comm channel.
This aborts all connections and then destroys the this comm channel itself, including closing the listening socket. Special code allows the default ::comm::comm channel to be closed such that the ::comm::comm command it is not destroyed. Doing so closes the listening socket, preventing both incoming and outgoing commands on the channel. This sequence reinitializes the default channel:
"::comm::comm destroy; ::comm::comm new ::comm::comm"
When a remote connection is lost (because the remote exited or called shutdown), comm can invoke an application callback. This can be used to cleanup or restart an ancillary process, for instance. See the lost callback below.
This is a mechanism for setting hooks for particular events:
This uses a syntax similar to Tk's bind command. Prefixing script with a + causes the new script to be appended. Without this, a new script replaces any existing script. When invoked without a script, no change is made. In all cases, the new hook script is returned by the command.
When an event occurs, the script associated with it is evaluated with the listed variables in scope and available. The return code (not the return value) of the script is commonly used decide how to further process after the hook.
Common variables include:
the name of the comm channel (and command)
the id of the remote in question
the file id for the socket of the connection
These are the defined events:
Variables: chan, id
This hook is invoked before making a connection to the remote named in id. An error return (via error) will abort the connection attempt with the error. Example:
% ::comm::comm hook connecting { if {[string match {*[02468]} $id]} { error "Can't connect to even ids" } } % ::comm::comm send 10000 puts ok Connect to remote failed: Can't connect to even ids %
Variables: chan, fid, id, host, and port.
This hook is invoked immediately after making a remote connection to id, allowing arbitrary authentication over the socket named by fid. An error return (via error ) will close the connection with the error. host and port are merely extracted from the id; changing any of these will have no effect on the connection, however. It is also possible to substitute and replace fid.
Variables: chan, fid, addr, and remport.
Hook invoked when receiving an incoming connection, allowing arbitrary authentication over socket named by fid. An error return (via error) will close the connection with the error. Note that the peer is named by remport and addr but that the remote id is still unknown. Example:
::comm::comm hook incoming { if {[string match <IP_ADDRESS> $addr]} { error "I don't talk to myself" } }
Variables: chan, id, cmd, and buffer.
This hook is invoked after collecting a complete script from a remote but before evaluating it. This allows complete control over the processing of incoming commands. cmd contains either send or async. buffer holds the script to evaluate. At the time the hook is called, $chan remoteid is identical in value to id.
By changing buffer, the hook can change the script to be evaluated. The hook can short circuit evaluation and cause a value to be immediately returned by using return result (or, from within a procedure, return -code return result). An error return (via error) will return an error result, as is if the script caused the error. Any other return will evaluate the script in buffer as normal. For compatibility with 3.2, break and return -code break result is supported, acting similarly to return {} and return -code return result.

This hook is invoked after collecting a complete reply script from a remote but before evaluating it. This allows complete control over the processing of replies to sent commands. The reply buffer is in one of the following forms
return result
return -code code result
return -code code -errorinfo info -errorcode ecode msg
For safety reasons, this is decomposed. The return result is in ret, and the return switches are in the return array:
return(-code)
return(-errorinfo)
return(-errorcode)
Any of these may be the empty string. Modifying these four variables can change the return value, whereas modifying buffer has no effect.
Variables: chan, id, buffer, ret, and return().
Similar to reply, but used for callbacks.
Variables: chan, id, and reason.
This hook is invoked when the connection to id is lost. Return value (or thrown error) is ignored. reason is an explanatory string indicating why the connection was lost. Example:
::comm::comm hook lost { global myvar if {$myvar(id) == $id} { myfunc return } }
These interfaces may change or go away in subsequence releases.
Returns the id of the sender of the last remote command executed on this channel. If used by a proc being invoked remotely, it must be called before any events are processed. Otherwise, another command may get invoked and change the value.
Invoking this procedure will substitute the Tk send and winfo interps commands with these equivalents that use ::comm::comm.
proc send {args} { eval ::comm::comm send $args } rename winfo tk_winfo proc winfo {cmd args} { if {![string match in* $cmd]} { return [eval [list tk_winfo $cmd] $args] } return [::comm::comm interps] }
Starting with version 4.6 of the package an option -socketcmd is supported, allowing the user of a comm channel to specify which command to use when opening a socket. Anything which is API-compatible with the builtin ::socket (the default) can be used.
The envisioned main use is the specification of the tls::socket command, see package tls, to secure the communication.
# Load and initialize tls package require tls tls::init -cafile /path/to/ca/cert -keyfile ... # Create secured comm channel ::comm::comm new SECURE -socketcmd tls::socket -listen 1 ...
The sections Execution Environment and Callbacks are also relevant to the security of the system, providing means to restrict the execution to a specific environment, perform additional authentication, and the like.
There is one outstanding difference between comm and send. When blocking in a synchronous remote command, send uses an internal C hook (Tk_RestrictEvents) to the event loop to look ahead for send-related events and only process those without processing any other events. In contrast, comm uses the vwait command as a semaphore to indicate the return message has arrived. The difference is that a synchronous send will block the application and prevent all events (including window related ones) from being processed, while a synchronous ::comm::comm send will block the application but still allow other events to get processed. In particular, after idle handlers will fire immediately when comm blocks.
What can be done about this? First, note that this behavior will come from any code using vwait to block and wait for an event to occur. At the cost of multiple channel support, comm could be changed to do blocking I/O on the socket, giving send-like blocking semantics. However, multiple channel support is a very useful feature of comm that it is deemed too important to lose. The remaining approaches involve a new loadable module written in C (which is somewhat against the philosophy of comm) One way would be to create a modified version of the vwait command that allow the event flags passed to Tcl_DoOneEvent to be specified. For comm, just the TCL_FILE_EVENTS would be processed. Another way would be to implement a mechanism like Tk_RestrictEvents, but apply it to the Tcl event loop (since comm doesn't require Tk). One of these approaches will be available in a future comm release as an optional component.
By default the result returned by a remotely invoked command is the result sent back to the invoker. This means that the result is generated synchronously, and the server handling the call is blocked for the duration of the command.
While this is tolerable as long as only short-running commands are invoked on the server long-running commands, like database queries make this a problem. One command can prevent the processing requests of all other clients for an arbitrary period of time.
Before version 4.5 of comm the only solution was to rewrite the server command to use the Tcl builtin command vwait, or one of its relatives like tkwait, to open a new event loop which processes requests while the long-running operation is executed. This however has its own perils, as this makes it possible to both overflow the Tcl stack with a large number of event loop, and to have a newer requests block the return of older ones, as the eventloop have to be unwound in the order of their creation.
The proper solution is to have the invoked command indicate to comm that it cannot or will not deliver an immediate, synchronous result, but will do so later. At that point the framework can put sending the actual result on hold and continue processing requests using the main event loop. No blocking, no nesting of event loops. At some future date the long running operation delivers the result to comm, via the future object, which is then forwarded to the invoker as usual.
The necessary support for this solution has been added to comm since version 4.5, in the form of the new method return_async.
This command is used by a remotely invoked script to notify the comm channel which invoked it that the result to send back to the invoker is not generated synchronously. If this command is not called the default/standard behaviour of comm is to send the synchronously generated result of the script itself to the invoker.
The result of return_async is an object. This object, called a future is where the result of the script has to be delivered to when it becomes ready. When that happens it will take all the necessary actions to deliver the result to the invoker of the script, and then destroy itself. Should comm have lost the connection to the invoker while the result is being computed the future will not try to deliver the result it got, but just destroy itself. The future can be configured with a command to call when the invoker is lost. This enables the user to implement an early abort of the long-running operation, should this be supported by it.
An example:
# Procedure invoked by remote clients to run database operations. proc select {sql} { # Signal the async generation of the result set future [::comm::comm return_async] # Generate an async db operation and tell it where to deliver the result. set query [db query -command [list $future return] $sql] # Tell the database system which query to cancel if the connection # goes away while it is running. $future configure -command [list db cancel $query] # Note: The above will work without problem only if the async # query will nover run its completion callback immediately, but # only from the eventloop. Because otherwise the future we wish to # configure may already be gone. If that is possible use 'catch' # to prevent the error from propagating. return }
The API of a future object is:
Use this method to tell the future that long-running operation has completed. Arguments are an optional return value (defaults to the empty string), and the Tcl return code (defaults to OK).
The future will deliver this information to invoker, if the connection was not lost in the meantime, and then destroy itself. If the connection was lost it will do nothing but destroy itself.
These methods allow the user to retrieve and set a command to be called if the connection the future belongs to has been lost.
comm exports itself as a package. The package version number is in the form major . minor, where the major version will only change when a non-compatible change happens to the API or protocol. Minor bug fixes and changes will only affect the minor version. To load comm this command is usually used:
package require comm 3
Note that requiring no version (or a specific version) can also be done.
The revision history of comm includes these releases:
Fixed ticket [ced0d60fc9]. Added proper detection of eof on a socket, properly closing it.
Fixed bugs 2972571 and 3066872, the first a misdetection of quoted brace after double backslash, the other a blocking gets making for an obvious (hinsight) DoS attack on comm channels.
Changed the implementation of comm::commCollect to emulate lindex's pre-Tcl 8 behaviour, i.e. it was given the ability to parse out the first word of a list, even if the whole buffer is not a well-formed list. Without this change the first word could only be extracted if the whole buffer was a well-formed list (ever since Tcl 8), and in a ver-high-load situation, i.e. a server sending lots and/or large commands very fast, this may never happen, eventually crashing the receiver when it runs out of memory. With the change the receiver is always able to process the first word when it becomes well-formed, regardless of the structure of the remainder of the buffer.
Added the option -socketcmd enabling users to override how a socket is opened. The envisioned main use is the specification of the tls::socket command, see package tls, to secure the communication.
Changed handling of ports already in use to provide a proper error message.
Bugfix in the replacement for vwait, made robust against of variable names containing spaces.
Bugfix in the handling of hooks, typo in variable name.
Bugfix in the handling of the result received by the send method. Replaced an after idle unset result with an immediate unset, with the information saved to a local variable.
The after idle can spill into a forked child process if there is no event loop between its setup and the fork. This may bork the child if the next event loop is the vwait of comm's send a few lines above the after idle, and the child used the same serial number for its next request. In that case the parent's after idle unset will delete the very array element the child is waiting for, unlocking the vwait, causing it to access a now missing array element, instead of the expected result.
Bugfixes in the wrappers for the builtin update and vwait commands.
Bugfix in the wrapper for the builtin update command.
Bugfixes in the handling of -interp for regular scripts. The handling of the buffer was wrong for scripts which are a single statement as list. Fixed missing argument to new command commSendReply, introduced by version 4.5. Affected debugging.
New server-side feature. The command invoked on the server can now switch comm from the standard synchronous return of its result to an asynchronous (defered) return. Due to the use of snit to implement the future objects used by this feature from this version on comm requires at least Tcl 8.3 to run. Please read the section Asynchronous Result Generation for more details.
Bugfix in the execution of hooks.
Bugfixes in the handling of -interp for regular and hook scripts. Bugfixes in channel cleanup.
Introduced -interp and -events to enable easy use of a slave interp for execution of received scripts, and of event scripts.
Bugfixes, and introduces -silent to allow the user to force the server/listening side to silently ignore connection attempts where the protocol negotiation failed.
Bugfixes, and most important, switched to utf-8 as default encoding for full i18n without any problems.
Rewrite of internal code to remove old pseudo-object model. Addition of send -command asynchronous callback option.
Per request by John LoVerso. Improved handling of error for async invoked commands.
Moved into tcllib and placed in a proper namespace.
A bug in the looking up of the remoteid for a executed command could be triggered when the connection was closed while several asynchronous sends were queued to be executed.
Internal change to how reply messages from a send are handled. Reply messages are now decoded into the value to pass to return; a new return statement is then cons'd up to with this value. Previously, the return code was passed in from the remote as a command to evaluate. Since the wire protocol has not changed, this is still the case. Instead, the reply handling code decodes the reply message.
Added more source commentary, as well as documenting config variables in this man page. Fixed bug were loss of connection would give error about a variable named pending rather than the message about the lost connection. comm ids is now an alias for comm interps (previously, it an alias for comm chans). Since the method invocation change of 3.0, break and other exceptional conditions were not being returned correctly from comm send. This has been fixed by removing the extra level of indirection into the internal procedure commSend. Also added propagation of the errorCode variable. This means that these commands return exactly as they would with send:
comm send id break catch {comm send id break} comm send id expr 1 / 0
Added a new hook for reply messages. Reworked method invocation to avoid the use of comm:* procedures; this also cut the invocation time down by 40%. Documented comm config (as this manual page still listed the defunct comm init!)
Some minor bugs were corrected and the documentation was cleaned up. Added some examples for hooks. The return semantics of the eval hook were changed.
A new wire protocol, version 3, was added. This is backwards compatible with version 2 but adds an exchange of supported protocol versions to allow protocol negotiation in the future. Several bugs with the hook implementation were fixed. A new section of the man page on blocking semantics was added.
All the documented hooks were implemented. commLostHook was removed. A bug in comm new was fixed.
This is a new version of comm with several major changes. There is a new way of creating the methods available under the comm command. The comm init method has been retired and is replaced by comm configure which allows access to many of the well-defined internal variables. This also generalizes the options available to comm new. Finally, there is now a protocol version exchanged when a connection is established. This will allow for future on-wire protocol changes. Currently, the protocol version is set to 2.
comm ids was renamed to comm channels. General support for comm hook was fully implemented, but only the lost hook exists, and it was changed to follow the general hook API. commLostHook was unsupported (replaced by comm hook lost) and commLost was removed.
The died hook was renamed lost, to be accessed by commLostHook and an early implementation of comm lost hook. As such, commDied is now commLost.
Unsupported method comm remoteid was added.
comm has been rewritten from scratch (but is fully compatible with Comm 1.0, without the requirement to use obTcl).
This package uses the TLS package to handle the security for https urls and other socket connections.
Policy decisions like the set of protocols to support and what ciphers to use are not the responsibility of TLS, nor of this package itself however. Such decisions are the responsibility of whichever application is using the package, and are likely influenced by the set of servers the application will talk to as well.
For example, in light of the recent POODLE attack discovered by Google many servers will disable support for the SSLv3 protocol. To handle this change the applications using TLS must be patched, and not this package, nor TLS itself. Such a patch may be as simple as generally activating tls1 support, as shown in the example below.
package require tls tls::init -tls1 1 ;# forcibly activate support for the TLS1 protocol ... your own application code ...
Please see the file comm.LICENSE that accompanied this source, or http://www.opengroup.org/www/dist_client/caubweb/COPYRIGHT.free.html.
This license for comm, new as of version 3.2, allows it to be used for free, without any licensing fee or royalty.
If there is a failure initializing a channel created with ::comm::comm new, then the channel should be destroyed. Currently, it is left in an inconsistent state.
There should be a way to force a channel to quiesce when changing the configuration.
The following items can be implemented with the existing hooks and are listed here as a reminder to provide a sample hook in a future version.
Allow easier use of a slave interp for actual command execution (especially when operating in "not local" mode).
Add host list (xhost-like) or "magic cookie" (xauth-like) authentication to initial handshake.
The following are outstanding todo items.
Add an interp discovery and name->port mapping. This is likely to be in a separate, optional nameserver. (See also the related work, below.)
Fix the {id host} form so as not to be dependent upon canonical hostnames. This requires fixes to Tcl to resolve hostnames!
This man page is bigger than the source file.
Tcl7.5 under Windows contains a bug that causes the interpreter to hang when EOF is reached on non-blocking sockets. This can be triggered with a command such as this:
"comm send $other exit"
Always make sure the channel is quiescent before closing/exiting or use at least Tcl7.6 under Windows.
Tcl7.6 on the Mac contains several bugs. It is recommended you use at least Tcl7.6p2.
Tcl8.0 on UNIX contains a socket bug that can crash Tcl. It is recommended you use Tcl8.0p1 (or Tcl7.6p2).
Tcl-DP provides an RPC-based remote execution interface, but is a compiled Tcl extension. See http://www.cs.cornell.edu/Info/Projects/zeno/Projects/Tcl-DP.html.
Michael Doyle<EMAIL_ADDRESS>has code that implements the Tcl-DP RPC interface using standard Tcl sockets, much like comm. The DpTcl package is available at http://chiselapp.com/user/gwlester/repository/DpTcl.
Andreas Kupries<EMAIL_ADDRESS>uses comm and has built a simple nameserver as part of his Pool library. See http://www.purl.org/net/akupries/soft/pool/index.htm.
This document, and the package it describes, will undoubtedly contain bugs and other problems. Please report such in the category comm of the Tcllib Trackers. Please also report any ideas for enhancements you may have for either package and/or documentation.
When proposing code changes, please provide unified diffs, i.e the output of diff -u.
Note further that attachments are strongly preferred over inlined patches. Attachments can be made by going to the Edit form of the ticket immediately after its creation, and then using the left-most button in the secondary navigation bar.
send(n)
comm, communication, ipc, message, remote communication, remote execution, rpc, secure, send, socket, ssl, tls
Programming tools
Copyright © 1995-1998 The Open Group. All Rights Reserved.
Copyright © 2003-2004 ActiveState Corporation.
Copyright © 2006-2009 Andreas Kupries <andreas_kupries@users.sourceforge.net>


Let's get physical: Dead Zebra releases series of sports-themed Android figures
by Corbin DavenportAndrew Bell, the artist behind the company Dead Zebra, has been releasing fun Android-themed figures for years. If you just can't get enough of the little bugdroids, or if you haven't purchased any already (you monster!), the company now has 12 more figures available.
The new 'Activate!' series contains 12 mini figures, available in individual boxes ($12 a pop) or in a complete set ($132). The designs include Baseball, Basketball, Gaming, Boxing, (American) Football, Golf, Hocket, Running, Skateboarding, Soccer, Swimming, and Tennis. As always with Dead Zebra, the designs are pretty great.
You can buy the complete set or individual items at the link below. If you'll excuse me, I need to finish purchasing the gaming figure.
Source:
Dead Zebra


We're sorry but NG Space Company doesn't work properly without JavaScript enabled. Please enable it to continue.


VIPS from C++Using VIPS — How to use the VIPS library from C++ |
VIPS comes with a convenient C++ API. It is a very thin wrapper over the C API and adds automatic reference counting, exceptions, operator overloads, and automatic constant expansion. You can drop down to the C API at any point, so all the C API docs also work for C++.
/* compile with: * g++ -g -Wall try.cc `pkg-config vips-cpp --cflags --libs` */ #include <vips/vips8> using namespace vips; int main( int argc, char **argv ) { GOptionContext *context; GOptionGroup *main_group; GError *error = NULL; if( VIPS_INIT( argv[0] ) ) vips_error_exit( NULL ); context = g_option_context_new( "" ); main_group = g_option_group_new( NULL, NULL, NULL, NULL, NULL ); g_option_context_set_main_group( context, main_group ); g_option_context_add_group( context, vips_get_option_group() ); if( !g_option_context_parse( context, &argc, &argv, &error ) ) { if( error ) { fprintf( stderr, "%s\n", error->message ); g_error_free( error ); } vips_error_exit( NULL ); } VImage in = VImage::new_from_file( argv[1], VImage::option()-> set( "access", VIPS_ACCESS_SEQUENTIAL_UNBUFFERED ) ); double avg = in.avg(); printf( "avg = %g\n", avg ); printf( "width = %d\n", in.width() ); VImage in = VImage::new_from_file( argv[1], VImage::option()-> set( "access", VIPS_ACCESS_SEQUENTIAL_UNBUFFERED ) ); VImage out = in.embed( 10, 10, 1000, 1000, VImage::option()-> set( "extend", "background" )-> set( "background", 128 ) ); out.write_to_file( argv[2] ); vips_shutdown(); return( 0 ); }
Everything before VImage in = VImage::..
is exactly
as the C API. This boilerplate gives the example a set of standard
command-line flags.
This line is the C++ equivalent of vips_image_new_from_file()
. It works
in the same way, the differences being:
VImage
lifetime is managed automatically, like a smart
pointer. You don't need to call g_object_unref()
.
Instead of using varargs and a NULL
-terminated option list, this
function takes an optional VOption
pointer. This
gives a list of name / value pairs for optional arguments to the
function.
In this case we request unbuffered IO for the image, meaning, we expect to do a single top-to-bottom scan of the image and do not need it to be decompressed entirely. You can use the C enum name, as is done in this case, or use a string and have the string looked up. See below.
The function will delete the VOption
pointer for
us when it's finished with it.
Instead of returning NULL
on error, this constructor will
raise a VError
exception.
There are a series of similar constructors which parallel the other
constructors in the C API, see VImage::new_from_memory()
,
VImage::new_from_buffer()
, and VImage::new_matrix()
. There's also
VImage::new_memory()
and VImage::new_temp_file()
, which when written to
with VImage::write()
will create whole images on memory or on disc.
The next line finds the average pixel value, it's the equivalent of the
vips_avg()
function. The differences from the C API are:
VImage::avg()
is a member function: the this
parameter is the first (the only, in this case) input image.
The function returns the first output parameter, in this case the average pixel value. Other return values are via pointer arguments, as in the C API.
Like VImage::new_from_file()
, function raises the
VError
exception on error.
Like VImage::new_from_file()
, extra arguments are passed
via an optional VOption
parameter. There are none
in this case, so the function brackets can be left empty.
All other operations follow the same pattern, for example the C API call
vips_add()
:
int vips_add( VipsImage *left, VipsImage *right, VipsImage **out, ... );
appears in C++ as:
VImage VImage::add( VImage right, VOption *options = 0 );
The next line uses VImage::width()
to get the image width in pixels.
There are similar functions paralleling vips_image_get_format()
and
friends. Use VImage::set()
to set metadata fields, VImage::get_int()
and
c. to fetch metadata.
Next we reload the image. The VImage::avg()
will have scanned the image
and reached the end of the file, we need to scan again for the next
operation. If we'd selected random access mode (the default) in the
original VImage::new_from_file()
, we would not need to reload.
The next line runs vips_embed()
with two optional parameters. The first
sets the value to an enum (here we use a string to set the value, it'll
be looked up in the list of possible enum values, or you can use the
symbols from the C API), the
second sets the value to an int
. The
"background"
parameter is actually a VipsArrayDouble: if you pass an
int
instead, it will be automatically converted to a
one-element array for you. You can pass a
std::vector<double>
too: the utility function
VImage::to_vectorv()
is a convenient way to make one.
Finally, VImage::write_to_file()
will write the new image to the
filesystem. You can add a VOption as a final parameter and set options
for the writer if you wish. Again, the operation will throw a VError
exception on error. The other writers from the C API are also present:
you can write to a memory array, to a formatted image in memory, or to
another image.
The C++ API will automatically turn constants into images in some cases. For example, you can join two images together bandwise (the bandwise join of two RGB images would be a six-band image) with:
VImage rgb = ...; VImage six_band = rgb.bandjoin( rgb );
You can also bandjoin a constant, for example:
VImage rgb_with_alpha = rgb.bandjoin( 255 );
Will add an extra band to an image, with every element in the new band having the value 255. This is quite a general feature. You can use a constant in most places where you can use an image and it will be converted. For example:
VImage a = (a < 128).ifthenelse( 128, a );
Will set every band element of a
less than 128 to 128.
The C++ API includes the usual range of arithmetic operator overloads. You can mix constants, vectors and images freely.
The API overloads []
to be vips_extract_band()
. You can
write:
VImage xyz = VImage::xyz( 256, 256 ) - VImage::to_vectorv( 2, 128.0, 128.0 ); VImage mask = (xyz[0].pow( 2 ) + xyz[1].pow( 2 )).pow( 0.5 ) < 100;
to make a circular mask, for example.
The API overloads ()
to be vips_getpoint()
. You can
write:
VImage xyz = VImage::xyz( 256, 256 ) - VImage::to_vectorv( 2, 128.0, 128.0 ); // this will have the value [0, 0] std::vector<double> point = xyz(128, 128);
VIPS operations which implement several functions with a controlling
enum, such as vips_math()
, are expanded to a set of member functions
named after the enum. For example, the C function:
int vips_math( VipsImage *in, VipsImage **out, VipsOperationMath math, ... );
where VipsOperationMath has the member VIPS_OPERATION_MATH_SIN, has a
C convenience function vips_sin()
:
int vips_sin( VipsImage *in, VipsImage **out, ... );
and a C++ member function VImage::sin()
:
VImage VImage::sin( VOption *options = 0 );
VIPS images can have a lot of metadata attached to them, giving things
like ICC profiles, EXIF data, and so on. You can use the command-line
program vipsheader
with the -a
flag to list
all the fields.
You can read metadata items with the member functions
, get_int()
,
get_double()
and get_string()
. Use
get_blob()
to call get_typeof()
vips_image_get_typeof()
and read the
type of an item. This will return 0 for undefined fields.
const char *VImage::get_string( const char *field ) throw( VError );
You can use the
family of overloaded members to set
metadata, for example:
set()
void VImage::set( const char *field, const char *value );
You can use these functions to manipulate exif metadata, for example:
VImage im = VImage::new_from_file( "x.jpg" ) int orientation = atoi( im.get_string( "exif-ifd0-Orientation" ) ); im.set( "exif-ifd0-Orientation", "2" ); im.write_to_file( "y.jpg" );
The C++ interface comes in two parts. First, VImage8.h
defines a simple layer over GObject for automatic reference counting,
then a generic way to call any vips8 operation with VImage::call()
,
then a few convenience functions, then a set of overloads.
The member function for each operation, for example VImage::add()
, is
generated by a small Python program called gen-operators.py
,
and its companion, gen-operators-h.py
to generate the
headers. If you write a new VIPS operator, you'll need to rerun these
programs to make the new member function.
You can write the wrapper yourself, of course, they are very simple.
The one for VImage::add()
looks like this:
VImage VImage::add(VImage right, VOption *options) { VImage out; call("add" , (options ? options : VImage::option()) -> set("out", &out) -> set("left", *this) -> set("right", right)); return out; }
Where VImage::call()
is the generic call-a-vips8-operation function.


PLANET SICK-BOY: http://www.sick-boy.com "We Put the SIN in Cinema"
>From Small Time Crooks' one-sheet, you might think the film is a kids' movie. It features a shadowy figure munching on a chocolate-chip cookie, while the title seems to be a play on words, with the implication that the `crooks' in question may be diminutive in height. Relax, pedophobiacs – there isn't a child anywhere in Crooks.
Crooks starts off like a modern-day version of The Honeymooners. A dishwashing ex-con named Ray Winkler (Woody Allen) dreams of retiring to Miami, where he wants only to swim and spend time at the dog track. One day, the former stick-up man hatches a plan to rob a Manhattan bank by renting an abandoned pizza parlor on the same block and tunneling into the bank's vault. As Ray sees it, the only thing that stands between him and his big score is his wife Frenchie (Tracey Ullman, Tracey Takes On), a derisive manicurist that becomes immediately suspicious when her husband brings home a box of chocolates before revealing his devious robbery plans. When she hesitates, Ray practically sends her to the moon, Ralph Kramden-style.
Aiding Ray in his attempt to convince Frenchie to go along with his idea are his two friends and cohorts, Tommy (Tony Darrow, Mickey Blue Eyes) and Denny (Michael Rapaport, Deep Blue Sea), who are described as being `so dumb that they never graduated kindergarten because they were drafted.' The three would-be criminals need Frenchie for both her monetary contribution to their scheme, as well as to run the cookie store that will serve as a front while the men burrow toward the bank vault.
Of course, the bank heist doesn't go as planned, and the bumbling burglars instead decide to franchise Sunset Cookies, which has become so popular that they've hired Frenchie's dimwitted cousin May (Primary Colors writer Elaine May). One year later, everyone involved in Sunset is filthy rich and are even interviewed by 60 Minutes' Steve Kroft in a particularly funny segment. All of this takes place in the Crooks first half-hour.
The remaining hour of Crooks focuses on how money affects the Winklers' relationship. Ray despises being rich and longs for his old life back, while Frenchie dives headfirst into Manhattan's high society, despite having horrendous taste in both decorating and fashion (in other words, she turns into Carmella Soprano). Frenchie, a former stripper, also hires an art dealer (Hugh Grant, Mickey Blue Eyes) to teach her to how to become a more proper socialite by escorting her to museums and performance art shows that Ray wouldn't be caught dead attending.
If there's one thing that Allen can do (besides writing fantastically original screenplays), it's eliciting great performances from his actors. In his last film, Sweet & Lowdown, both principal actors (Sean Penn and Samantha Morton) received Oscar nods. Hell, he even made Mira Sorvino an Oscar winner in Mighty Aphrodite. And Crooks is no different - the film features some of the best comedic acting that you will ever see. Period. Crooks is also one of Allen's loudest films, with cinematographer Fei Zhao perfectly capturing just how loud and gaudy Frenchie's taste became once she came into money.
Crooks is Allen's thirty-second directorial effort, and the first he's featured himself in since 1997's Deconstructing Harry. Since then, the sixty-four-year-old has appeared in several unbilled cameos (The Impostors and A Soldier's Daughter Never Cries), provided the voice for an animated film (Antz) and been the subject of a documentary (Wild Man Blues). It's also the second film that the prolific, twenty-time Oscar nominee has released in the last six months.
1:35 - PG for mild adult language
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Examples
get files from working directory
create files in working directory
delete files from working directory
list files in working directory
CGI execution examples
Close this interaction


I am beyond excited to start gSchool. This feels like my golden ticket. I have been trying hard to break into this industry for a while now, and with gSchool's help, I know I am going to finally reach my goal of becoming a software developer. Why is software development my ultimate career choice? Here are a few reasons:
After school, I want to work at a start-up in town for the next few years or longer. In the long term, I could see myself wanting to teach at a program like gSchool or work at a remote company. Also, I would love to get involved with activism groups for women in tech.


back
Please enter your image files.
The supported files are jpeg, gif, png, gd and gd2.
Width pixel
pixel Height pixel
pixel
Width ratio
% Height ratio
%
Area ratio
%
rszim.cgi Ver. 1.001
Copyright(C) 2005,
hidekik.com


Climate Report for Your Project
A dashboard for open-source maintainers to monitor project team dynamics and improve community health.
Overview
Health in Open Source Software Communities
By taking steps to reduce barriers to new contributors
[Steinmacher et al., 2015],
maintainers can create a welcoming culture that attracts more newcomers [Guizani et al 2022] and increases project diversity.
Increasing diversity and inclusion can benefit the health of open-source projects because prior studies show
that projects with more gender and tenure diversity are associated with higher productivity
[Vasilescu et al., 2015; Catolino et al., 2019].
This dashboard was built with open source community health as a top priority to serve the following goals:
Basic stats of team activities in the past week:
Conversations that Need Your Attention
Tip: Researchers have found that excessive review delays, nitpicking, and long wait for review are predictors of negative experiences in the code review process. Blocking a change request can cause unnecessary interpersonal conflict and negative feelings among contributors [Egelman et al., 2020].
Trends in the past 4 weeks:
How big is your community of developers?
Issue Author Stats
Pull Request Author Stats
New Issue Authors
New PR Authors
Tip: New contributors may need some additional support from the project community. In order for an open source project to be sustainable, it’s important to not only attract new contributors, but also retain them.
How was the response?
Issue Response
PR Response
Issue Comments
PR Comments
Tip: If a pull request is coming from an external contributor, try to comment on the PR before closing it. This can be helpful for the author and acknowledges their contribution.
How friendly are the conversations?
Conversation Tone Analysis
Issue conversations
The highest toxicity score* of comments: a
The highest identity attack score* of comments: a
Links to highest potentially problematic comments (threshold: 0.7)*:
Pull request conversations
The highest toxicity score* of comments: a
The highest identity attack score* of comments: a
Links to highest potentially problematic comments (threshold: 0.7)*:
Note: This analysis flags potentially problematic conversations, but it isn’t perfect! These conversations may need further review from maintainers to ensure that they have a friendly tone and follow the code of conduct.
Tip: If you do not already have one, consider creating a code of conduct for your community to promote respectful, productive discussions! Here is a template to get you started: https://www.contributor-covenant.org
* The toxicity score and identity attack score (both with range [0,1]) are calculated by Google's Perspective API.
These attributes can help detect interpersonal conflict
([Egelman et al., 2020], [Raman et al., 2020], and [Qiu et al., 2022]).
Toxicity: A rude, disrespectful, or unreasonable comment that is likely to make people leave a discussion.
Identity Attack: Negative or hateful comments targeting someone because of their identity.
Labels used in conversations created in the past week:
Conversations by Label
Tip: Consider adding issue labels that explicitly highlight starter tasks for new contributors. Labels like “newcomer friendly”, “good first issue”, and "help wanted" can help attract and retain new contributors [Guizani et al., 2022]. These labels will appear in GitHub repository search results.
Comparison to Similar Repositories in the past week:
Comparison metrics
Projects
Notes
Comparison between similar projects can put your project activity in context by helping you understand your project's metrics relative to your peers.
Situating a project within its particular ecosystem can help open-source maintainers understand project health and sustainability
[Goggins et al., 2021].
Prior Research Results:
Features that Affect Project Attractiveness
Project attractiveness affects which open-source projects developers choose to contribute to. Some features that developers consider may include [Qiu et al., 2019]:
| Features | Explanation |
|---|---|
Activity level
|
Recent commits signal that the project is still active |
Scaffolding
|
Project infrastructure such as labels and templates for issues and pull requests can help contributors navigate the project. |
README file
|
A comprehensive README should be organized into clear sections and include a project description, goals, contributing guidelines, and community contact information. |
Inclusive Language
|
Language used in the docs, code of conduct, and conversations for issues and pull requests can impact contributors’ impressions of the project. |
Methods
This dashboard was created by members of the STRUDEL and CoEx labs at the Carnegie Mellon University School of Computer Science. It uses publicly accessible data retrieved from the GitHub REST API, including data on activity, contributions, and authors relevant to the project.
We use Google’s Perspective API to identify potentially abusive or “toxic” comments with machine learning models.
References
- Egelman, C. D., Murphy-Hill, E., Kammer, E., Hodges, M. M., Green, C., Jaspan, C., & Lin, J. (2020, October). Predicting developers' negative feelings about code review. In 2020 IEEE/ACM 42nd International Conference on Software Engineering (ICSE) (pp. 174-185). IEEE. [Link]
- Goggins, S., Lumbard, K., & Germonprez, M. (2021, May). Open source community health: Analytical metrics and their corresponding narratives. In 2021 IEEE/ACM 4th International Workshop on Software Health in Projects, Ecosystems and Communities (SoHeal) (pp. 25-33). IEEE. [Link]
- Guizani, M., Zimmermann, T., Sarma, A., & Ford, D. (2022). Attracting and Retaining OSS Contributors with a Maintainer Dashboard. arXiv preprint arXiv:2202.07740. [Link]
- Miller, C., Cohen, S., Klug, D., Vasilescu, B., & Kästner, C. (2022). “Did You Miss My Comment or What?” Understanding Toxicity in Open Source Discussions. 44th International Conference on Software Engineering (ICSE'22). [Link]
- Qiu, H. S., Li, Y. L., Padala, S., Sarma, A., & Vasilescu, B. (2019). The signals that potential contributors look for when choosing open-source projects. Proceedings of the ACM on Human-Computer Interaction, 3(CSCW), 1-29. [Link]
- Qiu, H. S., Nolte, A., Brown, A., Serebrenik, A., & Vasilescu, B. (2019b). Going Farther Together: The Impact of Social Capital on Sustained Participation in Open Source. IEEE/ACM 41st International Conference on Software Engineering (ICSE), 2019, pp. 688-699, doi: 10.1109/ICSE.2019.00078. [Link]
- Qiu, H. S., Vasilescu, B., Kästner, C., Egelman, C., Jaspan, C., & Murphy-Hill, E. (2022). Detecting Interpersonal Conflict in Issues and Code Review: Cross Pollinating Open-and Closed-Source Approaches. 2022 IEEE/ACM 44th International Conference on Software Engineering: Software Engineering in Society (ICSE-SEIS) (pp. 41-55). IEEE. [Link]
- Raman, N., Cao, M., Tsvetkov, Y., Kästner, C., & Vasilescu, B. (2020). Stress and burnout in open source: Toward finding, understanding, and mitigating unhealthy interactions. Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering: New Ideas and Emerging Results (pp. 57-60). [Link]
- Steinmacher, I., Conte, T., Gerosa, M. A., & Redmiles, D. (2015). Social barriers faced by newcomers placing their first contribution in open source software projects. Proceedings of the 18th ACM conference on Computer supported cooperative work & social computing (pp. 1379-1392). [Link]


plotTrajectory.Rd
This function will plot a trajectory that was created onto an embedding.
plotTrajectory(ArchRProj = NULL, embedding = "UMAP", trajectory = "Trajectory", colorBy = "colData", name = "Trajectory", log2Norm = NULL, imputeWeights = NULL, pal = NULL, size = 0.5, rastr = TRUE, quantCut = c(0.05, 0.95), quantHex = 0.5, discreteSet = NULL, continuousSet = NULL, randomize = TRUE, keepAxis = FALSE, baseSize = 6, addArrow = TRUE, plotAs = NULL, plotParams = list(), ...)
| ArchRProj | An |
|---|---|
| embedding | The name of the embedding to use to visualize the given |
| trajectory | The column name in |
| colorBy | A string indicating whether points in the plot should be colored by a column in |
| name | The name of the column in |
| log2Norm | A boolean value indicating whether a log2 transformation should be performed on the values from |
| imputeWeights | The weights to be used for imputing numerical values for each cell as a linear combination of other cells values. See |
| pal | The name of a custom palette from |
| size | A number indicating the size of the points to plot if |
| rastr | A boolean value that indicates whether the plot should be rasterized. This does not rasterize lines and labels, just the internal portions of the plot. |
| quantCut | If this is not |
| quantHex | The xth quantile of all dots within each individual hexagon will determine the the numerical value for coloring to be displayed. This occurs when |
| discreteSet | The name of a discrete palette from |
| continuousSet | The name of a continuous palette from |
| randomize | A boolean value that indicates whether to randomize points prior to plotting to prevent cells from one cluster being present at the front of the plot. |
| keepAxis | A boolean value that indicates whether the x and y axis ticks and labels should be plotted. |
| baseSize | The base font size to use in the plot. |
| addArrow | A boolean value that indicates whether to add a smoothed arrow in the embedding based on the aligned trajectory. |
| plotAs | A string that indicates whether points ("points") should be plotted or a hexplot ("hex") should be plotted. By default if |
| plotParams | |
| ... | additional args |


Source code for test.test_mongo.test_item
import pytest
# Item inside db
<EMAIL_ADDRESS>@pytest.mark.existent_item
def test_item(client):
"""
Test to get the elements martching the criteria. The user has to specify the requested name of the elements and the test case check that returns a list with all the elements that match the requested criteria
"""
rv = client.get("/items/name/Aged Brie")
assert rv.data in b'[{"_id":"111111","name":"Aged Brie","quality":0,"sell_in":2}]\n'
assert rv.status_code == 200
# Request without Item Name
<EMAIL_ADDRESS>@pytest.mark.non_name
def test_nonItemName(client):
"""
Test to get an element without name. If an element from the data base has been request but has not specified the name it will return a message giving information to the user explaining that to get an element from de db has to specify the name of the requested element
"""
rv = client.get("/items/name/<name>")
assert rv.status_code == 404
assert rv.data in b'{"message": "The name of the item is required"}\n'
# Item that doesn't exist in the DB
<EMAIL_ADDRESS>@pytest.mark.non_item
def test_nonItem(client):
"""
Test to get an element from the data base that doen't exist or doesn't axist anymore. In case the request element it can't be found isnide the db will display a message giving information to the user explainig that the requested element it can't be found isnide the db
"""
rv = client.get("/items/name/Non existent")
assert rv.status_code == 404
assert (
rv.data
in b'{"message": "Sorry, right now we are out of stock of the item Non existent comeback later and try again"}\n'
)


Please check them out, or view my RESUME for more details
50 Words Everyday
Course Scheduler
ZhiClasses
U.Start
Flappy Bird Clone
<-- Scroll to view more -->


See: Description
| Exception | Description |
|---|---|
| InfoTraderParserException |
An exception thrown by the parser indicating inability to deal with the input
file
|
| InfoTraderValidationException |
An exception indicating that the process of validation failed.
|
| InfoTraderWriterException |
A base exception class for when the GedcomWriter fails
|
| InfoTraderWriterVersionDataMismatchException |
Represents a mismatch between the data being written and the GEDCOM version under which it's supposed to be written...
|
| ParserCancelledException |
Exception indicating that the file load/parse operation was cancelled
|
| UnsupportedInfoTraderCharsetException |
Represents an unsupported/illegal value for a charset encoding in a GEDCOM file
|
| UnsupportedVersionException |
An exception for when an unsupported GEDCOM version is used
|
| WriterCancelledException |
Exception indicating that the file construction and writing operation was cancelled
|


Instructions
Of the shown items, click the one you are most likely to purchase.
Once you've made 25 selections we will show you the results!


Starting with ngx-extended-pdf-viewer 5.0 (and pdf.js 2.6), PDF files with forms are supported.
Configuration:
If you're using the default options, you don't have to do anything to activate the feature. If
you're using custom options, make sure to activate the setting renderInteractiveForms: true
.
You can use the two-way binding attribute `[(formData)]` to fill the form in the PDF or to get the user input from the PDF. The event `(formData)` reports every input field, even if `[formData]` passes only a small selection of these field. You can use this to find out how the field names are called in the PDF file, so you can map them to your naming conventions if you don't have the opportunity to talk to the creator of the PDF file.
You can access low-level form data using NgxExtendedPdfViewerService.getFormData().
Caveat: The API is subject to change.
| Name | Coordinates (0, 0) = bottom left |
Json (a small selection) |
| {{field.fieldName}} | {{field.rect}} | {{field | json}} |
You can download the PDF file as a BLOB. The user can fill the PDF form, and you can download the file containing the user's input.
{{downloaded}}


Navigate to master branch.

Stage your changes for commit.
git add file_name
Save changes.
git commit -m "commit message"
Send changes to GitHub.
git push origin branch_name
Merge changes on GitHub
Checkout master branch.
git checkout master
Update local master branch.
git pull origin master
Confirm that the local repository has been properly updated and the changes have been saved.
Delete the old feature branch.
git branch -d branch_name


Riemann Sums June 20, 2015 Riemann sums are one of the first things learned when beginning the study of integration. Yet often they are presented as a theoretical underpinning and then quickly forgotten as the *rules* of integration are hammered into memory. While they do not allow for easy computation of integrals, they are an excellent glimpse into the nature of the integral. First we will consider a straight line with equation $f(x) = sx$, a straight line with slope $s$. We can plot it as shown in the following figure. You can play around with the slope by moving the slider.
So now we want to *integrate* this simple function, but what does that mean? If we look up integrate on google, we get > #### integrate > combine one thing with another so that they become whole. So it appears we want to do some sort of combining or adding. To proceed, we must first define the problem which we are trying to solve. Informally, we can state this as > Given a function $f(x)$ find the area of the region, $R$ in the x-y plane subject to the following conditions > > * $R$ is always between $f(x)$ and the $x$-axis > * The area above the $x$-axis is positive and the area below is negative > * $R$ is bounded by the vertial lines $x=a$ and $x=b$. Those who have studied some calculus recognize that we can state this problem without the last condition, although without the last condition, our problem is not to compute the area of $R$, but rather to find a function which represents the area of $R$. For now, we will assume all the conditions. If we go back to our example of a line, and let $a=-5,b=5$, then we can write our statement of the problem as $$ R = \int_a^b f(x)\,dx.$$ The curly sign simply means we want to find all the area and the function is any one we choose, in this case $f(x) =s x$. However, at this point you may be bothered by the $dx$ at the end. $dx$ is not technically a number, but we can think of it as the limit of one. For now, we will say that it is some sort of distance along the $x$-axis, we will develop understanding of its nature through the Riemann sum. The plot below shows the problem we are trying to solve where $R$ is the blue region minus the red region. Again you can move the slider to see how the region changes. For this specific case, the region is always composed of two right triangular regions, one red, one blue. We can use the formula for the area of a triangle which is $$ A = \frac{ h \times b}{2},$$ where $h$ is the height and $b$ is the base of the triangle (not to be confused with $b$ the right bound of integration), to compute this area. For both regions, we know that the base of the triangle is $b=5$. The height for the blue side is $f(5)=5s$ and the height for the red side is $f(-5)= -5s$. So the region is given as $$R=A\_{blue}-A\_{red} = \frac{25s}{2}-\frac{25s}{2}=0,$$ so in this case, the solution to the integral problem is zero. Lets take a moment and see if this is surprising. We know that the function $f(x)=sx$ is anti-symmetric with respect to reflection over the $y$ axis in the sense that $f(x) = -f(-x)$. So it makes sense if we take any region where $a=-b$, then the areas will always exactly cancel each other out. However, if $a\neq -b$, then we will get a non-zero answer. It is easy enough to do this problem for general $a$ and $b$, which is given as $$ R = \frac{sb^2}{2}-\frac{sa^2}{2},$$ make sure you understand how to get to this formula before you continue. The following app illustrates allows you to change the slope, $a$, and $b$, and will compute the slope. Notice that in this easy case, we are able to get by just knowing about triangles. However, we have discovered one, very essential detail, **We can solve the problem by breaking it into pieces**. In the previous case, these pieces were two triangles and we were able to get an exact answer, but now we will on to more complicated function where this will not be sufficent to get an exact answer. Let us consider the slightly more complicated function $$ f(x) = \sin(x) + \frac{x}{8},$$ which is shown in the plot below. We can see that triangles don't really make sense, so we choose to use the simplest shape we can, a rectangle. The following will get slightly technical, but the basic idea is that we will divide the range we want to integrate over into equally spaced regions $\Delta x$. We will then approximate the curve in each region by a rectange and add them up. As we make $\Delta x$ smaller, we will achieve a better approximation to the integral. In the limit that $\Delta x \to 0$, we have solved our problem. More formally, divide the interval $[a,b]$ into $n$ subintervals, which all have equal length $\Delta x$ given as $$\Delta x = \frac{b-a}{n}.$$ This is usually referred to as a *parition* of the interval. We can write out the elements of the partition as $$ P = \{a,a+\Delta x, a + 2\Delta x,\dots,a + (n-1)\Delta x, b\}.$$ We can then define the left Riemann sum as the approximation where we take the value of the function at the left of each element of the parition and create a rectange with one side $f(p_i)$ and the other side $\Delta x$. So we then form the Left Riemann sum $$ S = \sum\_{i=1}^n f(x\_{i-1})(x\_i-x\_{i-1}).$$ If we replace $f(x\_{i-1})$ with $f(x\_{i})$ in this expression, we get the right Riemann sum. In principle, we could use any value $f(x^*)$ with the caveat that $$ x\_{i-1}\leq x^* \leq x\_{i}.$$ For our specific example, then app, shows this formalism applied to our function. The lower right plot shows the dependance of the sum on $n$, where $n$ is the number of partitions. Notice that the Left and Right Riemann sums are not in general equal, however, they approach each other, as well as the correct answer as $n$ gets large. In the limit that $\Delta x \to 0$,($n \to \infty$), for a properly *behaved* function, this converges to the integral. The exact details of this are quite complicated and if you are interested, I point you to the Real Analysis notes in the Notes section of this website which have a much more rigourous derivation. We are now ready to say that $dx$ is an infinitly small segment of the real line. Integration is the act of adding infinitesimally narrow rectangles together to find the area of the curve. Although outside the scope of this post, we could use the fundamnetal theorem of calculus to compute that $$ \int_a^b \sin(x) + \frac{x}{8} = \left(-\cos(b)+\frac{b^2}{16}\right)-\left(-\cos(a)+\frac{a^2}{16}\right),$$ which answers the question of integration for this function. #import necessary packages import numpy as np import matplotlib.pyplot as plt from scipy.integrate import quad %matplotlib inline def Riemann_left(func,a,b,n): """Calculate the Riemann left sum for function func in region (a,b) with partition number n, an integer""" dx = (b-a)/n x = np.linspace(a,b-dx,n) # make a vector of points to evaluate sum on y = func(x) #evaluate x on each of these points return np.sum(y * dx) #sum the list of the points evaluated def Riemann_right(func,a,b,n): """Calculate the Riemann right sum for function func in region (a,b) with partition number n, an integer""" dx = (b-a)/n x = np.linspace(a+dx,b,n) y = func(x) return np.sum(y * dx) #now for an actual numerical integration routine def num_integrate(func,a,b): result = quad(lambda x: func(x), a, b) return result[0] def plot_sums(func,n,a,b,ax): """function plot sums for a function, given a function, an axis,a,b, and list of n""" #calculate the Riemann sums for each element of n sums_left = [Riemann_left(func,a,b,i) for i in n] sums_right = [Riemann_right(func,a,b,i) for i in n] num_ans = num_integrate(func,a,b) sums_ac = [num_ans for i in n] #generate function plot x = np.linspace(a,b,100) ax[0].plot(x,func(x)) ax[1].plot(n,sums_left,label= 'Left') ax[1].plot(n,sums_right, label = 'Right') ax[1].plot(n,sums_ac, label = 'Numerical') ax[1].legend() #define our function def func(x): return np.cos(x) - x/8 #define a and b a = -10 b = 10 n = [i for i in range(1,30)] #define axis for plotting fig, ax = plt.subplots(2,1) plot_sums(func,n,a,b,ax) ax[0].set_xlabel('x') ax[1].set_xlabel('n') ax[0].set_ylabel('f(x)') ax[1].set_ylabel('Approximate Integral') plt.tight_layout() ![png](/Images/RiemannSums_files/RiemannSums_3_0.png)


Qpid Proton 0.19.0 Release Notes
Proton is a high-performance, lightweight messaging library. More
about Qpid Proton.
For more information about this release, including download links and
documentation, see the release overview.
Note: This release contains the initial release of a new Ruby messaging API. The interfaces in this API are subject to change. We plan to take user feedback and make any resulting API changes in upcoming releases.
Some of the Proton bindings have been unmaintained for some time. We are deprecating them with this release, and we plan to remove them in an upcoming release. The deprecated bindings are JavaScript, Node.js, PHP, and Perl.
In addition, the Messenger API (in any binding) is now deprecated. We encourage you to use the newer reactive APIs instead.
New features and improvements
- PROTON-869 - [proton-c] should be straightforward to associate handlers with acceptors
- PROTON-1064 - ruby: native IO based on connection_driver.c
- PROTON-1429 - [go] Support marshaling and unmarshaling to/from the timestamp AMQP type in message body
- PROTON-1430 - [go] Support marshaling and unmarshaling to/from the uuid AMQP type in message body
- PROTON-1432 - [go] Support marshaling and unmarshaling to/from the char AMQP type in message body
- PROTON-1549 - Document legal values for the reconnect parameter
- PROTON-1651 - Correct spelling errors
- PROTON-1654 - Windows build does not compile the examples that require C++11
- PROTON-1670 - Configurable TLS versions
- PROTON-1678 - [cpp] Enable setting link names
- PROTON-1680 - [python] Handle various string inputs for allowed SASL mechanisms and add docs
- PROTON-1681 - [cpp] access to terminus capabilities
- PROTON-1684 - Change build for updated minimum tool versions
- PROTON-1687 - Improve efficiency of the transport output buffer
- PROTON-1693 - [ruby] Replace C-reactor based code with new Container
- PROTON-1702 - Fix epoll proactor listener for rearming and overflow per socket
- PROTON-1707 - Remove extraneous directories in C++ binding source
- PROTON-1713 - Various doc fixes
Bugs fixed
- PROTON-1079 - Ruby Reactor interface fails with SSL.new ArgumentError
- PROTON-1081 - Incorrect error message formatting in message.c
- PROTON-1238 - Add fallback operator<< for wrapped proton-c objects
- PROTON-1517 - SyncRequestResponse(BlockingConnection).call() fails with timeout
- PROTON-1522 - Password is logged on connecting with Python client
- PROTON-1531 - C epoll proactor listener cleanup race
- PROTON-1537 - ruby: update API in line with new C++ API changes
- PROTON-1556 - [proton-cpp] ssl_client_options is not self-assignable
- PROTON-1636 - Fairly Consistent (but intermittent) hangs in ruby-example-test/ruby-test-container using Travis CI
- PROTON-1641 - Windows proactor hang on incoming connections
- PROTON-1677 - Travis CI builds failing due to glibc bug
- PROTON-1685 - [go] support for marshalling/unmarshaling AMQP arrays
- PROTON-1686 - [go] unmarshal maps with illegal key types
- PROTON-1689 - [cpp] exception thrown in handler can result in garbage exception from run()
- PROTON-1694 - Some mutexes in the libuv proactor implementation are not properly initialised and destroyed
- PROTON-1697 - Tests of Ruby and Go bindings don't correctly use the path for saslpasswd2 discovered by cmake
- PROTON-1700 - [cpp] Reconnecting container does not respond to stop
- PROTON-1704 - [c proactor] test_ipv4_ipv6 intermittent failure on FreeBSD
- PROTON-1710 - Proton C++ will crash if told to run 0 threads
- PROTON-1711 - SSL_IMPL none SASL_IMPL none build attempts to build c-ssl-tests and fails
- PROTON-1717 - [C proactor] Allow initialization of transport and connection before binding
- PROTON-1720 - [ruby] support for SSL configuration via connection options
- PROTON-1725 - [ruby] broker example does not work if run outside home directory
Apache Qpid, Messaging built on AMQP; Copyright © 2015
The Apache Software Foundation; Licensed under
the Apache
License, Version 2.0; Apache Qpid, Qpid, Qpid Proton,
Proton, Apache, the Apache feather logo, and the Apache Qpid
project logo are trademarks of The Apache Software
Foundation; All other marks mentioned may be trademarks or
registered trademarks of their respective owners


| Line | Hits | Source |
|---|---|---|
| 1 | /* | |
| 2 | ||
| 3 | Copyright 2004, Martian Software, Inc. | |
| 4 | ||
| 5 | Licensed under the Apache License, Version 2.0 (the "License"); | |
| 6 | you may not use this file except in compliance with the License. | |
| 7 | You may obtain a copy of the License at | |
| 8 | ||
| 9 | http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 | ||
| 11 | Unless required by applicable law or agreed to in writing, software | |
| 12 | distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 | See the License for the specific language governing permissions and | |
| 15 | limitations under the License. | |
| 16 | ||
| 17 | */ | |
| 18 | ||
| 19 | package com.martiansoftware.nailgun; | |
| 20 | ||
| 21 | import java.io.IOException; | |
| 22 | import java.io.InputStream; | |
| 23 | ||
| 24 | /** | |
| 25 | * The class name is pretty descriptive. This creates an InputStream | |
| 26 | * much like a FilterInputStream, but with the wrapped InputStream | |
| 27 | * being local to the current Thread. By setting System.in to a | |
| 28 | * ThreadLocalInputStream, different Threads can read from different | |
| 29 | * InputStreams simply by using System.in. Of course, the init() | |
| 30 | * method must be called by the Thread that wishes to use the | |
| 31 | * wrapped stream. | |
| 32 | * | |
| 33 | * @author Marty Lamb | |
| 34 | */ | |
| 35 | class ThreadLocalInputStream extends InputStream { | |
| 36 | ||
| 37 | /** | |
| 38 | * The InputStreams for the various threads | |
| 39 | */ | |
| 40 | 0 | private InheritableThreadLocal streams = null; |
| 41 | ||
| 42 | 0 | private InputStream defaultInputStream = null; |
| 43 | ||
| 44 | /** | |
| 45 | * @param defaultInputStream the InputStream that will be used if the | |
| 46 | * current thread has not called init() | |
| 47 | */ | |
| 48 | ThreadLocalInputStream(InputStream defaultInputStream) { | |
| 49 | 0 | super(); |
| 50 | 0 | streams = new InheritableThreadLocal(); |
| 51 | 0 | this.defaultInputStream = defaultInputStream; |
| 52 | 0 | init(null); |
| 53 | 0 | } |
| 54 | ||
| 55 | /** | |
| 56 | * Sets the InputStream for the current thread | |
| 57 | * @param streamForCurrentThread the InputStream for the current thread | |
| 58 | */ | |
| 59 | void init(InputStream streamForCurrentThread) { | |
| 60 | 0 | streams.set(streamForCurrentThread); |
| 61 | 0 | } |
| 62 | ||
| 63 | /** | |
| 64 | * Returns this thread's InputStream | |
| 65 | * @return this thread's InputStream | |
| 66 | */ | |
| 67 | InputStream getInputStream() { | |
| 68 | 0 | InputStream result = (InputStream) streams.get(); |
| 69 | 0 | return ((result == null) ? defaultInputStream : result); |
| 70 | } | |
| 71 | ||
| 72 | // BEGIN delegated java.io.InputStream methods | |
| 73 | ||
| 74 | /** | |
| 75 | * @see java.io.InputStream#available() | |
| 76 | */ | |
| 77 | public int available() throws IOException { | |
| 78 | 0 | return (getInputStream().available()); |
| 79 | } | |
| 80 | ||
| 81 | /** | |
| 82 | * @see java.io.InputStream#close() | |
| 83 | */ | |
| 84 | public void close() throws IOException { | |
| 85 | 0 | getInputStream().close(); |
| 86 | 0 | } |
| 87 | ||
| 88 | /** | |
| 89 | * @see java.io.InputStream#mark(int) | |
| 90 | */ | |
| 91 | public void mark(int readlimit) { | |
| 92 | 0 | getInputStream().mark(readlimit); |
| 93 | 0 | } |
| 94 | ||
| 95 | /** | |
| 96 | * @see java.io.InputStream#markSupported() | |
| 97 | */ | |
| 98 | public boolean markSupported() { | |
| 99 | 0 | return (getInputStream().markSupported()); |
| 100 | } | |
| 101 | ||
| 102 | /** | |
| 103 | * @see java.io.InputStream#read() | |
| 104 | */ | |
| 105 | public int read() throws IOException { | |
| 106 | 0 | return (getInputStream().read()); |
| 107 | } | |
| 108 | ||
| 109 | /** | |
| 110 | * @see java.io.InputStream#read(byte[]) | |
| 111 | */ | |
| 112 | public int read(byte[] b) throws IOException { | |
| 113 | 0 | return (getInputStream().read(b)); |
| 114 | } | |
| 115 | ||
| 116 | /** | |
| 117 | * @see java.io.InputStream#read(byte[],int,int) | |
| 118 | */ | |
| 119 | public int read(byte[] b, int off, int len) throws IOException { | |
| 120 | 0 | return (getInputStream().read(b, off, len)); |
| 121 | } | |
| 122 | ||
| 123 | /** | |
| 124 | * @see java.io.InputStream#reset() | |
| 125 | */ | |
| 126 | public void reset() throws IOException { | |
| 127 | 0 | getInputStream().reset(); |
| 128 | 0 | } |
| 129 | ||
| 130 | /** | |
| 131 | * @see java.io.InputStream#skip(long) | |
| 132 | */ | |
| 133 | public long skip(long n) throws IOException { | |
| 134 | 0 | return (getInputStream().skip(n)); |
| 135 | } | |
| 136 | ||
| 137 | // BEGIN delegated java.io.InputStream methods | |
| 138 | ||
| 139 | // Note: Should java.lang.Object methods be delegated? If not, and | |
| 140 | // someone synchronizes on this stream, processes might be blocked | |
| 141 | // that shouldn't be.  Not so clear are hashcode(), equals(), notify(), and | |
| 143 | // the wait() methods. | |
| 144 | } |
|
this report was generated by version 1.0.5 of jcoverage. |
copyright © 2003, jcoverage ltd. all rights reserved. |


| 1 | /** | |
| 2 | * Copyright (c) 2016-present, RxJava Contributors. | |
| 3 | * | |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in | |
| 5 | * compliance with the License. You may obtain a copy of the License at | |
| 6 | * | |
| 7 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 8 | * | |
| 9 | * Unless required by applicable law or agreed to in writing, software distributed under the License is | |
| 10 | * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See | |
| 11 | * the License for the specific language governing permissions and limitations under the License. | |
| 12 | */ | |
| 13 | ||
| 14 | package io.reactivex.rxjava3.internal.operators.maybe; | |
| 15 | ||
| 16 | import io.reactivex.rxjava3.core.*; | |
| 17 | import io.reactivex.rxjava3.disposables.Disposable; | |
| 18 | import io.reactivex.rxjava3.exceptions.*; | |
| 19 | import io.reactivex.rxjava3.functions.*; | |
| 20 | import io.reactivex.rxjava3.internal.disposables.*; | |
| 21 | import io.reactivex.rxjava3.plugins.RxJavaPlugins; | |
| 22 | ||
| 23 | /** | |
| 24 | * Peeks into the lifecycle of a Maybe and MaybeObserver. | |
| 25 | * | |
| 26 | * @param <T> the value type | |
| 27 | */ | |
| 28 | public final class MaybePeek<T> extends AbstractMaybeWithUpstream<T, T> { | |
| 29 | ||
| 30 | final Consumer<? super Disposable> onSubscribeCall; | |
| 31 | ||
| 32 | final Consumer<? super T> onSuccessCall; | |
| 33 | ||
| 34 | final Consumer<? super Throwable> onErrorCall; | |
| 35 | ||
| 36 | final Action onCompleteCall; | |
| 37 | ||
| 38 | final Action onAfterTerminate; | |
| 39 | ||
| 40 | final Action onDisposeCall; | |
| 41 | ||
| 42 | public MaybePeek(MaybeSource<T> source, Consumer<? super Disposable> onSubscribeCall, | |
| 43 | Consumer<? super T> onSuccessCall, Consumer<? super Throwable> onErrorCall, Action onCompleteCall, | |
| 44 | Action onAfterTerminate, Action onDispose) { | |
| 45 | super(source); | |
| 46 |
1
1. |
this.onSubscribeCall = onSubscribeCall; |
| 47 |
1
1. |
this.onSuccessCall = onSuccessCall; |
| 48 |
1
1. |
this.onErrorCall = onErrorCall; |
| 49 |
1
1. |
this.onCompleteCall = onCompleteCall; |
| 50 |
1
1. |
this.onAfterTerminate = onAfterTerminate; |
| 51 |
1
1. |
this.onDisposeCall = onDispose; |
| 52 | } | |
| 53 | ||
| 54 | @Override | |
| 55 | protected void subscribeActual(MaybeObserver<? super T> observer) { | |
| 56 |
2
1. subscribeActual : removed call to io/reactivex/rxjava3/internal/operators/maybe/MaybePeek$MaybePeekObserver::<init> → KILLED 2. subscribeActual : removed call to io/reactivex/rxjava3/core/MaybeSource::subscribe → KILLED |
source.subscribe(new MaybePeekObserver<>(observer, this)); |
| 57 | } | |
| 58 | ||
| 59 | static final class MaybePeekObserver<T> implements MaybeObserver<T>, Disposable { | |
| 60 | final MaybeObserver<? super T> downstream; | |
| 61 | ||
| 62 | final MaybePeek<T> parent; | |
| 63 | ||
| 64 | Disposable upstream; | |
| 65 | ||
| 66 | MaybePeekObserver(MaybeObserver<? super T> actual, MaybePeek<T> parent) { | |
| 67 | this.downstream = actual; | |
| 68 | this.parent = parent; | |
| 69 | } | |
| 70 | ||
| 71 | @Override | |
| 72 | public void dispose() { | |
| 73 | try { | |
| 74 | parent.onDisposeCall.run(); | |
| 75 | } catch (Throwable ex) { | |
| 76 | Exceptions.throwIfFatal(ex); | |
| 77 | RxJavaPlugins.onError(ex); | |
| 78 | } | |
| 79 | ||
| 80 | upstream.dispose(); | |
| 81 | upstream = DisposableHelper.DISPOSED; | |
| 82 | } | |
| 83 | ||
| 84 | @Override | |
| 85 | public boolean isDisposed() { | |
| 86 | return upstream.isDisposed(); | |
| 87 | } | |
| 88 | ||
| 89 | @Override | |
| 90 | public void onSubscribe(Disposable d) { | |
| 91 | if (DisposableHelper.validate(this.upstream, d)) { | |
| 92 | try { | |
| 93 | parent.onSubscribeCall.accept(d); | |
| 94 | } catch (Throwable ex) { | |
| 95 | Exceptions.throwIfFatal(ex); | |
| 96 | d.dispose(); | |
| 97 | this.upstream = DisposableHelper.DISPOSED; | |
| 98 | EmptyDisposable.error(ex, downstream); | |
| 99 | return; | |
| 100 | } | |
| 101 | ||
| 102 | this.upstream = d; | |
| 103 | ||
| 104 | downstream.onSubscribe(this); | |
| 105 | } | |
| 106 | } | |
| 107 | ||
| 108 | @Override | |
| 109 | public void onSuccess(T value) { | |
| 110 | if (this.upstream == DisposableHelper.DISPOSED) { | |
| 111 | return; | |
| 112 | } | |
| 113 | try { | |
| 114 | parent.onSuccessCall.accept(value); | |
| 115 | } catch (Throwable ex) { | |
| 116 | Exceptions.throwIfFatal(ex); | |
| 117 | onErrorInner(ex); | |
| 118 | return; | |
| 119 | } | |
| 120 | this.upstream = DisposableHelper.DISPOSED; | |
| 121 | ||
| 122 | downstream.onSuccess(value); | |
| 123 | ||
| 124 | onAfterTerminate(); | |
| 125 | } | |
| 126 | ||
| 127 | @Override | |
| 128 | public void onError(Throwable e) { | |
| 129 | if (this.upstream == DisposableHelper.DISPOSED) { | |
| 130 | RxJavaPlugins.onError(e); | |
| 131 | return; | |
| 132 | } | |
| 133 | ||
| 134 | onErrorInner(e); | |
| 135 | } | |
| 136 | ||
| 137 | void onErrorInner(Throwable e) { | |
| 138 | try { | |
| 139 | parent.onErrorCall.accept(e); | |
| 140 | } catch (Throwable ex) { | |
| 141 | Exceptions.throwIfFatal(ex); | |
| 142 | e = new CompositeException(e, ex); | |
| 143 | } | |
| 144 | ||
| 145 | this.upstream = DisposableHelper.DISPOSED; | |
| 146 | ||
| 147 | downstream.onError(e); | |
| 148 | ||
| 149 | onAfterTerminate(); | |
| 150 | } | |
| 151 | ||
| 152 | @Override | |
| 153 | public void onComplete() { | |
| 154 | if (this.upstream == DisposableHelper.DISPOSED) { | |
| 155 | return; | |
| 156 | } | |
| 157 | ||
| 158 | try { | |
| 159 | parent.onCompleteCall.run(); | |
| 160 | } catch (Throwable ex) { | |
| 161 | Exceptions.throwIfFatal(ex); | |
| 162 | onErrorInner(ex); | |
| 163 | return; | |
| 164 | } | |
| 165 | this.upstream = DisposableHelper.DISPOSED; | |
| 166 | ||
| 167 | downstream.onComplete(); | |
| 168 | ||
| 169 | onAfterTerminate(); | |
| 170 | } | |
| 171 | ||
| 172 | void onAfterTerminate() { | |
| 173 | try { | |
| 174 | parent.onAfterTerminate.run(); | |
| 175 | } catch (Throwable ex) { | |
| 176 | Exceptions.throwIfFatal(ex); | |
| 177 | RxJavaPlugins.onError(ex); | |
| 178 | } | |
| 179 | } | |
| 180 | } | |
| 181 | } | |
Mutations | ||
| 46 |
1.1 |
|
| 47 |
1.1 |
|
| 48 |
1.1 |
|
| 49 |
1.1 |
|
| 50 |
1.1 |
|
| 51 |
1.1 |
|
| 56 |
1.1 2.2 |


Have the Springboks found the man to replace Rassie Erasmus?
by Online EditorsAs South Africa are still revelling in their World Cup triumph, in the coming weeks Rassie Erasmus faces yet another gruelling task.
Erasmus, who was named 2019 World Rugby Coach of the Year, revealed he will step down as head coach following the World Cup.
Fortunately, Erasmus will remain Director of Rugby, while a new ‘head coach’ will be appointed to the team.
The 46-year-old has assured that he will work “very closely with the new head coach”, leaving the question who will be the ideal candidate for the job.
According to numerous South African media outlets, current defence coach Jacques Nienaber is set to take over the role as the new man in charge.
Continue reading below…
Aiding the speculation and theory is Erasmus’ close relationship with Nienaber. They have known each other since the 1990s and Nienaber has been Erasmus’ right-hand man at the Free State Cheetahs, Stormers, Munster and now the Springboks.
Selecting someone inside the camp certainly suits the Director of Rugby’s long-term succession plans, thus Matt Proudfoot (forwards coach) and Mzwandile Stick (backline coach) could also be ideal candidates.
In terms of outsiders, Johan Ackermann (Gloucester – head coach), Johann van Graan (Munster – head coach) and Heyneke Meyer (Stade Français – head coach) are some of the names that could take over the position.
Ackermann recently signed a two-year contract extension with the Premiership side Gloucester, so it could be a costly affair to lure the former Lions coach back to South Africa.
While Meyer’s position at Stade Français is under huge threat given the Top14 side’s current form. Meyer has received the backing from the owner and German billionaire Hans-Peter Wild, but local French media are calling for his resignation as the club find themselves at bottom of the Top 14 table.
Deon Davids is another name than pops up in talks of the new Springboks coach. The former Southern Kings coach is highly-rated by Erasmus and was even invited to ‘job shadow’ the Springboks during the Rugby Championship campaign.
Despite all the uncertainties, one thing is certain the next coach will have to maintain the Springboks’ current trajectory to greatness.
Springboks fans were ecstatic after their side’s World Cup final win – but English fans were in a fairly good mood too:


In there, you need to input:
| - |
Group name |
| |
| - |
Decide who will be invited to join your private message group. It has one and only one input field.
Note:
Due to security reason, you must know someone's alias to invit him/her to your private message group, SMS won't list out available users for you.
|
| |
| - |
Decide whether group messages should be deleted automatically in a pre-defined period (in minutes) after a message is read. Default value is 'On',
that means 'Yes' and default message deletion period is 1 minute. You may change the message deletion period from 1 minute to 30 minutes. However,
if you select 'Off' on 'Auto delete read message', it doesn't mean the messages on your private group could be preserved forever until you delete
them manually. No, it is not. If you select 'Off', your messages deletion period will be passed control to follow system setting 'old_msg_delete_days'.
e.g. If value of 'old_msg_delete_days' is 7, then your private messages which was sent 7 days ago or before will be deleted automatically. So, there
is no such thing of preserved forever private message, preserved forever messages only exist on common message group with suitable setting only.
|
| |
Then, click 'Create' button to create your private message group.
|


Current Stable Version 0.7.1 -- source, required libraries and documentation Get It!
0.7.1 -- 03/03/2008 -- Updated prototype to <IP_ADDRESS>, fixed bug in ie6 in dialog, made hiding select boxes less jarring in dialog, if tooltip goes over the body to the right it is now pushed down below the anchor (thanks Nick)
0.7 -- 01/02/2008 -- Fixed a bug in the date picker. And dropped in prototype 1.6 and s.a.u 1.8 final.
0.7_pre1 -- 10/18/2007 -- Fixed some bugs with the dialog and tooltip. Also made the code more modern.
0.7_pre0 -- 10/17/2007 -- Migrated to prototype 1.6 and s.a.u 1.8.0_pre
0.6 -- 08/24/2007 -- Added support to pass parameters to Simpltry.Dialog.Ajax (thanks Seth), added option to disallow past date selection in datepicker, gave tooltips the ability to be cursor relative, fixed a render bug in tooltip when containing div was positioned absolutely.
0.5 -- 06/16/2007 -- Changed License to MIT, added timepicker, and upgraded to the latest prototype/script.aculo.us.
<IP_ADDRESS> -- 01/31/2007 -- fixed typo (thanks Dan)
0.4.6 -- 01/24/2007 -- multiple datepicker bug (thanks Dan)
0.4.5 -- 01/12/2007 -- datepicker month back bug (thanks Dan)
0.4.4 -- 11/22/2006 -- datepicker bug fixes
0.4.3 -- 10/25/2006 -- added ie 7 support
0.4.2 -- 10/18/2006 -- updated documentation -- refactored window_properties.js out of dialog.js
0.4.1 -- 10/14/2006 -- initial version


Welcome to the PFSA Library
The library collection consists of over 12,000 works dealing with the Portuguese throughout the
world.
It holds a vast number
of books on the Azores and a fairly complete sample of periodicals published by the Portuguese
in
California,
some dating to the late 1880's. The library contains many historical materials on Portuguese
from all
over
the world. We provide our community with various magazines, periodicals, albums, videos, micro
films,
etc.
Most of the collection circulates for periods of two weeks each and books can be requested from
anywhere
in California through interlibrary loan services provided by a network of public and academic
libraries
throughout
California.


Experienced Associate Engineer with a demonstrated history of working in the wireless industry. Skilled in C, CPP, PHP, Databases, Web Design, and Python. Strong engineering professional with a Bachelor’s Degree focused in Computer Science from National Institute of Technology Rourkela.
Broadly working on sensors software
I did an internship under Mr. N.S. Bhandari, Librarian, IIT Mandi for eight weeks.
CGPA: 9.50/10
95.6%
CGPA: 10/10
Apart from being a web developer, I enjoy playing chess and cricket. I enjoy travelling, exploring new places.
I spend a large amount of my free time exploring the latest technology advancements.