R uses the fucntion to perform operation. To run a function called funcname, we type funcname(input1, input2), where the inputs tell R how to run the function.
For example to create a vector of numbers, we use the function c() for concatenate.
x <- c(1,2,3,4,5)
x
class(x)
Any numbers inside the paratheses are joined together and save them as a vector named x. When we type x, it give us back the vector. We can save things using = rather than <-
x = c(1,2,3,4,5)
x
class(x)
Typing ?funcname will always cause R to open a new help file window with additional information about the function
?c
We can tell R to add two sets of numbers together. It will then add the first number from x to the first number from y, and so on. However, x ad y should be the same length. We can check the lenght using length() function
length(x)
y = c(1,2,3,4,5)
length(y)
ls() function allows us to look at a list of all of the objects, such as data and functions, that we have saved so far. The rm() function can be used to delete any that we don't want
ls()
rm(x)
length(x) # x is now deleted
It's also possible to delete all the objects at once.
rm(list=ls())
ls()
The matrix() function can be used to create a matrix of numbers. Before we use the matrix() function, we can learn more about it.
?matrix()
Let's create a very simple matrix!
# Named of the matrix is mat
mat = matrix(data = c(1,2,3,4,5,6), nrow=3, ncol=2)
mat
Note
- We could just as well omit typing data=,nrow=,ncol=,in the matrix() command baove that is, we could just type.
mat = matrix(c(1,2,3,4,5,6),3,2)
As the above examples illustrates, by default R creates matrices by successively filling in columns. Alternatively, the brow=TRUE
option can be used to populate the matrix in order of the rows.
mat = matrix(c(1,2,3,4),2,2,byrow = TRUE)
mat
sqrt()
function returns the square root of each element of a vector or matrix. The command x^2 raises the element of x to the power of 2; any power 2; any powers are possible, including the fractional or negative powers.
sqrt(2.10100)
sqrt(16)
sqrt(mat)
The rnorm()
function generates a vector of random variable, we will first argument n the sample size. Each time we call this function, we will get a different answer. Here, we create two correlated sets of numbers, x and y, and use the cor() function to compute the correlation between them.
?rnorm
x = rnorm(50)
x
y = x+rnorm(50, mean = 50, sd=.1)
y
cor(x,y)
By Default, rnorm() creates standard normal random variables with a mean of 0 and sd 1. However, the mean and sd can be altered by using the mean and sd arguments, as illustrated above. Sometimes, we want our code to reproduce the exact same set of random numbers, we can use the set.seed() function to do this. The set.seed() function takes an arbitrary integer argument.
set.seed(1303)
rnorm(50)
We will going to use set.seed() throught out the labs. The mean() and var() functions can be used to compute the mean and variance of a vector of numbers. Applying the sqrt() to the output of var() will give the standard deviation (sd). or you can directly use the sd().
set.seed(3)
y = rnorm(100)
mean(y)
var(y)
sqrt(var(y))
sd(y)
The plot() function is the primary way to plot the data in R. For instance, plot(x,y) produces a scatterplot of the numbers in x versus the numbers in y. There are many additional options that can be passed in to the plot() function. For example, passing in the argument xlab will result in a label on the x-axis. To find out more information about the plot() function type ?plot()
?plot()
x = rnorm(100)
y = rnorm(100)
plot(x,y)
plot(x,y,xlab="This is the x-axis", ylab= "This is the y-axis", main="Plot of x vs y")
Sometimes, we want to save our output of an R plot. The Command that we use to do this will depend on the file type that we would like to create. For instance, we create a pdf, using the pdf() function, and to create jpeg(), we use the jpeg() function.
pdf("Figure.pdf")
plot(x,y,col = "green")
dev.off()
The function dev.off() indicates to R we are done creating the plot. Alternatively, we can simply copy the plot window and paste it into the an appropriate file type, such a Word document.
?dev.off
The function seq() can be used to create a sequence of numbers. For instance, seq(a,b) makes a vector of integers between a and b. There are many other options: for instance seq(0,1,length=10) makes a sequence of 10 numbers that are equally spaced between 0 and 1. Typing 3:11 is a shorthand for seq(3,11) for integer arguments.
x = seq(1,10)
x
x = 1:10
x
x = seq(-pi,pi,length=50)
x
Let's create some more sophisticated plots. The contour() function produces a contour plot() in order to represent three dimensional data; it is like a topographical map.
It takes three arguments:
As with the plot() function there are many other inputs that can be used to fine-tune the output of the contour() function.
y=x
f = outer(x,y,function(x,y)cos(y)/(1+x^2))
contour(x,y,f)
contour(x,y,f,nlevels=45,add=T)
fa = (f-t(f))/2
contour(x,y,fa,nlevels=15)
The image() function works the same way as contour(), except that it produces the color-coded plot whose colors depend on the z value. This is know as heatmap
. and is sometimes used to plot temperature in weather forecasts. Alternativerly, persp() can be used to produce a three dimensional plot. The arguments theta and phi control the angles at which the plot is viewed.
image(x,y,fa)
persp(x,y,fa)
persp(x,y,fa,theta = 30)
persp(x,y,fa, theta = 30, phi=20)
persp(x,y,fa, theta = 30, phi=70)
persp(x,y,fa,theta = 30, phi=40)
We often wish to examine the part of a set of data. Suppose that our data is stored in the matrix A
A = matrix(1:16, 4,4)
A
A[2,3]
Above, will select the element corresponding to the second row and the third column. The first number after the open brack symbol [
always refers to the row, and the second number refers to column. We can select multiple rows and columns at a time, by providing vectors as the indics.
A[2:4]
A[2:4,2:4]
A[c(1,3),c(2,4)]
A[1:3,2:4]
A[1:2,]
A[,1:2]
The last two examples include either no index for the columns or no index for the rows. These indicates that R should include all the columns or all the rows, respectively. R treats a single row or columns of a matrix as a vector.
A[1,]
The use of -ve
sign in the index tells R to keep all the rows or columns except those indicated in the index.
A[-c(1,3),]
Lastly, dim() function outputs the number of rows followed by the number of columns of a given matrix.
dim(A)
For most analyses, the first step involves importing the dataset into R. The read.table()
function is the one of the primary ways to do this.The help file contains details about how to use this function. We can use the function, write.table()
to export data.
Before attempting, to load a dataset, we must make sure that R knows to search for the data in the proper directory. For example on a windows system one could select the directory using the change dir
... option under the File menu.However, the details of how to do this depend on the operating system(e.g. Windows, Mac, Linux etc.)that is being used.
ISLR package contains all the dataset which I will be using in the labs.
# uncomment the below line and download the package
# install.packages("ISLR")
library("ISLR")
Auto
fix(Auto)
Once the data has been loaded, the fix() function can be used to view, it in a spreadsheet like windows. However, the window must be closed before further R Commands can be entered.
Sometimes dataset has not been loaded correctly, because R has assumed the variable names are part of the data and so has included them in the first row. In that cases, put header=T
dim(Auto) # if you notice here it's showing 392 rather than 397 because R by defualt omit the na rows.
We can use plot() function to produce scatterplot of the quantitative varaibles. However, simply typing the variable names will produce an error message, because R does not know to look in the Auto dataset for those variables.
plot(cylinders, mpg)
To refer to a variable we must type the datset and the variable name joined with $ symbol. Alternatively, we can use attach() function in the order to tell R to make the variables in this dataframe available by name.
plot(Auto$cylinders,Auto$mpg)
attach(Auto)
plot(cylinders, mpg)
The cylinders variable is stored as a numeric vector, so R has treated it as quantitative. However, there are only a small number of possible values for cylinders, one may prefer to treat it as qualitative variable. The as.factor()
function converts quantitative variable to qualitative variables.
class(Auto$cylinders)
cylinders <- as.factor(cylinders)
class(cylinders)
If the variable plotted on x-axis is categorical then boxplots will automatically be produced by the plot() function
plot(cylinders,mpg)
plot(cylinders,mpg,col = "red")
plot(cylinders,mpg,col = "red", varwidth = T)
plot(cylinders,mpg,col = "red", varwidth = T, horizontal = T)
plot(cylinders,mpg,col = "red", varwidth = T, xlab= "Cylinders", ylab ="MPG")
The hist()
function can be used to plot histogram. Note col=2 has the same effect as col="red"
hist(mpg)
hist(mpg,col=2)
hist(mpg,col=2,breaks = 15)
The pairs()
function creates a scatterplot matrix i.e scatterplot for every pair of variables for any given dataset. We can also produce scatterplots for just a subset of the variables.
pairs(Auto)
pairs(~mpg + displacement+horsepower+weight+acceleration, Auto)
plot(horsepower , mpg)
In conjunction with plot()
function, identify()
provides a useful interactive method for identifying the value for a particular variable for points on a plot.
# plot(horsepower,mpg)
# identify(horsepower,mpg,name) # works in Rstudio
The summary() function provides a numerical summary of each variable in a particular dataset.
summary(Auto)
For qualitative variables such as name, R will list the number of observations that fall in each category.
summary(mpg)
That's it for this tutorial. Come week, I am bringing more content to learn R basics.


I am finishing up my third year at Cal Poly State University, San Luis Obispo, studying Graphic Communication with a concentration in Web and Digital Media.
I have worked for over a year at Accompa, Inc. as a Product Design Intern. Accompa's main products are enterprise software for requirements management and virtual idea boxes. Since I arrived, we have been branching out into mobile apps.
I began work on a dart scoring app called DartGenie shortly after being hired. My responsibilities spanned creating graphic and UI designs, developing marketing plans, writing requirements, managing the offshore development team, and testing the apps. The DartGenie app is available for iOS and Android, has more than 10,000 installs, and maintains a 4-star rating.
I am currently working on an app called Push the Hay, which is a logic puzzle game. I play a similar role on this project as I did on DartGenie. We hope to release this app by the end of May.


Amy Sarrazin
Democrat
Grants Development Manager for Mental Health Center of Denver
University of Massachusetts Dartmouth Master’s degree, Public Policy Analysis Anticipated graduation date 2021 University of Massachusetts Dartmouth Graduate Certificate, Public Management Metropolitan State University of Denver Bachelor of Arts (B.A.), Communication and Media Studies
80022
N/A
N/A
My only experience has been on behalf of my employer where I helped champion and fund advocacy work for the Caring for Denver ballot initiative in 2018.
I am wrapping up my graduate degree in public policy and feel this would serve as an amazing opportunity to learn more in a real world, hands on way
I have taken the StrengthsFinder assessment and a few of my top strengths include: strategic, communication, positivity, and includer. On a daily basis I utilize these strengths to work across my organization to promote voice and stakeholder involvement. I am very good at involving multiple communication styles, beliefs, and personality types to arrive at a common goal. I will bring my customer service and community engagement background to ensure that all voices are heard. One of the bigger topics discussed in my master's program is the ability to take oneself and background out of the decision making process. To do that, I look at the issue as a whole and look at all alternatives to what the issue at hand might be. I welcome stakeholder involvement and encourage communication so that any angles that might have been unseen get a fair look and understanding from me.
I am very strategic and logical when approaching problems. I consider all sources and options before reacting or responding. I like to understand all elements of the problem or issue before moving forward on a solution. I use a combination of deductive reasoning and critical thinking to assess a situation before coming to a conclusion.
Female


fun DataFrame.setNames(vararg newNames: String): DataFrame
Replace current column names with new ones. The number of provided names must match the number of columns.


A message from the founders of IronRidge
We created IronRidge in our free time between work, college, and parenting because we love the Minecraft community.
IronRidge was never intended to be a source of income, and we will never operate IronRidge as a for-profit server.
All donations go directly to our monthly and yearly server-related expenses.
As for all of the time we put into building this website from scratch, managing the server, and curating our fantastic community - that's on us.


my name is Or and i love my job! my favorite program language is angular
I enjoy writing front-end code with these technologies! I reccomend you to come and join me!
contact me on one of the following: twittr facebook linkedin


Cintiha K. Rosas-Gordillo
Email
Click Here Send Direct Email
Home
About
Projects
Contact
CONTACT FORM
Name
(required)
Email Address
(required)
Message
Submit
Linked-In Profile
Certificate
Resume


---
layout: page
---
Reinforce the rationale and importance of this step. Emphasize why this step is important and useful. Provide a hook or motivation to complete this step well. Optional extra intro text. Optional extra intro text. An annotated example using h5p. Some text below to help understand how to interact with this example. An optional place to put some follow-up text if needed. Example 1 follow-up text Example 2 Example 3 An optional place to put some follow-up text if needed. Offer tips and advice. Highlight common pitfalls and suggest strategies to avoid them. Link to additional resources for help and guidance. Quote experts (both learners and teachers), if that might be helpful. Summarize key things about this step. Give encouragement! Maybe provide a self-eval checklist or other useful resource?
Explain
Explain this step
The first set of steps
The second set of steps
Demonstrate
Annotated examples
Demonstrate with Tabs
Annotated examples
Title of example 1
Credit / background info for example
Title of example 2
Credit / background info for example
Title of example 1
Credit / background info for example
Guide & Enable
Provide tips & strategies
"A compelling quote that offers great advice." - a successful learner
Tips
Give it a try!


Here's a simple hack using a view's description text to add a Google swing-o-meter to indicate the proportion of builds passing.
Paste this text into the view's description box:
<script> var xmlhttp = null; if (window.XMLHttpRequest) xmlhttp = new XMLHttpRequest(); else if (window.ActiveXObject) { if (new ActiveXObject("Microsoft.XMLHTTP")) xmlhttp = new ActiveXObject("Microsoft.XMLHTTP"); else xmlhttp = new ActiveXObject("Msxml2.XMLHTTP"); } var url = document.location + "/api/xml?xpath=count%28//job[color=%22blue%22]%29div+count%28//job%29" xmlhttp.open("GET", url, false);//false means synchronous xmlhttp.send() var buildSuccessFraction= xmlhttp.responseText document.write('<img src="http://chart.apis.google.com/chart?chs=320x160&cht=gom&chd=t:' + buildSuccessFraction * 100.0 + '&chxt=x,y&chxl=y|0:||1:|failure|success">') </script>
Sample:
Security Limitations
Jenkins now prevents script tags being used in the view section. If you accept the risk of allowing script tags in views, then you will need to also include and configure the "Anything Goes" formatter.
Attachments:
chart.png (image/png)


SurveyForm
Name:
Dojo Location:
Favorite Language:
Comment:
{{survey['name']}}
{{survey['location']}}
{{survey['language']}}
{{survey['comment']}}
Return


| Type | Name and description |
|---|---|
com.rabbitmq.client.Channel |
createChannel() Creates a RabbitMQ Channel with the default connection. |
com.rabbitmq.client.Channel |
createChannel(java.lang.String connectionName) Creates a RabbitMQ Channel with the specified connection. |
void |
createExchangesAndQueues() Creates any configured exchanges and queues. |
com.rabbitmq.client.Connection |
getConnection() Returns the RabbitMQ Connection associated with the default connection. |
com.rabbitmq.client.Connection |
getConnection(java.lang.String name) Returns the RabbitMQ Connection with the specified connection name. |
RunningState |
getRunningState() Get the overall running state of consumers and connections. |
java.util.List<ConnectionReport> |
getStatusReport() Generates a report about all connections and consumers. |
void |
load() Loads the configuration and registers any consumers or converters. |
void |
registerConnection(ConnectionConfiguration configuration) Registers a new connection. |
void |
registerConsumer(java.lang.Object consumer) Registers a consumer. |
void |
registerMessageConverter(MessageConverter converter) Registers a message converter. |
void |
reload() Stops all consumers and connections, reloads the application configurations, and finally starts all connections and consumers. |
void |
reset() Stops all consumers and connections, and removes any registered contexts. |
void |
setConnectionManager(ConnectionManager connectionManager) Sets the connection manager. |
void |
setConsumerManager(ConsumerManager consumerManager) Sets the rabbit consumer manager. |
void |
setMessageConverterManager(MessageConverterManager messageConverterManager) Sets the message converter manager. |
void |
setQueueBuilder(QueueBuilder queueBuilder) Sets the rabbit queue builder. |
void |
shutdown() Perform a graceful shutdown of consumers and then disconnect. |
void |
start() Starts all connections, creates exchanges and queues, and starts all consumers. |
void |
start(boolean deferConsumers) Starts all connections and creates exchanges and queues. |
void |
startConnection(java.lang.String name) Starts the connection with the given name. |
void |
startConnections() Starts all connections. |
void |
startConsumer(java.lang.String name) Starts a consumer based on its name. |
void |
startConsumers() Starts all consumers. |
void |
startConsumers(java.lang.String connectionName) Starts all consumers associated with the given connection name. |
void |
stop() Stops all consumers and connections. |
void |
stopConnection(java.lang.String name) Stops the connection with the given name. |
void |
stopConnections() Stops all connections. |
void |
stopConsumer(java.lang.String name) Stops a consumer based on its name. |
void |
stopConsumers() Stops all consumers. |
void |
stopConsumers(java.lang.String connectionName) Stops all consumers associated with the given connection name. |
Creates a RabbitMQ Channel with the default connection.
Creates a RabbitMQ Channel with the specified connection.
Creates any configured exchanges and queues.
Returns the RabbitMQ Connection associated with the default connection.
Returns the RabbitMQ Connection with the specified connection name.
Get the overall running state of consumers and connections.
Generates a report about all connections and consumers.
Loads the configuration and registers any consumers or converters.
Registers a new connection.
Registers a consumer.
Registers a message converter.
Stops all consumers and connections, reloads the application configurations, and finally starts all connections and consumers. Calling this method will retain any manually registered consumers and connections unless they are overridden by the configuration.
Stops all consumers and connections, and removes any registered contexts.
Sets the connection manager.
Sets the rabbit consumer manager.
Sets the message converter manager.
Sets the rabbit queue builder.
Perform a graceful shutdown of consumers and then disconnect. This method blocks until the full shutdown is complete.
Starts all connections, creates exchanges and queues, and starts all consumers.
Starts all connections and creates exchanges and queues. Optionally starts consumers. This method is useful in situation where the system needs to be started up but other work needs to be done before messages can start consuming.
Starts the connection with the given name.
Starts all connections.
Starts a consumer based on its name.
Starts all consumers.
Starts all consumers associated with the given connection name.
Stops all consumers and connections.
Stops the connection with the given name. This will also stop all consumers using the connection.
Stops all connections. This will also stop all consumers.
Stops a consumer based on its name.
Stops all consumers.
Stops all consumers associated with the given connection name.


|
Clawpack Documentation Version 5.0 --- Under Construction! Not yet accurate |
Takes a grid patch with mesh widths hx and hy, of dimensions nrow by ncol, and uses the boundary conditions to set the solution values on any piece of the patch which extends outside the physical domain.
User-specified boundary conditions must be included in this routine.


We are a team of students competing in RamHacks 2018
We were challenged with creating a program to help the public.
This is our attempt. Enjoy.
Developers:
Adam
Allen Payne
Jeremy
Sid


cloud-launcher is a set of free and open-source tools for designing, launching, and managing distributed computing systems on a global scale.
cloud-launcher aims to integrate with every provider on the planet to not only free you from reliance on a single provider, but to allow you to run across any and all providers to create truely high-availabile systems that can survive in all but the most catastrophic scenarios.


Docs
API
Resources
Community
Feedback
Discussion
View Source
Feedback
Tell us how we are doing, and how we can improve


With the introduction of DTrace on Solaris 10, DTrace support has been added to the Java SE 6 HotSpot VM. The hotspot and hotspot_jni providers make available probes that can be used to monitor JVM internal state and activities as well as the Java application that is running. All of the probes are USDT probes and are accessed using the process-id of the JVM process. The probe details are listed in the next section, and the API is provided in the reference section.
The hotspot provider makes available probes that can be used to track the lifespan of the VM, thread start and stop events, GC and memory pool statistics, method compilations, and monitor activity. With a startup flag, additional probes are enabled which can be used to monitor the running Java program, such as method enter and return probes, and object allocations. All of the hotspot probes originate in the VM library (libjvm.so), so they are also provided from programs which embed the VM.
Many of the probes in the provider have arguments that can be examined to provide further details on the state of the VM. Many of these probes' arguments are opaque IDs which can be used to link probe firings to each other, however strings and other data are also provided. When string values are provided, they are always present as a pair: a pointer to unterminated modified UTF-8 data (see JVM spec :4.4.7) , and a length value which indicates the extent of that data. Because the string data (even when none of the characters are outside the ASCII range) is not guaranteed to be terminated by a NUL character, it is necessary to use the length-terminated copyinstr() intrinsic to read the string data from the process.
The probes that relate to the VM life-cycle are indicated below. None have any arguments at this time.
| vm-init-begin | Probe that fires just as the VM initialization begins |
| vm-init-end | Probe that fires when the VM initialization finishes, and the VM is ready to start running application code |
| vm-shutdown | Probe that fires as the VM is shutting down due to program termination or an error |
Two probes are available for tracking thread start and stop events.
| thread-start | Probe that fires when a thread is started. Provides the arguments listed below |
| thread-stop | Probe that fires when the thread has completed. Provides the arguments listed below |
Each of these probes has the following arguments:
| args[0] | A pointer to UTF-8 string data which contains the thread name |
| args[1] | The length of the thread name data (in bytes) |
| args[2] | The Java thread ID. This is the value that will match other HotSpot VM probes which contain a thread argument |
| args[3] | The native/OS thread ID. This is the ID assigned by the host operating system |
| args[4] | A boolean value which indicates if this thread is a daemon or not. A value of 0 indicates a non-daemon thread |
Two probes are available for tracking class loading and unloading activity.
| class-loaded | Probe that fires when a class has been loaded |
| class-unloaded | Probe that fires when a class has been unloaded from the system |
Each of these probes has the following arguments:
| args[0] | A pointer to UTF-8 string data which contains the name of the class that was loaded |
| args[1] | The length of the class name data (in bytes) |
| args[2] | The class loader ID, which is a unique identifier for a class loader in the VM. This is the class loader that loaded the class |
| args[3] | A boolean value which indicates if the class is a shared class (if the class was loaded from the shared archive) |
Probes are available that can be used to measure the duration of a system-wide garbage collection cycle (for those garbage collectors that have a defined begin and end). Each memory pool can be tracked independently. The probes for individual pools pass the memory manager's name, the pool name, and pool usage information at both the begin and end of pool collection.
The provided GC-related probes are:
| gc-begin | Probe that fires when a system-wide collection is about to start. It's one argument (arg[0]) is a boolean value which indicates if this is to be a Full GC. |
| gc-end | Probe that fires when a system-wide collection has completed. No arguments. |
| mem-pool-gc-begin | Probe that fires when an individual memory pool is about to be collected. Provides the arguments listed below |
| mem-pool-gc-end | Probe that fires after an individual memory pool has been collected. Provides the arguments listed below |
Memory pool probe arguments:
| args[0] | A pointer to UTF-8 string data which contains the name of the manager which manages this memory pool |
| args[1] | The length of the manager name data (in bytes) |
| args[2] | A pointer to UTF-8 string data which contains the name of the memory pool |
| args[3] | The length of the memory pool name data (in bytes) |
| args[4] | The initial size of the memory pool (in bytes) |
| args[5] | The amount of memory in use in the memory pool (in bytes) |
| args[6] | The number of committed pages in the memory pool |
| args[7] | The maximum size of the memory pool |
Probes are available to indicate which methods are being compiled and by which compiler. Probes are also available to track the installing and uninstalling of compiled methods.
Probes that mark the begin and end of method compilation:
| method-compile-begin | Probe that fires as method compilation begins. Provides the arguments listed below |
| method-compile-end | Probe that fires when method compilation completes. In addition to the arguments listed below, argv[8] is a boolean value which indicates if the compilation was successful |
Method compilation probe arguments:
| args[0] | A pointer to UTF-8 string data which contains the name of the compiler which is compiling this method |
| args[1] | The length of the compiler name data (in bytes) |
| args[2] | A pointer to UTF-8 string data which contains the name of the class of the method being compiled |
| args[3] | The length of the class name data (in bytes) |
| args[4] | A pointer to UTF-8 string data which contains the name of the method being compiled |
| args[5] | The length of the method name data (in bytes) |
| args[6] | A pointer to UTF-8 string data which contains the signature of the method being compiled |
| args[7] | The length of the signature data (in bytes) |
When compiled methods are installed for execution or uninstalled, the following probes are fired:
| compiled-method-load | Probe that fires when a compiled method is installed. In addition to the arguments listed below, argv[6] contains a pointer to the compiled code, and argv[7] is the size of the compiled code |
| compiled-method-unload | Probe that fires when a compiled method is uninstalled. Provides the arguments listed below |
Compiled method loading probe arguments:
| args[0] | A pointer to UTF-8 string data which contains the name of the class of the method being installed |
| args[1] | The length of the class name data (in bytes) |
| args[2] | A pointer to UTF-8 string data which contains the name of the method being installed |
| args[3] | The length of the method name data (in bytes) |
| args[4] | A pointer to UTF-8 string data which contains the signature of the method being installed |
| args[5] | The length of the signature data (in bytes) |
As the Java application runs, threads will enter and exit monitors, wait on monitors, and perform notifications. Probes are available for all wait and notification events, as well as for contended monitor entry and exit events. A contended monitor entry is the situation where a thread attempts to enter a monitor when another thread is already in the monitor. A contended monitor exit event occurs when a thread leaves a monitor and other threads are waiting to enter to the monitor. Thus, contended enter and contended exit events may not match up to each other in relation to the thread that encounters these events, though it is expected that a contended exit from one thread should match up to a contended enter on another thread (the thread waiting to enter the monitor).
All monitor events provide the thread ID, a monitor ID, and the type of the class of the object as arguments. It is expected that the thread and the class will help map back to the Java program, while the monitor ID can provide matching information between probe firings.
Since the existence of these probes in the VM causes performance degradation, they will only fire if the VM flag -XX:+ExtendedDTraceProbes is set on the java command line. This flag can be turned on and off dynamically at runtime by using the jinfo utility.
If the above flag is off, the monitor probes are still present in the probe listing obtainable from dtrace, but will remain dormant and will never fire. It is intended that this restriction be removed in future releases of the VM, where these probes will be enabled all the time with no impact to performance.
The available probes:
| monitor-contended-enter | Probe that fires as a thread attempts to enter a contended monitor |
| monitor-contended-entered | Probe that fires when a thread successfully enters the contended monitor |
| monitor-contended-exit | Probe that fires when a thread leaves a monitor and other threads are waiting to enter |
| monitor-wait | Probe that fires as a thread begins a wait on a monitor via Object.wait(). The probe has an additional argument, args[4] which is a 'long' value which indicates the timeout being used. |
| monitor-waited | Probe that fires when a thread completes an Object.wait(). |
| monitor-notify | Probe that fires when a thread calls Object.notify() to notify waiters on a monitor |
| monitor-notifyAll | Probe that fires when a thread calls Object.notifyAll() to notify waiters on a monitor |
Monitor probe arguments:
| args[0] | The Java thread identifier for the thread performing the monitor operation |
| args[1] | A unique, but opaque identifier for the specific monitor that the action is performed upon |
| args[2] | A pointer to UTF-8 string data which contains the class name of the object being acted upon |
| args[3] | The length of the class name data (in bytes) |
A few probes are provided to allow fine-grained examination of Java thread execution. These consist of probes that fire anytime a method is entered or returned from, as well as a probe that fires whenever a Java object has been allocated.
Since the existence of these probes in the VM causes performance degradation, they will only fire if the VM has the ExtendedDTraceProbes flag enabled. By default the probes are all present in any listing of the probes in the VM, but are dormant without the appropriate flag. It is intended that this restriction be removed in future releases of the VM, where these probes will be enabled all the time with no impact to performance.
The method entry and return probes:
| method-entry | Probe that fires when a method is being entered. |
| method-return | Probe that fires when a method returns, either normally or due to an exception. |
Method probe arguments:
| args[0] | The Java thread ID of the thread that is entering or leaving the method |
| args[1] | A pointer to UTF-8 string data which contains the name of the class of the method |
| args[2] | The length of the class name data (in bytes) |
| args[3] | A pointer to UTF-8 string data which contains the name of the method |
| args[4] | The length of the method name data (in bytes) |
| args[5] | A pointer to UTF-8 string data which contains the signature of the method |
| args[6] | The length of the signature data (in bytes) |
The available allocation probe:
| object-alloc | Probe that fires when any object is allocated, provided that the ExtendedDTraceProbes flag is enabled. |
The object allocation probe has the following arguments:
| args[0] | The Java thread ID of the thread that is allocating the object |
| args[1] | A pointer to UTF-8 string data which contains the class name of the object being allocated |
| args[2] | The length of the class name data (in bytes) |
| args[3] | The size of the object being allocated |
In order to call from native code to Java code, due to embedding of the VM in an application or execution of native code within a Java application, the native code must make a call through the JNI interface. The JNI interface provides a number of methods for invoking Java code and examining the state of the VM. DTrace probes are provided at the entry point and return point for each of these methods. The probes are provided by the hotspot_jni provider. The name of the probe is the name of the JNI method, appended with "-entry" for entry probes, and "-return" for return probes. The arguments available at each entry probe are the arguments that were provided to the function (with the exception of the Invoke* methods, which omit the arguments that are passed to the Java method).  All rights reserved. |


Matryoshka Nesting Hashes
Ruby's collection object classes, Arrays and Hashes
April 26th, 2015
Arrays
Arrays are the easiest data "box" to understand. Imagine an egg carton. An array that models an empty would be an array with twelve nil values. If you took coins and put them in the egg carton, you would know what was in each section, how many sections there were, even where in the egg carton their was a 1956 quarter. However, outside of an implied order (what order they were put in), there wouldn't be any meaning to where you placed that quarter. In an array, the index value in always its place in relation to the start of the box, it knows what is next to itself, etc.
Hashes
Hashes on the other hand don't have an order. It is difficult to imagine a hash, but if you imagine several cups with labels on them, you can get close. Each cup has a lable on it, say salt or cummin. Inside of the salt cup would only be salt, you could ask how much salt there was and if there was enough to make bread. However, you couldn't, and wouldn't ask where the salt was in relation to the cummin. The cummin is in its own bowl, and they don't have an order, their just all there on the table. The table is the hash, it is where all of the key (bowls) / value (spices) pairs are stored.


Limitless - Notifications
Overview
Bootbox.js is a small JavaScript library which allows you to create programmatic dialog boxes using Bootstrap modals, without having to worry about creating, managing or removing any of the required DOM elements or JS event handlers.
Usage
Include the following lines of code in the
section of your HTML:

Call the plugin via JavaScript:
// Initialization example
bootbox.alert({
size: 'small',
message: "Your message here…",
callback: function(){ /* your callback code */ }
})
Alert dialog
A simple alert dialog with a single button. Pressing the ESC key or clicking the close button dismisses the dialog. If a callback is provided it is not passed any value when executed
Alert options:
// Options
bootbox.alert({
size: 'small',
message: "Your message here…",
callback: function(){ /* your callback code */ }
});
Confirm dialog
A confirm dialog with a cancel and a confirm button. Pressing the ESC key or clicking close dismisses the dialog and invokes the callback as if the user had clicked the cancel button
Confirm options:
// Options
bootbox.confirm({
size: 'small',
message: "Your message here…",
callback: function(result){ /* your callback code */ }
});
Prompt dialog
A dialog which prompts for user input. Pressing the ESC key or clicking close dismisses the dialog and invokes the callback as if the user had clicked the cancel button. Prompt dialogs require a callback function.
Prompt options:
// Options
bootbox.prompt({
size: 'small',
message: "Your message here…",
callback: function(result){ /* your callback code */ }
})
Dialog options
Options can be passed in as a JavaScript object. Please note that not all options are valid for all dialog types.
| Option | Type | Description |
|---|---|---|
message |
String | Element | [Required]. Text (or markup) displayed in the dialog |
title |
String | Element | Adds a header to the dialog and places this text (or markup) in an
 element |
locale |
String | The locale settings used to translate the three standard button labels: OK, CONFIRM, CANCEL. Default: en . Currently available: bg_BG , br , cs , da , de , el , en , es , et , fa , fi , fr , he , hu , hr , id , it , ja , lt , lv , nl , no , pl , pt , ru sq , sv , th , tr , zh_CN , zh_TW |
callback |
Function | [Required]. An alert callback should not supply an argument; it will be ignored if it does. Confirm and prompt callbacks must supply an argument for the result; for confirm, it will be a true or false value, while the prompt result will hold the value entered by the user |
onEscape |
Boolean | Function | Allows the user to dismisss the dialog by hitting ESC, which will invoke this function |
show |
Boolean | Whether the dialog should be shown immediately |
backdrop |
Boolean | Whether the dialog should be have a backdrop or not. Also determines whether clicking on the backdrop dismisses the modal |
closeButton |
Boolean | Whether the dialog should have a close button or not |
animate |
Boolean | Animate the dialog in and out (requires a browser which supports CSS animations) |
className |
String | An additional class to apply to the dialog wrapper. Default null |
size |
String | Adds the relevant Bootstrap modal size class to the dialog wrapper. Valid values are 'large' and 'small' |
buttons |
Object | [Required]. Buttons are defined as JavaScript objects |
Public methods
Options can be passed in as a JavaScript object. Please note that not all options are valid for all dialog types.
| Method | Description |
|---|---|
bootbox.init(function) |
Allows the user to supply a function to be called when dialog gets initialized |
bootbox.setDefaults(object options) |
This method allows the user to set many of the default options. Many of these options are also applied to the basic wrapper methods and can be overridden whenever the wrapper methods are invoked with a single options argument |
bootbox.addLocale(String name, object values) |
Allows the user to add a custom translation for each of the built-in command buttons |
bootbox.removeLocale(String name) |
Allows the user to remove a locale from the available locale settings |
bootbox.setLocale(String name) |
Allows the user to select a locale rather than using setDefaults("locale", ...) |
bootbox.hideAll() |
Hide all currently active bootbox dialogs. Individual dialogs can be closed as per normal Bootstrap dialogs |
Plugin info
| Property | Description |
|---|---|
| File name | bootbox.min.js |
| Location | assets/js/plugins/notifications/ |
| Updates | 0 |
| Links | Github project page |
Overview
jGrowl is a jQuery plugin that raises unobtrusive messages within the browser, similar to the way that OS X's Growl Framework works. The idea is simple, deliver notifications to the end user in a noticeable way that doesn't obstruct the work flow and yet keeps the user informed.
Usage
Include the following lines of code in the
section of your HTML:

Call the plugin via JavaScript:
// Sample 1
$.jGrowl("Hello world!");
// Sample 2
$.jGrowl("Stick this!", {
sticky: true
});
// Sample 3
$.jGrowl("A message with a header", {
header: 'Important'
});
// Sample 4
$.jGrowl("A message that will live a little longer.", {
life: 10000
});
// Sample 5
$.jGrowl("A message with a beforeOpen callback and a different opening animation.", {
beforeClose: function(e,m) {
alert('About to close this notification!');
},
animateOpen: {
height: 'show'
}
});
Plugin options
| Option | Default | Description |
|---|---|---|
pool |
0 | Limit the number of messages appearing at a given time to the number in the pool |
header |
empty | Optional header to prefix the message, this is often helpful for associating messages to each other |
group |
empty | A css class to be applied to notifications when they are created, useful for 'grouping' notifications by a css selector |
sticky |
false | When set to true a message will stick to the screen until it is intentionally closed by the user |
position |
top-right | Designates a class which is applied to the jGrowl container and controls its position on the screen. By Default there are five options available, top-left, top-right, bottom-left, bottom-right, center. This must be changed in the defaults before the startup method is called |
appendTo |
body | The element where our jGrowl messages are appended to. The default is body but feel free to define another one |
glue |
after | Designates whether a jGrowl notification should be appended to the container after all notifications, or whether it should be prepended to the container before all notifications. Options are after or before |
theme |
default | A CSS class designating custom styling for this particular message, intended for use with jQuery UI |
themeState |
highlight | A CSS class designating custom styling for this particular message and its state, intended for use with jQuery UI |
corners |
10px | If the corners jQuery plugin is include this option specifies the curvature radius to be used for the notifications as they are created |
check |
250 | The frequency that jGrowl should check for messages to be scrubbed from the screen.This must be changed in the defaults before the startup method is called |
life |
3000 | The lifespan of a non-sticky message on the screen |
closeDuration |
normal | The animation speed used to close a notification |
openDuration |
normal | The animation speed used to open a notification |
easing |
swing | The easing method to be used with the animation for opening and closing a notification |
closer |
true | Whether or not the close-all button should be used when more then one notification appears on the screen. Optionally this property can be set to a function which will be used as a callback when the close all button is clicked. This must be changed in the defaults before the startup method is called |
closeTemplate |
× | This content is used for the individual notification close links that are added to the corner of a notification. This must be changed in the defaults before the startup method is called |
closerTemplate |

[ close all ]
 | This content is used for the close-all link that is added to the bottom of a jGrowl container when it contains more than one notification. This must be changed in the defaults before the startup method is called |
log |
function(e,m,o) {} | Callback to be used before anything is done with the notification. This is intended to be used if the user would like to have some type of logging mechanism for all notifications passed to jGrowl. This callback receives the notification's DOM context, the notifications message and its option object |
beforeOpen |
function(e,m,o) {} | Callback to be used before a new notification is opened. This callback receives the notification's DOM context, the notifications message and its option object |
afterOpen |
function(e,m,o) {} | Callback to be used after a new notification is opened. This callback receives the notification's DOM context, the notifications message and its option object |
open |
function(e,m,o) {} | Callback to be used when a new notification is opened. This callback receives the notification's DOM context, the notifications message and its option object |
beforeClose |
function(e,m,o) {} | Callback to be used before a new notification is closed. This callback receives the notification's DOM context, the notifications message and its option object |
close |
function(e,m,o) {} | Callback to be used when a new notification is closed. This callback receives the notification's DOM context, the notifications message and its option object |
animateOpen |
{ opacity: 'show' } | The animation properties to use when opening a new notification (default to fadeOut ) |
animateClose |
{ opacity: 'hide' } | The animation properties to use when closing a new notification (defaults to fadeIn ) |
Plugin info
| Property | Description |
|---|---|
| File name | jgrowl.min.js |
| Location | assets/js/plugins/notifications/ |
| Updates | 0 |
| Links | Github project page |
Overview
NOTY is a jQuery plugin that makes it easy to create alert - success - error - warning - information - confirmation messages as an alternative the standard alert dialog. Each notification is added to a queue. The notifications can be positioned at the: top - topLeft - topCenter - topRight - center - centerLeft - centerRight - bottom - bottomLeft - bottomCenter - bottomRight.
Usage
Include the following lines of code in the
section of your HTML:

Call the plugin via JavaScript:
// Basic initialization
var n = noty({
text: 'noty - a jquery notification library!'
});
Plugin options and defaults
// Options and defaults
$.noty.defaults = {
layout: 'top',
theme: 'defaultTheme',
type: 'alert', // alert, success, error, warning, information, confirm
text: '', // can be html or string
dismissQueue: true, // If you want to use queue feature set this true
template: '

',
animation: {
open: {height: 'toggle'}, // or Animate.css class names like: 'animated bounceInLeft'
close: {height: 'toggle'}, // or Animate.css class names like: 'animated bounceOutLeft'
easing: 'swing',
speed: 500 // opening & closing animation speed
},
timeout: false, // delay for closing event. Set false for sticky notifications
force: false, // adds notification to the beginning of queue when set to true
modal: false,
maxVisible: 5, // you can set max visible notification for dismissQueue true option,
killer: false, // for close all notifications before show
closeWith: ['click'], // ['click', 'button', 'hover', 'backdrop'] // backdrop click will close all notifications
callback: {
onShow: function() {},
afterShow: function() {},
onClose: function() {},
afterClose: function() {},
onCloseClick: function() {},
},
buttons: false // an array of buttons
};
Plugin API
| Option | Description |
|---|---|
$.noty.get(id) |
Returns a NOTY javascript object |
$.noty.close(id) |
Close a NOTY - same as var n = noty({text: 'Hi!'})); n.close(); |
$.noty.clearQueue() |
Clears the notification queue |
$.noty.closeAll() |
Close all notifications |
$.noty.setText(id, text) |
Notification text updater - same as var n = noty({text: 'Hi!'})); n.setText('Hi again!'); |
$.noty.setType(id, type) |
Notification type updater - same as var n = noty({text: 'Hi!'})); n.setType('error'); |
Plugin info
| Property | Description |
|---|---|
| File name | noty.min.js |
| Location | assets/js/plugins/notifications/ |
| Updates | 0 |
| Links | Github project page |
Overview
PNotify is a JavaScript notification plugin, developed by SciActive. Formerly known as Pines Notify. It is designed to provide an unparalleled level of flexibility, while still being very easy to implement and use. PNotify provides desktop notifications based on the Web Notifications Draft
. If desktop notifications are not available or not allowed, PNotify will fall back to displaying the notice as a regular, in-browser notice.
Usage
Include the following lines of code in the
section of your HTML:

Call the plugin via JavaScript:
// Initialization sample
$(function(){
new PNotify({
title: 'Regular Notice',
text: 'Check me out! I\'m a notice.'
});
});
Plugin options
| Option | Default | Description |
|---|---|---|
title |
false | The notice's title |
title_escape |
false | Whether to escape the content of the title. (HTML not allowed) |
text |
false | The notice's text |
text_escape |
false | Whether to escape the content of the text. (HTML not allowed) |
styling |
"brighttheme" | What styling classes to use. (Can be either "brighttheme" , "jqueryui" , "bootstrap2" , "bootstrap3" , "fontawesome" , or a custom style object) |
addclass |
"" | Additional classes to be added to the notice |
cornerclass |
"" | Class to be added to the notice for corner styling |
auto_display |
true | Display the notice when it is created. Turn this off to add notifications to the history without displaying them |
width |
"300px" | Width of the notice |
min_height |
"16px" | Minimum height of the notice. It will expand to fit content |
type |
"notice" | Type of the notice. "notice" , "info" , "success" , or "error" |
icon |
true | Set icon to true to use the default icon for the selected style/type, false for no icon, or a string for your own icon class |
animation |
"fade" | The animation to use when displaying and hiding the notice. "none" , "show" , "fade" , and "slide" are built in to jQuery. Others require jQuery UI. Use an object with effect_in and effect_out to use different effects |
animate_speed |
"slow" | Speed at which the notice animates in and out. "slow" , "def" or "normal" , "fast" or number of milliseconds |
position_animate_speed |
500 | Specify a specific duration of position animation |
opacity |
1 | Opacity of the notice |
shadow |
true | Display a drop shadow |
hide |
true | After a delay, remove the notice |
delay |
8000 | Delay in milliseconds before the notice is removed |
mouse_reset |
true | Reset the hide timer if the mouse moves over the notice |
remove |
true | Remove the notice's elements from the DOM after it is removed |
insert_brs |
true | Change new lines to br tags |
stack |
- | The stack on which the notices will be placed. Also controls the direction the notices stack |
Plugin modules
| Option | Default | Description |
|---|---|---|
Desktop. desktop: {...} |
||
desktop |
false | Display the notification as a desktop notification |
fallback |
true | If desktop notifications are not supported or allowed, fall back to a regular notice |
icon |
null | The URL of the icon to display. If false , no icon will show. If null , a default icon will show |
tag |
null | Using a tag lets you update an existing notice, or keep from duplicating notices between tabs. If you leave tag null, one will be generated, facilitating the "update" function |
Buttons. buttons: {...} |
||
closer |
true | Provide a button for the user to manually close the notice |
closer_hover |
true | Only show the closer button on hover |
sticker |
true | Provide a button for the user to manually stick the notice |
sticker_hover |
true | Only show the sticker button on hover |
show_on_nonblock |
false | Show the buttons even when the nonblock module is in use |
labels |
{close: "Close", stick: "Stick"} | Lets you change the displayed text, facilitating internationalization |
NonBlock. nonblock: {...} |
||
nonblock |
false | Create a non-blocking notice. It lets the user click elements underneath it |
nonblock_opacity |
0.2 | The opacity of the notice (if it's non-blocking) when the mouse is over it |
Confirm. confirm: {...} |
||
confirm |
false | Make a confirmation box |
prompt |
false | Make a prompt |
prompt_class |
"" | Classes to add to the input element of the prompt |
prompt_default |
"" | The default value of the prompt |
prompt_multi_line |
false | Whether the prompt should accept multiple lines of text |
align |
"right" | Where to align the buttons. (right, center, left, justify) |
buttons |
[{text: "Ok", addClass: "", promptTrigger: true, click: function(notice, value){ notice.remove(); notice.get().trigger("pnotify.confirm", [notice, value]); }},{text: "Cancel", addClass: "", click: function(notice){ notice.remove(); notice.get().trigger("pnotify.cancel", notice); }}] | The buttons to display, and their callbacks. If a button has promptTrigger set to true, it will be triggered when the user hits enter in a single line prompt |
History. history: {...} |
||
history |
true | Place the notice in the history |
menu |
false | Display a pull down menu to redisplay previous notices |
fixed |
true | Make the pull down menu fixed to the top of the viewport |
maxonscreen |
Infinity | Maximum number of notifications to have onscreen |
labels |
{redisplay: "Redisplay", all: "All", last: "Last"} | Lets you change the displayed text, facilitating internationalization |
Reference. reference: {...} |
||
putThing |
false | Maximum number of notifications to have onscreen |
labels |
{text: "Spin Around"} | Provide a thing for stuff. Turned off by default |
Plugin callbacks
The callback options all expect one argument, a function, which will be called when that event occurs. They can be included in the options object passed to PNotify() just like any other options. If the function returns false on the "before_open" or "before_close" callback, that event will be canceled.
| Callback | Description |
|---|---|
before_init |
This option is called before the notice has been initialized. It accepts one argument, the options object |
after_init |
This option is called after the notice has been initialized. It accepts one argument, the notice object |
before_open |
This option is called before the notice has been displayed. It accepts one argument, the notice object |
after_open |
This option is called after the notice has been displayed. It accepts one argument, the notice object |
before_close |
This option is called before the notice closes. It accepts one argument, the notice object |
after_close |
This option is called after the notice closes. It accepts one argument, the notice object |
Plugin info
| Property | Description |
|---|---|
| File name | pnotify.min.js |
| Location | assets/js/plugins/notifications/ |
| Updates | 0 |
| Links | Github project page |
Overview
Sweet Alert is a JavaScript notification plugin for a beautiful alert replacement. SweetAlert automatically centers itself on the page and looks great no matter if you're using a desktop computer, mobile or tablet.
Usage
Include the following lines of code in the
section of your HTML:

Call the plugin via JavaScript:
// Basic initialization
swal("Oops...", "Something went wrong!", "error");
More advanced example - a warning message, with a function attached to the "Confirm"
button:
// Advanced initialization
swal({
title: "Are you sure?",
text: "You will not be able to recover this imaginary file!",
type: "warning",
showCancelButton: true,
confirmButtonColor: "#DD6B55",
confirmButtonText: "Yes, delete it!",
closeOnConfirm: false,
html: false
}, function() {
swal(
"Deleted!",
"Your imaginary file has been deleted.",
"success"
);
});
Plugin options
| Option | Default | Description |
|---|---|---|
title |
null (required) | The title of the modal. It can either be added to the object under the key "title" or passed as the first parameter of the function |
text |
null | A description for the modal. It can either be added to the object under the key "text" or passed as the second parameter of the function |
type |
null | The type of the modal. SweetAlert comes with 4 built-in types which will show a corresponding icon animation: "warning" , "error" , "success" and "info" . You can also set it as "input" to get a prompt modal. It can either be put in the object under the key "type" or passed as the third parameter of the function |
allowEscapeKey |
true | If set to true , the user can dismiss the modal by pressing the escape key |
customClass |
null | A custom CSS class for the modal. It can be added to the object under the key "customClass" |
allowOutsideClick |
false | If set to true , the user can dismiss the modal by clicking outside it |
showCancelButton |
false | If set to true , a "Cancel" button will be shown, which the user can click on to dismiss the modal |
showConfirmButton |
true | If set to false , the "OK/Confirm" button will be hidden. Make sure you set a timer or set allowOutsideClick to true when using this, in order not to annoy the user |
confirmButtonText |
"OK" | Use this to change the text on the "Confirm" button. If showCancelButton is set as true , the confirm button will automatically show "Confirm" instead of "OK" |
confirmButtonColor |
"#AEDEF4" | Use this to change the background color of the "Confirm" button (must be a HEX value) |
cancelButtonText |
"Cancel" | Use this to change the text on the "Cancel" button |
closeOnConfirm |
true | Set to false if you want the modal to stay open even if the user presses the "Confirm" button. This is especially useful if the function attached to the "Confirm" button is another SweetAlert |
closeOnCancel |
true | Same as closeOnConfirm , but for the cancel button |
imageUrl |
null | Add a customized icon for the modal. Should contain a string with the path to the image |
imageSize |
"80x80" | If imageUrl is set, you can specify imageSize to describes how big you want the icon to be in px. Pass in a string with two values separated by an "x". The first value is the width , the second is the height |
timer |
null | Auto close timer of the modal. Set in ms (milliseconds) |
html |
false | If set to true , will not escape title and text parameters. (Set to false if you're worried about XSS attacks.) |
animation |
true | If set to false , the modal's animation will be disabled. Possible (string) values: pop (default when animation set to true ), slide-from-top , slide-from-bottom |
inputType |
"text" | Change the type of the input field when using type: "input" (this can be useful if you want users to type in their password for example). |
inputPlaceholder |
null | When using the input-type, you can specify a placeholder to help the user |
inputValue |
null | Specify a default text value that you want your input to show when using type: "input" |
showLoaderOnConfirm |
false | Set to true to disable the buttons and show that something is loading |
Plugin methods
SweetAlert also comes with some simple methods that you can call:
| Callback | Example | Description |
|---|---|---|
setDefaults |
swal.setDefaults({ confirmButtonColor: '#0000' }); | If you end up using a lot of the same settings when calling SweetAlert, you can use setDefaults at the start of your program to set them once and for all! |
close |
swal.close(); | Close the currently open SweetAlert programatically |
showInputError |
swal.showInputError("Invalid email!"); | Show an error message after validating the input field, if the user's data is bad |
enableButtons, disableButtons |
swal.disableButtons(); | Disable or enable the user to click on the cancel and confirm buttons |
Plugin info
| Property | Description |
|---|---|
| File name | sweet_alert.min.js |
| Location | assets/js/plugins/notifications/ |
| Updates | 0 |
| Links | Github project page |


It is possible to have more than one SICStus run-time in a single process. These are completely independent (except that they dynamically load the same foreign resources; see Foreign Resources and Multiple SICStus Run-Times).
Even though the SICStus run-time can only be run in a single thread, it is now possible to start several SICStus run-times, optionally each in its own thread.
SICStus run-times are rather heavy weight and you should not expect to be able to run more than a handful.


The Iliad
by Homer
Book 12: The Battle at the Grecian Wall
Additional Information
- Year Published: 1899
- Language: English
- Country of Origin: Greece
- Source: Homer. (1899). The Iliad. Boston, MA; B.H. Stanton.
-
Readability:
- Flesch–Kincaid Level: 6.4
- Word Count: 4,625
- Genre: Epic
- Keywords: destiny, fate, glory, honor
- ✎ Cite This
Downloads
The Greeks having retired into their intrenchments, Hector attempts to force them; but it proving impossible to pass the ditch, Polydamas advises to quit their chariots, and manage the attack on foot. The Trojans follow his counsel; and having divided their army into five bodies of foot, begin the assault. But upon the signal of an eagle with a serpent in his talons, which appeared on the left hand of the Trojans, Polydamas endeavours to withdraw them again. This Hector opposes, and continues the attack; in which, after many actions, Sarpedon makes the first breach in the wall. Hector also, casting a stone of vast size, forces open one of the gates, and enters at the head of his troops, who victoriously pursue the Grecians even to their ships.
While thus the hero's pious cares attend
The cure and safety of his wounded friend,
Trojans and Greeks with clashing shields engage,
And mutual deaths are dealt with mutual rage.
Nor long the trench or lofty walls oppose;
With gods averse the ill–fated works arose;
Their powers neglected, and no victim slain,
The walls were raised, the trenches sunk in vain.
Without the gods, how short a period stands
The proudest monument of mortal hands!
This stood while Hector and Achilles raged.
While sacred Troy the warring hosts engaged;
But when her sons were slain, her city burn'd,
And what survived of Greece to Greece return'd;
Then Neptune and Apollo shook the shore,
Then Ida's summits pour'd their watery store;
Rhesus and Rhodius then unite their rills,
Caresus roaring down the stony hills,
Æsepus, Granicus, with mingled force,
And Xanthus foaming from his fruitful source;
And gulfy Simois, rolling to the main
Helmets, and shields, and godlike heroes slain:
These, turn'd by Phoebus from their wonted ways,
Deluged the rampire nine continual days;
The weight of waters saps the yielding wall,
And to the sea the floating bulwarks fall.
Incessant cataracts the Thunderer pours,
And half the skies descend in sluicy showers.
The god of ocean, marching stern before,
With his huge trident wounds the trembling shore,
Vast stones and piles from their foundation heaves,
And whelms the smoky ruin in the waves.
Now smooth'd with sand, and levell'd by the flood,
No fragment tells where once the wonder stood;
In their old bounds the rivers roll again,
Shine 'twixt the hills, or wander o'er the plain.
But this the gods in later times perform;
As yet the bulwark stood, and braved the storm;
The strokes yet echoed of contending powers;
War thunder'd at the gates, and blood distain'd the towers.
Smote by the arm of Jove with dire dismay,
Close by their hollow ships the Grecians lay:
Hector's approach in every wind they hear,
And Hector's fury every moment fear.
He, like a whirlwind, toss'd the scattering throng,
Mingled the troops, and drove the field along.
So 'midst the dogs and hunters' daring bands,
Fierce of his might, a boar or lion stands;
Arm'd foes around a dreadful circle form,
And hissing javelins rain an iron storm:
His powers untamed, their bold assault defy,
And where he turns the rout disperse or die:
He foams, he glares, he bounds against them all,
And if he falls, his courage makes him fall.
With equal rage encompass'd Hector glows;
Exhorts his armies, and the trenches shows.
The panting steeds impatient fury breathe,
And snort and tremble at the gulf beneath;
Just at the brink they neigh, and paw the ground,
And the turf trembles, and the skies resound.
Eager they view'd the prospect dark and deep,
Vast was the leap, and headlong hung the steep;
The bottom bare, (a formidable show!)
And bristled thick with sharpen'd stakes below.
The foot alone this strong defence could force,
And try the pass impervious to the horse.
This saw Polydamas; who, wisely brave,
Restrain'd great Hector, and this counsel gave:
"O thou, bold leader of the Trojan bands!
And you, confederate chiefs from foreign lands!
What entrance here can cumbrous chariots find,
The stakes beneath, the Grecian walls behind?
No pass through those, without a thousand wounds,
No space for combat in yon narrow bounds.
Proud of the favours mighty Jove has shown,
On certain dangers we too rashly run:
If 'tis will our haughty foes to tame,
Oh may this instant end the Grecian name!
Here, far from Argos, let their heroes fall,
And one great day destroy and bury all!
But should they turn, and here oppress our train,
What hopes, what methods of retreat remain?
Wedged in the trench, by our own troops confused,
In one promiscuous carnage crush'd and bruised,
All Troy must perish, if their arms prevail,
Nor shall a Trojan live to tell the tale.
Hear then, ye warriors! and obey with speed;
Back from the trenches let your steeds be led;
Then all alighting, wedged in firm array,
Proceed on foot, and Hector lead the way.
So Greece shall stoop before our conquering power,
And this (if Jove consent) her fatal hour."
This counsel pleased: the godlike Hector sprung
Swift from his seat; his clanging armour rung.
The chief's example follow'd by his train,
Each quits his car, and issues on the plain,
By orders strict the charioteers enjoin'd
Compel the coursers to their ranks behind.
The forces part in five distinguish'd bands,
And all obey their several chiefs' commands.
The best and bravest in the first conspire,
Pant for the fight, and threat the fleet with fire:
Great Hector glorious in the van of these,
Polydamas, and brave Cebriones.
Before the next the graceful Paris shines,
And bold Alcathous, and Agenor joins.
The sons of Priam with the third appear,
Deiphobus, and Helenas the seer;
In arms with these the mighty Asius stood,
Who drew from Hyrtacus his noble blood,
And whom Arisba's yellow coursers bore,
The coursers fed on Selle's winding shore.
Antenor's sons the fourth battalion guide,
And great Æneas, born on fountful Ide.
Divine Sarpedon the last band obey'd,
Whom Glaucus and Asteropaeus aid.
Next him, the bravest, at their army's head,
But he more brave than all the hosts he led.
Now with compacted shields in close array,
The moving legions speed their headlong way:
Already in their hopes they fire the fleet,
And see the Grecians gasping at their feet.
While every Trojan thus, and every aid,
The advice of wise Polydamas obey'd,
Asius alone, confiding in his car,
His vaunted coursers urged to meet the war.
Unhappy hero! and advised in vain;
Those wheels returning ne'er shall mark the plain;
No more those coursers with triumphant joy
Restore their master to the gates of Troy!
Black death attends behind the Grecian wall,
And great Idomeneus shall boast thy fall!
Fierce to the left he drives, where from the plain
The flying Grecians strove their ships to gain;
Swift through the wall their horse and chariots pass'd,
The gates half–open'd to receive the last.
Thither, exulting in his force, he flies:
His following host with clamours rend the skies:
To plunge the Grecians headlong in the main,
Such their proud hopes; but all their hopes were vain!
To guard the gates, two mighty chiefs attend,
Who from the Lapiths' warlike race descend;
This Polypoetes, great Perithous' heir,
And that Leonteus, like the god of war.
As two tall oaks, before the wall they rise;
Their roots in earth, their heads amidst the skies:
Whose spreading arms with leafy honours crown'd,
Forbid the tempest, and protect the ground;
High on the hills appears their stately form,
And their deep roots for ever brave the storm.
So graceful these, and so the shock they stand
Of raging Asius, and his furious band.

Even when they saw Troy's sable troops impend,
And Greece tumultuous from her towers descend,
Forth from the portals rush'd the intrepid pair,
Opposed their breasts, and stood themselves the war.

Around their heads the whistling javelins sung,
With sounding strokes their brazen targets rung;
Fierce was the fight, while yet the Grecian powers
Maintain'd the walls, and mann'd the lofty towers:
To save their fleet their last efforts they try,
And stones and darts in mingled tempests fly.
As when sharp Boreas blows abroad, and brings
The dreary winter on his frozen wings;
Beneath the low–hung clouds the sheets of snow
Descend, and whiten all the fields below:
So fast the darts on either army pour,
So down the rampires rolls the rocky shower:
Heavy, and thick, resound the batter'd shields,
And the deaf echo rattles round the fields.
With shame repulsed, with grief and fury driven,
The frantic Asius thus accuses Heaven:
"In powers immortal who shall now believe?
Can those too flatter, and can Jove deceive?
What man could doubt but Troy's victorious power
Should humble Greece, and this her fatal hour?
But like when wasps from hollow crannies drive,
To guard the entrance of their common hive,
Darkening the rock, while with unwearied wings
They strike the assailants, and infix their stings;
A race determined, that to death contend:
So fierce these Greeks their last retreats defend.
Gods! shall two warriors only guard their gates,
Repel an army, and defraud the fates?"
These empty accents mingled with the wind,
Nor moved great Jove's unalterable mind;
To godlike Hector and his matchless might
Was owed the glory of the destined fight.
Like deeds of arms through all the forts were tried,
And all the gates sustain'd an equal tide;
Through the long walls the stony showers were heard,
The blaze of flames, the flash of arms appear'd.
The spirit of a god my breast inspire,
To raise each act to life, and sing with fire!
While Greece unconquer'd kept alive the war,
Secure of death, confiding in despair;
And all her guardian gods, in deep dismay,
With unassisting arms deplored the day.
Even yet the dauntless Lapithae maintain
The dreadful pass, and round them heap the slain.
First Damasus, by Polypoetes' steel,
Pierced through his helmet's brazen visor, fell;
The weapon drank the mingled brains and gore!
The warrior sinks, tremendous now no more!
Next Ormenus and Pylon yield their breath:
Nor less Leonteus strews the field with death;
First through the belt Hippomachus he gored,
Then sudden waved his unresisted sword:
Antiphates, as through the ranks he broke,
The falchion struck, and fate pursued the stroke:
Iamenus, Orestes, Menon, bled;
And round him rose a monument of dead.
Meantime, the bravest of the Trojan crew,
Bold Hector and Polydamas, pursue;
Fierce with impatience on the works to fall,
And wrap in rolling flames the fleet and wall.
These on the farther bank now stood and gazed,
By Heaven alarm'd, by prodigies amazed:
A signal omen stopp'd the passing host,
Their martial fury in their wonder lost.
Jove's bird on sounding pinions beat the skies;
A bleeding serpent of enormous size,
His talons truss'd; alive, and curling round,
He stung the bird, whose throat received the wound:
Mad with the smart, he drops the fatal prey,
In airy circles wings his painful way,
Floats on the winds, and rends the heaven with cries:
Amidst the host the fallen serpent lies.
They, pale with terror, mark its spires unroll'd,
And Jove's portent with beating hearts behold.
Then first Polydamas the silence broke,
Long weigh'd the signal, and to Hector spoke:
"How oft, my brother, thy reproach I bear,
For words well meant, and sentiments sincere?
True to those counsels which I judge the best,
I tell the faithful dictates of my breast.
To speak his thoughts is every freeman's right,
In peace, in war, in council, and in fight;
And all I move, deferring to thy sway,
But tends to raise that power which I obey.
Then hear my words, nor may my words be vain!
Seek not this day the Grecian ships to gain;
For sure, to warn us, Jove his omen sent,
And thus my mind explains its clear event:
The victor eagle, whose sinister flight
Retards our host, and fills our hearts with fright,
Dismiss'd his conquest in the middle skies,
Allow'd to seize, but not possess the prize;
Thus, though we gird with fires the Grecian fleet,
Though these proud bulwalks tumble at our feet,
Toils unforeseen, and fiercer, are decreed;
More woes shall follow, and more heroes bleed.
So bodes my soul, and bids me thus advise;
For thus a skilful seer would read the skies."
To him then Hector with disdain return'd:
(Fierce as he spoke, his eyes with fury burn'd:)
"Are these the faithful counsels of thy tongue?
Thy will is partial, not thy reason wrong:
Or if the purpose of thy heart thou vent,
Sure heaven resumes the little sense it lent.
What coward counsels would thy madness move
Against the word, the will reveal'd of Jove?
The leading sign, the irrevocable nod,
And happy thunders of the favouring god,
These shall I slight, and guide my wavering mind
By wandering birds that flit with every wind?
Ye vagrants of the sky! your wings extend,
Or where the suns arise, or where descend;
To right, to left, unheeded take your way,
While I the dictates of high heaven obey.
Without a sign his sword the brave man draws,
And asks no omen but his country's cause.
But why should'st thou suspect the war's success?
None fears it more, as none promotes it less:
Though all our chiefs amidst yon ships expire,
Trust thy own cowardice to escape their fire.
Troy and her sons may find a general grave,
But thou canst live, for thou canst be a slave.
Yet should the fears that wary mind suggests
Spread their cold poison through our soldiers' breasts,
My javelin can revenge so base a part,
And free the soul that quivers in thy heart."
Furious he spoke, and, rushing to the wall,
Calls on his host; his host obey the call;
With ardour follow where their leader flies:
Redoubling clamours thunder in the skies.
Jove breathes a whirlwind from the hills of Ide,
And drifts of dust the clouded navy hide;
He fills the Greeks with terror and dismay,
And gives great Hector the predestined day.
Strong in themselves, but stronger in his aid,
Close to the works their rigid siege they laid.
In vain the mounds and massy beams defend,
While these they undermine, and those they rend;
Upheaved the piles that prop the solid wall;
And heaps on heaps the smoky ruins fall.
Greece on her ramparts stands the fierce alarms;
The crowded bulwarks blaze with waving arms,
Shield touching shield, a long refulgent row;
Whence hissing darts, incessant, rain below.
The bold Ajaces fly from tower to tower,
And rouse, with flame divine, the Grecian power.
The generous impulse every Greek obeys;
Threats urge the fearful; and the valiant, praise.
"Fellows in arms! whose deeds are known to fame,
And you, whose ardour hopes an equal name!
Since not alike endued with force or art;
Behold a day when each may act his part!
A day to fire the brave, and warm the cold,
To gain new glories, or augment the old.
Urge those who stand, and those who faint, excite;
Drown Hector's vaunts in loud exhorts of fight;
Conquest, not safety, fill the thoughts of all;
Seek not your fleet, but sally from the wall;
So Jove once more may drive their routed train,
And Troy lie trembling in her walls again."
Their ardour kindles all the Grecian powers;
And now the stones descend in heavier showers.
As when high Jove his sharp artillery forms,
And opes his cloudy magazine of storms;
In winter's bleak un comfortable reign,
A snowy inundation hides the plain;
He stills the winds, and bids the skies to sleep;
Then pours the silent tempest thick and deep;
And first the mountain–tops are cover'd o'er,
Then the green fields, and then the sandy shore;
Bent with the weight, the nodding woods are seen,
And one bright waste hides all the works of men:
The circling seas, alone absorbing all,
Drink the dissolving fleeces as they fall:
So from each side increased the stony rain,
And the white ruin rises o'er the plain.
Thus godlike Hector and his troops contend
To force the ramparts, and the gates to rend:
Nor Troy could conquer, nor the Greeks would yield,
Till great Sarpedon tower'd amid the field;
For mighty Jove inspired with martial flame
His matchless son, and urged him on to fame.
In arms he shines, conspicuous from afar,
And bears aloft his ample shield in air;
Within whose orb the thick bull–hides were roll'd,
Ponderous with brass, and bound with ductile gold:
And while two pointed javelins arm his hands,
Majestic moves along, and leads his Lycian bands.
So press'd with hunger, from the mountain's brow
Descends a lion on the flocks below;
So stalks the lordly savage o'er the plain,
In sullen majesty, and stern disdain:
In vain loud mastiffs bay him from afar,
And shepherds gall him with an iron war;
Regardless, furious, he pursues his way;
He foams, he roars, he rends the panting prey.
Resolved alike, divine Sarpedon glows
With generous rage that drives him on the foes.
He views the towers, and meditates their fall,
To sure destruction dooms the aspiring wall;
Then casting on his friend an ardent look,
Fired with the thirst of glory, thus he spoke:
"Why boast we, Glaucus! our extended reign,
Where Xanthus' streams enrich the Lycian plain,
Our numerous herds that range the fruitful field,
And hills where vines their purple harvest yield,
Our foaming bowls with purer nectar crown'd,
Our feasts enhanced with music's sprightly sound?
Why on those shores are we with joy survey'd,
Admired as heroes, and as gods obey'd,
Unless great acts superior merit prove,
And vindicate the bounteous powers above?
'Tis ours, the dignity they give to grace;
The first in valour, as the first in place;
That when with wondering eyes our martial bands
Behold our deeds transcending our commands,
Such, they may cry, deserve the sovereign state,
Whom those that envy dare not imitate!
Could all our care elude the gloomy grave,
Which claims no less the fearful and the brave,
For lust of fame I should not vainly dare
In fighting fields, nor urge thy soul to war.
But since, alas! ignoble age must come,
Disease, and death's inexorable doom
The life, which others pay, let us bestow,
And give to fame what we to nature owe;
Brave though we fall, and honour'd if we live,
Or let us glory gain, or glory give!"
He said; his words the listening chief inspire
With equal warmth, and rouse the warrior's fire;
The troops pursue their leaders with delight,
Rush to the foe, and claim the promised fight.
Menestheus from on high the storm beheld
Threatening the fort, and blackening in the field:
Around the walls he gazed, to view from far
What aid appear'd to avert the approaching war,
And saw where Teucer with the Ajaces stood,
Of fight insatiate, prodigal of blood.
In vain he calls; the din of helms and shields
Rings to the skies, and echoes through the fields,
The brazen hinges fly, the walls resound,
Heaven trembles, roar the mountains, thunders all the ground
Then thus to Thoos: "Hence with speed (he said),
And urge the bold Ajaces to our aid;
Their strength, united, best may help to bear
The bloody labours of the doubtful war:
Hither the Lycian princes bend their course,
The best and bravest of the hostile force.
But if too fiercely there the foes contend,
Let Telamon, at least, our towers defend,
And Teucer haste with his unerring bow
To share the danger, and repel the foe."
Swift, at the word, the herald speeds along
The lofty ramparts, through the martial throng,
And finds the heroes bathed in sweat and gore,
Opposed in combat on the dusty shore.
"Ye valiant leaders of our warlike bands!
Your aid (said Thoos) Peteus' son demands;
Your strength, united, best may help to bear
The bloody labours of the doubtful war:
Thither the Lycian princes bend their course,
The best and bravest of the hostile force.
But if too fiercely, here, the foes contend,
At least, let Telamon those towers defend,
And Teucer haste with his unerring bow
To share the danger, and repel the foe."

With equal steps bold Teucer press'd the shore,
Whose fatal bow the strong Pandion bore.
High on the walls appear'd the Lycian powers,
Like some black tempest gathering round the towers:
The Greeks, oppress'd, their utmost force unite,
Prepared to labour in the unequal fight:
The war renews, mix'd shouts and groans arise;
Tumultuous clamour mounts, and thickens in the skies.
Fierce Ajax first the advancing host invades,
And sends the brave Epicles to the shades,
Sarpedon's friend. Across the warrior's way,
Rent from the walls, a rocky fragment lay;
In modern ages not the strongest swain
Could heave the unwieldy burden from the plain:
He poised, and swung it round; then toss'd on high,
It flew with force, and labour'd up the sky;
Full on the Lycian's helmet thundering down,
The ponderous ruin crush'd his batter'd crown.
As skilful divers from some airy steep
Headlong descend, and shoot into the deep,
So falls Epicles; then in groans expires,
And murmuring to the shades the soul retires.
While to the ramparts daring Glaucus drew,
From Teucer's hand a winged arrow flew;
The bearded shaft the destined passage found,
And on his naked arm inflicts a wound.
The chief, who fear'd some foe's insulting boast
Might stop the progress of his warlike host,
Conceal'd the wound, and, leaping from his height
Retired reluctant from the unfinish'd fight.
Divine Sarpedon with regret beheld
Disabled Glaucus slowly quit the field;
His beating breast with generous ardour glows,
He springs to fight, and flies upon the foes.
Alcmaon first was doom'd his force to feel;
Deep in his breast he plunged the pointed steel;
Then from the yawning wound with fury tore
The spear, pursued by gushing streams of gore:
Down sinks the warrior with a thundering sound,
His brazen armour rings against the ground.
Swift to the battlement the victor flies,
Tugs with full force, and every nerve applies:
It shakes; the ponderous stones disjointed yield;
The rolling ruins smoke along the field.

At once bold Teucer draws the twanging bow,
And Ajax sends his javelin at the foe;
Fix'd in his belt the feather'd weapon stood,
And through his buckler drove the trembling wood;
But Jove was present in the dire debate,
To shield his offspring, and avert his fate.
The prince gave back, not meditating flight,
But urging vengeance, and severer fight;
Then raised with hope, and fired with glory's charms,
His fainting squadrons to new fury warms.
"O where, ye Lycians, is the strength you boast?
Your former fame and ancient virtue lost!
The breach lies open, but your chief in vain
Attempts alone the guarded pass to gain:
Unite, and soon that hostile fleet shall fall:
The force of powerful union conquers all."
This just rebuke inflamed the Lycian crew;
They join, they thicken, and the assault renew:
Unmoved the embodied Greeks their fury dare,
And fix'd support the weight of all the war;
Nor could the Greeks repel the Lycian powers,
Nor the bold Lycians force the Grecian towers.
As on the confines of adjoining grounds,
Two stubborn swains with blows dispute their bounds;
They tug, they sweat; but neither gain, nor yield,
One foot, one inch, of the contended field;
Thus obstinate to death, they fight, they fall;
Nor these can keep, nor those can win the wall.
Their manly breasts are pierced with many a wound,
Loud strokes are heard, and rattling arms resound;
The copious slaughter covers all the shore,
And the high ramparts drip with human gore.
As when two scales are charged with doubtful loads,
From side to side the trembling balance nods,
(While some laborious matron, just and poor,
With nice exactness weighs her woolly store,)
Till poised aloft, the resting beam suspends
Each equal weight; nor this, nor that, descends:
So stood the war, till Hector's matchless might,
With fates prevailing, turn'd the scale of fight.
Fierce as a whirlwind up the walls he flies,
And fires his host with loud repeated cries.
"Advance, ye Trojans! lend your valiant hands,
Haste to the fleet, and toss the blazing brands!"
They hear, they run; and, gathering at his call,
Raise scaling engines, and ascend the wall:
Around the works a wood of glittering spears
Shoots up, and all the rising host appears.
A ponderous stone bold Hector heaved to throw,
Pointed above, and rough and gross below:
Not two strong men the enormous weight could raise,
Such men as live in these degenerate days:
Yet this, as easy as a swain could bear
The snowy fleece, he toss'd, and shook in air;
For Jove upheld, and lighten'd of its load
The unwieldy rock, the labour of a god.
Thus arm'd, before the folded gates he came,
Of massy substance, and stupendous frame;
With iron bars and brazen hinges strong,
On lofty beams of solid timber hung:
Then thundering through the planks with forceful sway,
Drives the sharp rock; the solid beams give way,
The folds are shatter'd; from the crackling door
Leap the resounding bars, the flying hinges roar.
Now rushing in, the furious chief appears,
Gloomy as night! and shakes two shining spears:
A dreadful gleam from his bright armour came,
And from his eye–balls flash'd the living flame.
He moves a god, resistless in his course,
And seems a match for more than mortal force.
Then pouring after, through the gaping space,
A tide of Trojans flows, and fills the place;
The Greeks behold, they tremble, and they fly;
The shore is heap'd with death, and tumult rends the sky.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use IOCase | |
|---|---|
| org.apache.commons.io | This package defines utility classes for working with streams, readers, writers and files. |
| org.apache.commons.io.filefilter | This package defines an interface (IOFileFilter) that combines both
FileFilter and FilenameFilter . |
| Uses of IOCase in org.apache.commons.io |
|---|
| Fields in org.apache.commons.io declared as IOCase | |
|---|---|
static IOCase |
IOCase.INSENSITIVE
The constant for case insensitive regardless of operating system. |
static IOCase |
IOCase.SENSITIVE
The constant for case sensitive regardless of operating system. |
static IOCase |
IOCase.SYSTEM
The constant for case sensitivity determined by the current operating system. |
| Methods in org.apache.commons.io that return IOCase | |
|---|---|
static IOCase |
IOCase.forName(java.lang.String name)
Factory method to create an IOCase from a name. |
| Methods in org.apache.commons.io with parameters of type IOCase | |
|---|---|
static boolean |
FilenameUtils.equals(java.lang.String filename1,
java.lang.String filename2,
boolean normalized,
IOCase caseSensitivity)
Checks whether two filenames are equal, optionally normalizing and providing control over the case-sensitivity. |
static boolean |
FilenameUtils.wildcardMatch(java.lang.String filename,
java.lang.String wildcardMatcher,
IOCase caseSensitivity)
Checks a filename to see if it matches the specified wildcard matcher allowing control over case-sensitivity. |
| Uses of IOCase in org.apache.commons.io.filefilter |
|---|
| Constructors in org.apache.commons.io.filefilter with parameters of type IOCase | |
|---|---|
NameFileFilter(java.util.List names,
IOCase caseSensitivity)
Constructs a new name file filter for a list of names specifying case-sensitivity. |
|
NameFileFilter(java.lang.String[] names,
IOCase caseSensitivity)
Constructs a new name file filter for an array of names specifying case-sensitivity. |
|
NameFileFilter(java.lang.String name,
IOCase caseSensitivity)
Construct a new name file filter specifying case-sensitivity. |
|
WildcardFileFilter(java.util.List wildcards,
IOCase caseSensitivity)
Construct a new wildcard filter for a list of wildcards specifying case-sensitivity. |
|
WildcardFileFilter(java.lang.String[] wildcards,
IOCase caseSensitivity)
Construct a new wildcard filter for an array of wildcards specifying case-sensitivity. |
|
WildcardFileFilter(java.lang.String wildcard,
IOCase caseSensitivity)
Construct a new wildcard filter for a single wildcard specifying case-sensitivity. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


Coffee & kitties: This cat cafe is saving hundreds of cats
Step inside the café that's helping cats get adopted one cup of coffee at a time.
El Gato Coffeehouse, Houston's first and only cat café, has helped hundreds of furry felines find their forever homes.
Here, you can sip your favorite latte while cuddling with adoptable kitties - and that's not all. This unique café also offers yoga with cats, "Meowvie" night, a cat lovers' book club and painting with cats!
Cat adoption fees are $15 through Friends for Life. For more information, visit elgatocoffeehouse.com.


jQuery Mobile Single Image Display Tests
Single Image Display Tests
Single Image Display Tests
Single Image Display Tests
Single Image Display Tests
Single Image Display Tests
Single Image Display Tests
Single Image Display Tests
Single Image Display Tests


"What is the structural function of this letter? After all, it is included. But say—why the devil do you want structure?" Structure is outdated. The medium is the message.


UDAbstractDatabaseLogger Class Reference
| Inherits from | UDAbstractLogger |
|---|---|
| Declared in | UDAbstractDatabaseLogger.h |
Overview
This class provides an abstract implementation of a database logger.
That is, it provides the base implementation for a database logger to build atop of. All that is needed for a concrete database logger is to extend this class and override the methods in the implementation file that are prefixed with “db_”.
saveThreshold
Specifies how often to save the data to disk. Since saving is an expensive operation (disk io) it is not done after every log statement. These properties allow you to configure how/when the logger saves to disk.
@property (assign, readwrite) NSUInteger saveThreshold
Discussion
A save is done when either (whichever happens first):
- The number of unsaved log entries reaches saveThreshold
- The amount of time since the oldest unsaved log entry was created reaches saveInterval
You can optionally disable the saveThreshold by setting it to zero. If you disable the saveThreshold you are entirely dependent on the saveInterval.
You can optionally disable the saveInterval by setting it to zero (or a negative value). If you disable the saveInterval you are entirely dependent on the saveThreshold.
It’s not wise to disable both saveThreshold and saveInterval.
The default saveThreshold is 500. The default saveInterval is 60 seconds.
Declared In
UDAbstractDatabaseLogger.h
saveInterval
See the description for the saveThreshold
property
@property (assign, readwrite) NSTimeInterval saveInterval
Declared In
UDAbstractDatabaseLogger.h
maxAge
It is likely you don’t want the log entries to persist forever. Doing so would allow the database to grow infinitely large over time.
@property (assign, readwrite) NSTimeInterval maxAge
Discussion
The maxAge property provides a way to specify how old a log statement can get before it should get deleted from the database.
The deleteInterval specifies how often to sweep for old log entries. Since deleting is an expensive operation (disk io) is is done on a fixed interval.
An alternative to the deleteInterval is the deleteOnEverySave option. This specifies that old log entries should be deleted during every save operation.
You can optionally disable the maxAge by setting it to zero (or a negative value). If you disable the maxAge then old log statements are not deleted.
You can optionally disable the deleteInterval by setting it to zero (or a negative value).
If you disable both deleteInterval and deleteOnEverySave then old log statements are not deleted.
It’s not wise to enable both deleteInterval and deleteOnEverySave.
The default maxAge is 7 days. The default deleteInterval is 5 minutes. The default deleteOnEverySave is NO.
Declared In
UDAbstractDatabaseLogger.h
deleteInterval
See the description for the maxAge
property
@property (assign, readwrite) NSTimeInterval deleteInterval
Declared In
UDAbstractDatabaseLogger.h
deleteOnEverySave
See the description for the maxAge
property
@property (assign, readwrite) BOOL deleteOnEverySave
Declared In
UDAbstractDatabaseLogger.h
– savePendingLogEntries
Forces a save of any pending log entries (flushes log entries to disk).
- (void)savePendingLogEntries
Declared In
UDAbstractDatabaseLogger.h
– deleteOldLogEntries
Removes any log entries that are older than maxAge.
- (void)deleteOldLogEntries
Declared In
UDAbstractDatabaseLogger.h


|
Dreamroam
0.0.0
A free and open source C++ 3D GameEngine
|
A Forward+ Rendering Pipeline with post-processing support It provides features such as shadow mapping More...
#include <AdvancedRenderingPipeline.hh>
Public Member Functions | |
| LAVA_PROPERTY (Camera) | |
| LAVA_GETTER (Width) | |
| LAVA_GETTER (Height) | |
| LAVA_PROPERTY (FXAA) | |
| LAVA_PROPERTY (DitheringStrength) | |
| LAVA_PROPERTY (TransparentPass) | |
| int | getOutputWidth () const |
| int | getOutputHeight () const |
| AdvancedRenderingPipeline (SharedDevice const &device, GenericFormat outputFormat) | |
| void | resize (int w, int h) |
| Resizes the internal pipeline size. | |
| void | assignCamera (camera::SharedGenericCamera const &cam, bool useCamViewport=true) |
| void | render (lava::RecordingCommandBuffer &cmd, lava::SharedFramebuffer const &fbo, const std::function< void(lava::pipeline::AdvancedRenderPass const &pass)> &renderFunc) |
| executes the whole rendering pipeline More... | |
| SharedRenderPass const & | outputPass () const |
| Use this to create the FBOs for the Pipeline to output to. | |
| SharedRenderPass const & | prePass () const |
| Use this to create the Pipelines to render the shadow pass. | |
| SharedRenderPass const & | forwardPass () const |
| Use this to create the Pipelines to render the forward pass. | |
A Forward+ Rendering Pipeline with post-processing support It provides features such as shadow mapping


Interactively procraxstinate high-payoff content without backward-compatible data. Quickly cultivate optimal processes and tactical architectures.


Issue: WITH-OUTPUT-TO-STRING-APPEND-STYLE
References: CLtL, pages 331, 386
Category: CLARIFICATION
Edit history: Version 1, 25-Mar-88 JonL
Version 2, 29-Mar-88 JonL (fix typos; comments by Daniels)
Version 3, 23-May-88 JonL (fix nits raised by Masinter)
Version 4, 23-May-88 JonL (change issue name -- only 1 proposal)
Version 5, 7-Jun-88 Masinter (more nits)
Problem description:
CLtL p386 says that FORMATting to a fill-pointer'd string should add
characters "as if by use of VECTOR-PUSH-EXTEND"; but CLtL p331 says that
WITH-OUTPUT-TO-STRING will work "as if using VECTOR-PUSH-EXTEND if the
string is adjustable, and otherwise as if using VECTOR-PUSH". It's very
unlikely that the original authors of these parts intended differing
semantics for these two cases. Furthermore, the semantics for
WITH-OUTPUT-TO-STRING permit the inconspicuous loss of characters
written to the string, since VECTOR-PUSH will just "drop on the floor"
any characters that would go beyond the end.
Proposal (WITH-OUTPUT-TO-STRING-APPEND-STYLE:VECTOR-PUSH-EXTEND):
Change the documentation of WITH-OUTPUT-TO-STRING to be like that under
FORMAT. That is, replace the first sentence of the next-to-last paragraph
on CLtL p331 by:
"If *string* is specified, it must be a string with a fill pointer;
the output is incrementally appended to the string (as if by use of
Test Case:
(let ((str (make-array 4 :element-type 'string-char :fill-pointer 0)))
(with-output-to-string (s str) (princ "You Luz, Bunkie!" s))
str)
CLtL behaviour will return "You "; proposed behaviour will signal an error.
Rationale:
It's unlikely that the mention of VECTOR-PUSH in CLtL p331 was intended
to suggest that characters could be quietly "dropped on the floor". In
any case, there is no practical or theoretical reason to make FORMAT and
WITH-OUTPUT-TO-STRING act differently on non-adjustable strings.
Current Practice:
VaxLisp 2.2 and Lucid 3.0 implement the proposal; Lucid 2.1 and earlier
versions implement CLtL. For WITH-OUTPUT-TO-STRING, Xerox Common Lisp
implements CLtL. Symbolics Genera 7.2 implements the proposal.
Cost to Implementors:
Very small.
Cost to Users:
Virtually none.
Benefits:
Less special-casing in the semantics of "printing" to strings.
More conformity with naive expectations about printing to strings.
Aesthetics:
Minor impact.
Discussion:
Implementations may want to actually call VECTOR-PUSH, rather than
VECTOR-PUSH-EXTEND, on non-adjustable string in order to test the
result -- nil means an overflow of the total length of the string;
thus they may signal an error more directly related to the problem,
rather than permitting VECTOR-PUSH-EXTEND to complain about a non-
adjustable array. But either way, the semantics is still that of
VECTOR-PUSH-EXTEND: when you get to the end of the string, adjustable
strings are extended, and non-adjustable strings cause error signals.
It's perfectly acceptable to use VECTOR-PUSH-EXTEND with a non-adjustable
array. It's the error-signalling property of VECTOR-PUSH-EXTEND, as opposed
to the "dropping on the floor" of VECTOR-PUSH, that motivated this proposal.


Agrodolce {{IPA-it|ˌaɡroˈdoltʃe|}} is a traditional sweet and sour sauce in Italian cuisine. Its name comes from "agro" (sour) and "dolce" (sweet). Agrodolce is made by reducing sour and sweet elements, traditionally vinegar and sugar. Sometimes, additional flavorings are added, such as wine, fruit, or even chocolate. It can be used for lamb, and served over rigatoni or wide noodles, such as pappardelle.
Though the term "aigre-doux" could refer to any sweet and sour sauce in French cuisine, a gastrique is very similar to agrodolce.<ref>Slow-Cooker Lamb Stew Agrodolce</ref>
{{reflist}}
{{Italy-cuisine-stub}}
es:Salsa agridulce fr:Sauce aigre-douce he:אגרו-דולצ'ה id:Saus asam manis no:Sursøt saus sv:Sötsur sås