Consider the following pseudo code for PROTO-vEB-MAXIMUM.
PROTO-vEB-MAXIMUM (V)
// check for base condition if it is true then it contain the array A [0...1] of two bit.
1. if V.u==2
// if statement is used to check the element of array first location
2. if V.A[1]==1
//return statement return as a true
3. return 1
//elseif is used to check the value of second location of array
4. else if V.A[0]==1
//return false as a result
5. return 0
// else portion of code will be executed when if statement is false
6. else
// return nil as a result
7. return NIL
8. end if
// if u=2 is false then assign the cluster number to the variable max-cluster
9. else
10. max-cluster= PROTO-vEB-MAXIMUM (V.summary)
//check the value of max-cluster
11. if max-cluster==NIL
//if the value of max-cluster is nil then it return NIL
12. return NIL
13. else
//find the offset within cluster of max element.
14. offset = PROTO-vEB-MAXIMUM (V.cluster [max-cluster])
//finally returns the maximum number from cluster and offset.
15. return index (max-cluster, offset)
Explanation of Algorithm:
• In the above algorithm line first is used to check the base case.
• Find the initial cluster that contain the element of the set and store it into variable max-cluster.
• If there is no element in max-cluster variable then it return null otherwise find the maximum element from the cluster number and offset.
• Finally display the maximum element.
• In the worst case, there are two recursive calls.
The recurrence relation for the above algorithm is as follows:
Substituting u = 2k we get the following:
Renaming the recurrence relation, we get:
Using, master’s theorem, we can find the complexity of the above algorithm to be
Hence, the running time of above algorithm will be .
Consider the following pseudo code for PROTO-vEB-PREDECESSOR.
PROTO-vEB-PREDECESSOR (V, a)
// check for base condition if it is true then it contain the array A [0...1] of two bit.
1. if V.u==2
// if statement is used to check the value of a and element of array first location
2. if a==1 and V.A[0]==1
//return statement return as a false
3. return 0
// else portion of code will be executed when if statement is false
4. else
// return nil as a result
5. return NIL
//if base condition is false then calculates PROTO-vEB-PREDECESSOR
6. else offset = PROTO-vEB-PREDECESSOR (
//if offset has the predecessor
7. if offset != NIL
// return the value of predecessor
8. return index(high (a), offset)
9. else
//assign the other non-empty cluster to Pred-cluster variable
10. Pred-cluster= PROTO-vEB-PREDECESSOR (V.summary, high (a))
11. if Pred-cluster==NIL
// return null value
12. return NIL
13. else
//finally returns the predecessor from cluster and offset.
14. offset = PROTO-vEB-MAXIMUM (
15. return index (Pred-cluster, offset)
Explanation of Algorithm:
• Predecessor of any element a is the largest element in the V that is a.
• In the above algorithm the only way that a can have the predecessor when a==0 and V.A[1]==1.
• In the line 6 of above algorithm, predecessor of a is searched. if it is not NIL, then the predecessor of the element is returned. Otherwise, in the line 10, predecessor cluster for the current cluster is determined.
• If the predecessor cluster is found, then the maximum element in that predecessor cluster is the required predecessor element of a. Thus, it is calculated and returned in the lines 14-15.
The time complexity of PROTO-vEB-PREDECESSOR algorithm is ame as time complexity of PROTO-VEB-SUCCESSOR , that is .
Deleting an element form Proto van Emde Boas structure:
• When an element 0 ≤ x < u is inserted in the Proto van Emde Boas structure, the corresponding index in the corresponding cluster is set to 1 and the summary bit of corresponding cluster is also updated.
• When an element is deleted from the Proto van Emde Boas structure, the corresponding bit in the array of corresponding cluster is set to 0. But, not always the summary bit required to be changed to 0.
• Change the summary bit when an element is deleted in the following case only:
o When an element is deleted, change the corresponding bit in the array as 0. Then check whether there is any 1 bit in the cluster. Generally a cluster contains 0 to u-1 elements.
o If the cluster has at least one bit, then the corresponding summary bit has to be changed. Otherwise, the summary bit can be remained same.
The following is the procedure to delete an element from the Proto van Emde Boas structures:
PROTO-vEB-DELETE (V, x)
1 flag=FALSE
2 if V.u = = 2
3 V.A[x] = 0
4 for k=0 to V.u-1
5 if V.A[k] = = 1
6 flag=TRUE
7 return flag
8 else
9 flag=PROTO-vEB-DELETE( V. cluster [high(x)], low(x))
10 if flag = = FALSE
11 flag=PROTO-vEB-DELETE( V. summary, high(x))
12 return flag
• In line 3, the procedure deletes an element x by updates the corresponding bit in the array A.
• In line 4 to line 6, the procedure checks whether there is any 1 in the cluster.
• The procedure recursively calls to go sub clusters in line 9 until the base case occurs.
• To check whether the summary bit is to be changed or not, the Boolean value flag is used. The procedure updates the summary bit in line 11, if the flag is false (there is no 1’s in the cluster). Otherwise, the procedure skips the line 11.
Worst case time complexity:
In the worst case, occurs when all the clusters has no 1s. Then the procedure has to change all the summary bits for all the corresponding clusters.
In this case, in each iteration PROTO-vEB-DELETE two recursive calls in the lines 9 and 11.
Therefore, the worst case running time for the PROTO-vEB-DELETE is time.
Pseudo code for PROTO-vEB-DELETE structure
The PROTO-vEB is a data structure format used to organize the data in tree structure that will help to dynamically perform the operations on the elements of the tree.
The basic structure of the PROTO-vEB is shown in the diagram below. The information about the universe size is stored in the node u. The pointer summary is a pointer to the proto-vEB() structure. There is an array cluster that has a range of denotingdifferent pointers to proto-vEB() structures.
When the total number of elements has to be counted in the structure, an additional attribute n can be added. The attribute n would be used to count the total number of the elements in the structure for a certain value of u. After this modification is done in the structure, the structure would look like the one below:
In the PROTO-vEB-DELETE operation, not only the required number is deleted but also the addition of the clusters to 1 by the logical OR operation is also modified to include the updated result after deletion of the number x.
Delete operation is not as easy as the insert operation. The reason is that while deleting an element, first it has to be made sure whether or not the element exists in the structure. Only after this the appropriate bit in the summary can be reset to 0.
To do this the scanning of the entire structure might be required. The scan would continue till the concerned element is found in the structure. The count would also help find out if the deletion has taken place successfully.
To make the above happen, the size of the tree has to be determined. This is the place where n comes into the picture. The scan would run until the total scanned elements count crosses n. If this happens that means the element does not exist in the structure and thus cannot be deleted. After the operation if the value of n has decreased by 1 then the operation is successful.
This fact should be taken care of while writing the pseudo code for the DELETE operation.
The pseudo code of the DELETE operation is given below:
PROTO-vEB-DELETE (V,x)
//base case
1. if
2. return 0
3. if
4. return 1
5. call PROTO-vEB-MEMBER
// to find the location of the specified number in the structure.
6.
//copying the attribute n of the specific cluster
7. set
8. count
//check if the count exceeds the limit of elements
9. if then
10. for
//adding up the values of each of the elements of the cluster
11.
12. reset the corresponding value of V.summary too according to the values
of the s of each cluster.
Here at first;
1) Check the base cases where and when the size is 1 after deleting the result is 0, and when the size is 2 after deleting the result returned is 1.
2) Then find the specific position of the number x in the structure from where it has to be deleted in Line 4 by calling PROTO-vEB-MEMBER (V, x).
3) Then copy the attribute n of the structure so as to keep comparing every time a deletion operation occurs with the previous value of the value of n of the cluster.
4) This will help in the logical or of the elements of the cluster, this occurs in Line 5.
5) Then delete the number from the position which is found from the MEMBER operation.
6) Now count the present number of the attribute n in Line 7.
7) Then check if the number decreases meaning the deletion operation has taken place, the logically OR of the elements in that cluster is calculated and the result is updated at every node (Line 8-10).
8) Then there is need to reset the value of the summary array to the logical or of the values of the clusters (Line 11).
In the analysis, the complexity of the MEMBER function isand that of the DELETE algorithm is:
So from the Master’s theorem,
.
Therefore,
And which is greater than 1.
So
Therefore,
However, the inclusion of attribute n helps in deleting the element from the tree. This does not affect any other operation. The reason is that while performing any other operation like Insert, Member and others. The value of n need not be checked.
The result of these operations concludes either true or false. The implication would be straight forward and the reason would be intuitive. So, while performing other operations the attribute n can be simply ignored.
But for enhanced performance of insert operation, n can be considered. After insertion if the value of n is not increased, the insert operation is supposed to have failed. But this is only an optional practice. Since this check would be performed in a constant time so the running time of the procedure would not be altered.
Modifying the proto -vEB structure to support duplicate keys:
The proto-vEB is a recursive data structure that is used to store dynamic data set in a tree structure. operations like INSERT, DELETE, MININUM etc. can be performed on this tree. The basic structure of the PROTO-vEB is shown in the diagram below:
• The information about the size of the universe is stored in the node u.
• The cluster of the tree contains pointers to proto-vEB() structures.
• Summary also points to a proto-vEB() structure.
• Generally the vEB-PROTO structure does not allow to store the duplicate keys.
The proto -vEB structure:
• The proto-vEB structure does not support the duplicate keys.
• Since the structure of the proto-vEB allows the values between 0 and -1 to insert. No two same values can be inserted.
• The structure stores only one bit(0 or 1) in the array that specifies the structure contains the number or not.
• That is, the keys are not actually stored in the structure; rather the array indexes are considered to be the value of the key and the corresponding bit is set to 1 at the index. If the key is not present the index is left as 0.
• However, the binary value in the array specifies that whether a single value is present in the structure or not.
Required changes to present data structure to support duplicate keys are as follows:
In order to make the structure support the duplicate keys, change the storage structure such that the slots of array A allows to store integers instead of simple binary value 0 and 1. That is, each slot in the array works as a counter of a value.
INSERTION:
Initially all the indexes would be set to 0. When a key is inserted the value in the corresponding position in the array is incremented by 1. If the same key is inserted, the value in the corresponding array position is incremented to 2.
DELETION:
When a key is deleted, the corresponding value in the array position is decremented by 1. If the counter reaches 0, there is no value that is equal to the array index in the tree.
Adaption to Summary:
Summary bit can be set to 0, if the sum of counters of array in a cluster is zero. Otherwise, the summary bit can be set to 1.
Example:
The following is the proto-vEB structure for the following set of elements (containing duplicate elements) s={2,3,4,5,6,7,7,14,14,15}:
PROTO-vEB structure with satellite data
The PROTO-vEB is a data structure format used to organize the data in tree structure that will help to dynamically perform the operations on the elements of the tree.
The basic structure of the PROTO-vEB is shown in the diagram below. The information about the universe size is stored in the node u. The pointer summary is a pointer to the proto-vEB() structure. There is an array cluster that has a range of denoting different pointers to proto-vEB() structures.
Satellite Data:
Satellite data, while referenced with respect to the PROTO-vEB structure, is all of the data that is in the node other than the key. This might be a pointer, any integer or other type data.
In general scenarios, any satellite data attached with a key is always kept in the same node as the key. Storing it in the node in the case of an efficient tree structure like PROTO-vEB tree should be done in such a way that the modification does not affect the rest of the structure.
Modification in data structure:
There might be several approaches that can be used to store the satellite data in the vEB tree. The selection of approach depends upon the need in terms of execution time and the space availability.
Below are illustrated a few approaches that can be used to store the satellite data along with the possible advantages and the disadvantages of each if there are any.
Inclusion of pointer:
To modify the vEB tree structure to support satellite data, configure it so that it holds a pointer to the satellite that has to be stored. The pointer can be defined according to the data that is being stored.
An analogy to this approach would be a link list. Every node, in that, has a data and the address field that points to the next node.
To simulate the analogy the node can be changed to be like a collection of nodes. Each node would contain an additional address field that would have the address to the memory location where the satellite data is stored.
This would not make a great impact on the size of the tree and would support the satellite data as well. The operations on the PROTO-vEB structure can be performed by taking the reference of the Keys. This way it could be a good deal to store the satellite data in the VEB tree.The structure would look like the one below:
In the above diagram, the pointer ptr holds the pointer to the satellite data. This can be set to NULL if there is no satellite data available. The advantage of using a pointer would be that it would not take a great amount of space. In case of the node is not storing any satellite data than setting the pointer to NULL would ensure that the space not being consumed needlessly.
Satellite Data in Node itself:
Other way of modification is to save all the data in the structure nodes. This would make the access of the data faster because the data has not to be searched for in various disk locations.
This approach however might be less efficient and more space consuming. The reason is that the entire chunk of data is stored along with the node. This would intuitively be larger than the pointer to any remote disk location.
Moreover, this would make the structure look clumsy and complex. If the satellite is itself complex, the approach would start creating new complexity with the increasing complexities of the satellite data
Ordered pair approach:
One more and probably the most appropriate approach to do this is a minor modification in the first approach. In this entire data is treated as the key value pair.
The keys are the keys stored in the structure itself and the value is the entire satellite data that is associated with the key.
The satellite data would be lying somewhere in the disk in the descending orderand key to this would be stored in the structure. This would make it an ordered pair of keys and associated satellite data.
The keys are stored in the ascending order. Whenever the associated data has to be fetched, it can be gotten by searching the related key in the pair that is stored on the disk. The ascending order of the keys would preserve the basic structure of the vEB tree that has the keys in the ascending order.
The structure of the node in this approach might look like below:
struct satellite
{
int p;
float q;
satellite*pair_ptr;
}
So, the modification in the data structure would allow the data to be stored in the form of the key value pair. Keys would be the data stored in the tree itself and the data would be associated with the keys nonetheless would be stored somewhere else in the memory. The keys would essentially be stored in the ascending order.
A PROTO-vEB structure
The PROTO-vEB is a data structure format used to organize the data in tree structure that will help to dynamically perform the operations on the elements of the tree.
The basic structure of the PROTO-vEB is shown in the diagram below. The information about the universe size is stored in the node u. The pointer summary is a pointer to the proto-vEB() structure. There is an array cluster that has a range of denoting different pointers to proto-vEB() structures.
While creating the PROTO-vEB structure the following variables have to be taken care of:
1. Universe size: Variable u that is used to store the universe size for the vEB proto structure. This can be maintained using an attribute in the PROTO-vEB structure.
2. Summary: It is already known that summary is a pointer that holds the information about the vEB tree, a variable to hold this information would be required.
3. Cluster: The array that is used to store the values in it in the form of bits. The indexes of the array represent the value and the presence of 0 or 1 represents the presence or absence of the key, respectively.
Pseudo code for PROTO-vEB structure:
While writing the pseudo code the following should be done:
1) Declare and initialize the variable for storing the universe size.
2) Declare and initialize the pointer that would store the summary. For this use an array that would hold the information about the structures.
3) Declare an array that would be used as cluster array. The values that have to be stored in the tree would be first kept in a temporary array and then based on the presence or absence of 1s in the array indexes the values in the cluster array would be filled up.
The pseudo code for the creation of the PROTO-vEB structure can be written as given below:
PROTO-vEB (u)
1. {
// initialize the variable and array index
2. int;
3.
//declare a new array
4.
5. Summary;
//size of the summary array is the number of clusters that is
//run a loop for array indexes
6. for
//
7. {
8.
//the number of clusters is, and in each cluster the number of elements is
9. for
10. {
//check the list element
11. if
12. ;
13. else
14. ;
} } }
LIST
1. {
2. Enter the elements in the list [ ].
//Check the elements
3. if
//return 1 if exists
4. return
5. else
//return 0 if does not exist
6. return (0).
}
Explanation of the pseudo code:
First of all, initialize a variable and an array in line 2 and line 3. The array initialized in the line 3 would be used to hold the size of the universe. Declare an array in line 4 that would be used to store the key values in it. Declare another array in line 5 that would be used to store the summary for the given tree.
Lines 6 to 12 are used to store the values in the cluster array. Line 6 initializes a loop that runs from1 till. Line 8 sets the maximum number of clusters to. Line 9 is used to check the values that are to be filled in the tree.
To check the values another procedure LIST is to be called. This procedure picks the values from an additional array list that holds the values to be inserted in the tree. If the value in list array is 1 the respective index in the cluster is also set to 1; 0 otherwise.
Now, have a look at the LIST procedure.
This procedure does nothing but enters the values in the cluster array. The concerned key value is passed as the argument. If the value of the variable passed as argument is 1 then the current index of the array list is set to 1. If the value is 0 then the value in the current index of the array is set to 0.
The empty structure of the PROTO-vEB
The PROTO-vEB structure:
The PROTO-vEB is a data structure format used to organize the data in tree structure that will help to dynamically perform the operations on the elements of the tree.
The basic structure of the PROTO-vEB is shown in the diagram below. The information about the universe size is stored in the node u. The pointer summary is a pointer to the proto-vEB() structure. There is an array cluster that has a range of denoting different pointers to proto-vEB() structures.
The PROTO-vEB MINIMUM gets executed as follows. It gives the minimum number in the list.
PROTO-vEB MINIMUM ( V )
//check the base case
1. if
//check if the first index holds an element
2. if
3. return 0
//check if the second index holds an element
4. else if
5. return 1
//check if the list is empty
6. else
return NIL
7. else
//recursive call to the procedure
min-cluster = PROTO-vEB MINIMUM (V.summary)
//check for NIL list
8. if(min-cluster == NIL)
9. return NIL
10. else
//find out the offset for the list
offset =PROTO-vEB-MINIMUM (V.cluster [min-cluster])
11. return index (min-cluster, offset)
Explanation of the procedure:
In simple words the procedure checks for the first non-zero value in the lists. As the levels get ahead the procedure searches the minimum cluster and finds the first non-zero value in that.
As soon as the value is found, the procedure returns the index of that value. The index is the minimum value in the entire structure.
The procedure gets executed as follows:
Line 1 checks the fundamental case where the universe has only two values.
Line 2 checks if the cluster array has a 1 in its first index and returns the control with a value 0 from line 3.
Line 4 checks the case if the first index has a 1 in it as the value.
Line 5 returns a 1 if case mentioned in the line 4 is true.
If none of these cases is true, the line 6 throws the control out of the procedure with a NIL returned.
The alternative of the line 1 is to call the procedure recursively and store the returned value in the min-cluster that is line 7.
Line 8 checks if the value stored in the min-cluster variable is NIL. If this happens, the procedure returns NIL.
Line 10 and 11 calculate the offset and index for the structure and return the index based on the offset and the min-cluster value.
For NIL structure:
Now have a look at the same procedure for the NIL structure.
Since the structure does not have any element, obviously the structure would not have any range and u cannot be given any value but NIL.
The control gets transfer to the line 7.This is a recursive call to the procedure with the summary pointer passed as argument to the procedure. Since this is a NIL structure that’s why the structure would not have any elements stored in it.
Simply there are no children.
So the procedure would return a NIL. This is stored in the variable min-cluster. Now line 8 is checked to find out if the min-cluster has a NIL. If this is so the next line to be executed would be the line 9. This returns a NIL.
So, it is apparent that the line 9 is executed only if the list is empty. In any other case there would any other value returned than NIL.
PROTO-vEB structure
The PROTO-vEB is a recursive data structure format used to organize the data in tree structure that will help to dynamically perform the operations on the elements of the tree.
The basic structure of the PROTO-vEB is shown in the below diagram. The information about the universe size is stored in the node u. The pointer summary is a pointer to the proto-vEB() structure. There is an array cluster that has a range of denoting different pointers to proto-vEB() structures.
The following operations can be performed on PROTO-vEB structure:
1. PROTO-vEB-MEMBER: The operation finds if a particular element exists in the structure
2. PROTO-vEB-MINIMUM: The operation finds the minimum element in the structure.
3. PROTO-vEB-MAXIMUM: The operation finds the maximum element in the structure.
4. PROTO-vEB-PREDECESSOR: To find the predecessor of a given value.
5. PROTO-vEB-SUCCESSOR: TO find the successor of the given value.
6. PROTO-vEB-INSERT: To insert a value in the structure.
7. PROTO-vEB-DELETE: To delete the specified element from the structure, if that exists in the structure.
Calculating the complexity for each of the operation performed on PROTO-vEB structure with elements in each cluster is as follows:
PROTO-vEB-MEMBER:
PROTO-vEB-MEMBER procedure calls recursively itself every time in the worst case. Finally it takes to checks membership in constatnt time. Thus, if T(u) is the running time of PROTO-vEB-MEMBER, then the running time can be characterized as follows:
Consider .That is,
So,
Again consider,
Thus, the new recurrence is,
According to the Master’s theorem, case 2, the above recurrence relation has the following solution.
Hence,
PROTO-vEB-MINIMUM ( V ):
In the worst case, the procedure PROTO-vEB-MINIMUM calls itself recursively twice. But the finding the cluster which contains minimum element takes constant time.
Therefore
Consider. That is, and
Thus,
By master’s theorem, case 1,
So, the complexity of PROTO-vEB-MINIMUM operation is
PROTO-vEB-MAXIMUM:
The objective of this operation is to find the maximum element in the PROTO-vEB structure. Thus, like PROTO-vEB-MINIMUM, the PROTO-vEB-MAXIMUM operation also requires time.
Hence
Successor operation finds the next node in the hierarchy with the smallest key that is greater than the current key. The operation makes two recursive calls to itself and calls the procedure to find the minimum as well.
So, the total complexity would be equal to the sum of the complexity of two recursive calls and complexity of minimum.
Consider u=2m and =
By master’s theorem, case 3,
Thus
Hence
PROTO-vEB-PREDECESSOR:
Predecessor of a node is the node having the greatest value that is less than the current node.
In the worst case, the procedure PROTO-vEB-PREDECESSOR calls itself twice and calls PROTO-vEB-MAXIMUM once. Therefore, the time complexity for PROTO-vEB-PREDECESSOR is same as time complexity of PROTO-vEB-SUCCESSOR .
Hence the complexity of the procedure is .
PROTO-vEB-INSERT :
In the worst case, always the procedure PROTO-vEB-INSERT calls itself twice and takes constant time for updating the summary bit.
So the complexity would be as below:
Consider u=2m and =
By master’s theorem, case 1, the solution to the above recursion is as follows:
Hence
PROTO-vEB-DELETE:
In the worst case, like PROTO-vEB-INSERT, the procedure PROTO-vEB-DELETE recursively calls itself twice and each time it updates the summary bit also in constant time.
Therefore,
Consider u=2m and =
By master’s theorem, case 1, the solution to the above recursion is as follows:
Hence


GLURP
A RESTful API framework for Node using the HTTP module,
with libraries that automate creating a server and router that
can handle multiple route requests and easily respond with
multiple file types, icluding HTML, CSS, JPEG and JS.
GLURP REPO
Contact the Glurp team


{% load blog_tags %} {% load static %}
This is my blog. I've written {% total_posts %} posts so far.
Subscribe to my RSS feed


umount
Unlink a filesystem from its mount point, making it no longer accessible.
A filesystem cannot be unmounted when it is busy.
More information: home page
- Unmount a filesystem, by passing the path to the source it is mounted from:
umount path/to/device_file
- Unmount a filesystem, by passing the path to the target where it is mounted:
umount path/to/mounted_directory
- Unmount all mounted filesystems (except the `proc` filesystem):
umount -a


Large Banner 1920x1080
Black Logo PNG
White Logo PNG
Rank Card Game Box PNG
Rank Card Game Box Back PNG
Rank Card Game Open Box PNG
Rank Cards in Fan PNG
Rank Cards Layout
Playing Rank


but this vote is still open for voting. So you can't see the results yet.
You may want to vote, or alternatively you may want to try again.


#if alertMessage??>
${alertMessage.message}
This site provides reference for the management model for the WildFly application server, as well as other application servers in the same family such as JBoss EAP 6+, JBoss EAP7 & JBoss AS 7
WildFly is the next generation of the JBoss AS application server.
JBoss EAP 7 is Red Hat's commercial offering based on WildFly code base.
JBoss EAP 6 is Red Hat's commercial offering based on the AS7 and WildFly code base.


--- title: Mapping Breweries in US with Leaflet in R author: Linear Fragility date: '2021-04-09' slug: [] categories: - Data World tags: - Data Visualization - R - Leaflet output: html_document thumbnail: images/beer.png ---
It was a wonderful Friday night when I walked into a local beer shop called “101 Bottles of Beer on the Wall”. I did not actually make effort to count how many bottles of beer were actually on the wall. They indeed have A LOT of different kinds of beers. And that made me wonder how many companies are making draft beers in United States. Then I found a data set made available on Kaggle by Brett Kurzawa, and here is map of all breweries.
pacman::p_load(
uszipcodes, ## I created this package available on Github
leaflet,
stringr,
dplyr
)
I created the package uszipcodes and it is available in my github. It includes zip code location data and some handy functions to clean data.
beers <- read.csv("~/R_Projects/my_website/website/content/post/2021-04-09-mapping-breweries-in-us-with-leaflet-in-r/breweries_us.csv") ## data downloaded from https://www.kaggle.com/brkurzawa/us-breweries
colnames(beers)
## [1] "brewery_name" "type" "address" "website"
## [5] "state" "state_breweries"
raw_zip <- get_zip(beers$address)
sum(contain_letter(raw_zip))
## [1] 55
beers$Zip <- as.integer(clean_zip(raw_zip))
## Warning: NAs introduced by coercion
beer_location <- inner_join(beers, zip_table[ , c(1,4,5)])
## Joining, by = "Zip"
content <- beer_location %>%
mutate(popup = paste0('', beer_location$brewery_name, ''))
beer_icon <- makeIcon(
iconUrl = "~/R_Projects/website/website/static/images/beer_glass.png",
iconWidth = 28, iconHeight = 30,
iconAnchorX = 0, iconAnchorY = 0
)
beer_map <- leaflet(beer_location) %>%
setView(lng = -98.583, lat = 39.833, zoom = 4) %>%
addTiles() %>%
addProviderTiles(providers$Wikimedia) %>%
addMarkers(lng = beer_location$Longitude, lat = beer_location$Latitude,
clusterOptions = markerClusterOptions(),
popup = content$popup,
icon = beer_icon
)


vignettes/HowToUsePhenotypeLibraryRPackage.Rmd
HowToUsePhenotypeLibraryRPackage.Rmd
PhenotypeLibrary is part of HADES
remotes::install_github("OHDSI/PhenotypeLibrary")
PhenotypeLibrary::listPhenotypes()
#> # A tibble: 569 x 27
#> cohortId cohortName cohortNameFormatted cohortNameLong cohortNameAtlas
#> <dbl> <chr> <chr> <chr> <chr>
#> 1 2 [W] COVID-19 dia~ COVID-19 diagnosis~ COVID-19 diag~ [W] COVID-19 d~
#> 2 3 [P] Cough or Spu~ Cough or Sputum Cough or Sput~ [P] Cough or S~
#> 3 4 [P] Diarrhea Diarrhea Diarrhea [P] Diarrhea
#> 4 5 [P] Dyspnea Dyspnea Dyspnea [P] Dyspnea
#> 5 6 [P] Fever Fever Fever [P] Fever
#> 6 7 [P] Headache or ~ Headache or Headac~ Headache or H~ [P] Headache o~
#> 7 8 [P] Altered smel~ Altered smell or t~ Altered smell~ [P] Altered sm~
#> 8 9 [P] Sore throat Sore throat Sore throat [P] Sore throat
#> 9 10 [P] Nausea or Vo~ Nausea or Vomiting Nausea or Vom~ [P] Nausea or ~
#> 10 11 [P] Malaise and ~ Malaise and or fat~ Malaise and o~ [P] Malaise an~
#> # i 559 more rows
#> # i 22 more variables: librarian <chr>, status <chr>, addedVersion <chr>,
#> # logicDescription <chr>, hashTag <chr>, isCirceJson <dbl>,
#> # contributors <chr>, contributorOrcIds <chr>,
#> # contributorOrganizations <chr>, peerReviewers <chr>,
#> # peerReviewerOrcIds <lgl>, recommendedEraPersistenceDurations <chr>,
#> # recommendedEraCollapseDurations <chr>, recommendSubsetOperators <chr>, ...
cohortDefinitionSet <- PhenotypeLibrary::getPlCohortDefinitionSet(cohortIds = c(1, 2, 3))
cohortDefinitionSet
#> # A tibble: 2 x 4
#> cohortId cohortName json sql
#> <dbl> <chr> <chr> <chr>
#> 1 2 [W] COVID-19 diagnosis or SARS-CoV-2 test (1pos) "{\n\t\"cdmVe~ "CRE~
#> 2 3 [P] Cough or Sputum "{\n\t\"cdmVe~ "CRE~
connectionDetails <-
DatabaseConnector::createConnectionDetails(
dbms = "postgresql",
server = "some.server.com/ohdsi",
user = "joe",
password = "secret"
)
cdmDatabaseSchema <- "cdm_synpuf"
cohortDatabaseSchema <- "scratch.dbo"
cohortTables <- CohortGenerator::getCohortTableNames()
CohortGenerator::generateCohortSet(
connectionDetails = connectionDetails,
cdmDatabaseSchema = cdmDatabaseSchema,
cohortDatabaseSchema = cohortDatabaseSchema,
cohortTableNames = cohortTables,
cohortDefinitionSet = cohortDefinitionSet
)
databaseId <- "synpuf"
databaseName <-
"Medicare Claims Synthetic Public Use Files (SynPUFs)"
databaseDescription <-
"Medicare Claims Synthetic Public Use Files (SynPUFs) were created to allow interested parties to gain familiarity using Medicare claims data while protecting beneficiary privacy. These files are intended to promote development of software and applications that utilize files in this format, train researchers on the use and complexities of Centers for Medicare and Medicaid Services (CMS) claims, and support safe data mining innovations. The SynPUFs were created by combining randomized information from multiple unique beneficiaries and changing variable values. This randomization and combining of beneficiary information ensures privacy of health information."
CohortDiagnostics::executeDiagnostics(
cohortDefinitionSet = cohortDefinitionSet,
exportFolder = outputFolder,
databaseId = databaseId,
databaseName = databaseName,
databaseDescription = databaseDescription,
cohortDatabaseSchema = cohortDatabaseSchema,
cdmDatabaseSchema = cdmDatabaseSchema,
connectionDetails = connectionDetails,
cohortTableNames = cohortTableNames
)


Resources
Jekyll’s growing use is producing a wide variety of tutorials, frameworks, extensions, examples, and other resources that can be very helpful. Below is a collection of links to some of the most popular Jekyll resources.
Editors
- jekyll-atom: A collection of snippets and tools for Jekyll in Atom
- markdown-writer: An Atom package for Jekyll. It can create new posts/drafts, manage tags/categories, insert link/images and add many useful key mappings.
- sublime-jekyll: A Sublime Text package for Jekyll static sites. This package should help creating Jekyll sites and posts easier by providing access to key template tags and filters, as well as common completions and a current date/datetime command (for dating posts). You can install this package manually via GitHub, or via Package Control.
- vim-jekyll: A vim plugin to generate new posts and run
jekyll build
all without leaving vim. - WordPress2Jekyll: A WordPress plugin that allows you to use WordPress as your editor and (automatically) export content in to Jekyll. WordPress2Jekyll attempts to marry these two systems together in order to make a site that can be easily managed from all devices.
Useful Guides
- CloudCannon Academy is a set of resources created by CloudCannon to help folks get up and running with Jekyll. They cover all skill levels, and even include some great video tutorials.
- Jekyll Cheatsheet is a single-page resource for Jekyll filters, variables, and the like.
- “Creating and Hosting a Personal Site on GitHub”
- ‘Build A Blog With Jekyll And GitHub Pages’ on Smashing Magazine
- Publishing to GitHub Pages? Check out our documentation page for just that purpose.
- Blogging with Git, Emacs and Jekyll
- Tips for working with GitHub Pages Integration
Integrations
-
Use a SaaS service as a backend for forms (contact forms, hiring forms, etc.)
- Formspree (open source)
- FormKeep
- Simple Form
- Formingo
- Formester
- Talkyard: Embedded comments for Jekyll and others (free and open source, or hosted serverless)
- Staticman: Add user-generated content to a Jekyll site (free and open source)
- Snipcart: Add a shopping cart to a Jekyll site
- Contentful: use Jekyll together with the API-driven Contentful CMS.
- Algolia: Add a powerful instant search to your Jekyll site
Other commentary
-
‘My Jekyll Fork’, by Mike West
“Jekyll is a well-architected throwback to a time before WordPress, when men were men, and HTML was static. I like the ideas it espouses, and have made a few improvements to it’s core. Here, I’ll point out some highlights of my fork in the hopes that they see usage beyond this site.”
-
‘About this Website’, by Carter Allen
“Jekyll is everything that I ever wanted in a blogging engine. Really. It isn’t perfect, but what’s excellent about it is that if there’s something wrong, I know exactly how it works and how to fix it. It runs on the your machine only, and is essentially an added”build” step between you and the browser. I coded this entire site in TextMate using standard HTML5 and CSS3, and then at the end I added just a few little variables to the markup. Presto-chango, my site is built and I am at peace with the world.”
-
Generating a Tag Cloud in Jekyll – A guide to implementing a tag cloud and per-tag content pages using Jekyll.
- A way to extend Jekyll without forking and modifying the Jekyll gem codebase and some portable Jekyll extensions that can be reused and shared.
- Using your Rails layouts in Jekyll


The skeleton (from Greek σκελετός, skeletos "dried body", "mummy"[1]) is the body part that forms the supporting structure of an organism. There are two different skeletal types: the exoskeleton, which is the stable outer shell of an organism, and the endoskeleton, which forms the support structure inside the body.


## My impressions of Angular 2,
(the developer preview)
### Disclaimer
![](images/caution.gif)
### Disclaimer #2
![](images/time.jpg)
![](images/angular1.png)
# ?
- data binding
- add html behavior
- create html tags
![](images/popular.gif)
### Much fun
Problems with Angular 1.x
It can be slow
Angular != Web Components
Complexity
![](images/feelings_about_angularjs_over_time.png)
Router = no bueno
## Angular 2?
![](images/angular2.png)
Ng-Europe 2014
Angular 1.x ==X=> Angular 2
AtScript
![](images/panic.gif)
ng-conf 2015
- Public deisgn docs
- Migration path
- TypeScript
What's great about Angular 2
But first, [demo app](http://<IP_ADDRESS>:8080/)
### Angular 1.x concepts
Controller
Template
Directives
Model
Scope
Expressions
View
Module
Service
### Angular 2 concepts
services
components
views
### How to make a component
```
@Component({
// specify selector and dependencies
})
@View({
// specify template
})
class TitleComponent {
// make object that controls component
}
```
Event binding
```
<tag (eventName)="fnToCall()"></tag>
```
Module loader (System.js)
```
var dependencies = [
...
]
dependencies.forEach(function(dependency){
System.import(dependency);
});
```
And in each dependency
```
bootstrap(NameOfComponent);
```
No need for "$scope"!
```
<h1 >{{propertyOnComponent}}</h1>
```
Dynamic html properties
```
<img [src]="selectedMember.avatar_url"></img>
```
What's not great about Angular 2
Migration with new router
Dependencies need to migrate
Resources are jumbled
Hard to get sneak peek
## Conclusion
Cool! Eventually...
#### How to learn more
- Best [starter code](https://github.com/angular-class/angular2-webpack-starter)
- Best [blog post](http://angular-tips.com/blog/2015/06/why-will-angular-2-rock/)
- Step by step [guide](https://angular.io/docs/js/latest/guide/) (2.0.0-alpha.22)
- [Glossary](https://www.youtube.com/watch?v=YhcOeJP06Zc) from ng-Vegas
- [ng-conf 2015 keynote](https://www.youtube.com/watch?v=-dMBcqwvYA0&index=21&list=PLOETEcp3DkCoNnlhE-7fovYvqwVPrRiY7) <== Deep-dive into syntax
Thanks!


There are more than a few options out there to host a blog these days. But this is a technical blog and as one of my first posts, I wanted to provide a technical tutorial on how it was deployed and what I learned.
For this site, I wanted to own the full technical stack, for two reasons:
- to have full control over every functional and design aspect of the site
- to fully understand how the site software stack works from the operating system on up
The site is only made from open source software so if I wanted to edit some miniscule detail, I have full power to do that. Welcome to the first post using this stack!
The words you’re reading are sent to you through software that’s deployed in this guide. I’m hosting all the code that makes up the site so if you want to copy and deploy a similar stack, go right ahead.
This post will be one of a few in a series. I’ll tackle topics common for all production web services such as load balancing, service discovery, high availability, and security.
- Deploying a server part 1: deploying hugo
- Deploying a server part 2: envoy as a frontend proxy
- Deploying a server part 3: envoy with consul service discovery
- Deploying a server part 4: web server metrics
- ... TBD
Hugo - A static site generator
After reading "switching to Hugo", I fancied the idea of using a static site generator instead of something more complex like Wordpress. What is a static site generator? To explain let’s think about Wordpress, which is a dynamic site. It has the capability to generate and insert dynamic content into the files that are returned to clients. This could be dynamic content such as article comments or an on-the-fly generated list of the most popular posts.
Static site generators pre-compile all of the web content (HTML, CSS) so it only changes when the content actually changes. This comes at the sacrifice of dynamic content, but is an acceptable trade off for me, because I want this site to be super simple.
Here are some things I like about Hugo (an open source static site generator):
- Its architecture simple and easy to understand
- The content is hosted as flat files that can be version controlled
- It has powerful but simple control for organizing articles
- It’s written in golang (which I’m in the process of learning)
- It’s fast (this is not a requirement, but if it becomes one, then great!)
Because the entire site is version controlled, all the code and content that runs this blog is right here!
Deploying Hugo
Deploying Hugo has a couple steps to it, first of which was learning how Hugo works. After that I wanted to customize its structure and how it looks. When I was happy with the customization I went ahead and deployed it all. You can edit and deploy this site as well just by using the code from the github repo.
Understanding How Hugo Works
Hugo runs as a single binary that binds to an interface and port to serve content from the local filesystem. This tutorial got me started in running Hugo on my mac to start my learning.
With the tutorial, the hugo server can be started easily and accessed on your local browser.
$ hugo server
...
Web Server is available at http://localhost:1313/ (bind address <IP_ADDRESS>)
Press Ctrl+C to stop
Finding a theme
There are already a lot of good themes that exist. I was looking for a minimalist theme and settled on zozo.
Hugo has a prescriptive directory structure that defines how it works. For this site I don’t use most of the directories, but here are some of the files and folders I did spend a lot of time on:
├── config.toml
├── content
│ ├── about
│ ├── links
│ └── posts
└── themes
└── zozo
├── layouts
│ ├── 404.html
│ ├── _default
│ │ ├── list.html
│ │ ├── ...
│ ├── index.html
│ ├── partials
│ │ ├── comments.html
│ │ ├── footer.html
│ │ ├── head.html
│ │ ├── header.html
│ │ ├── ...
├── static
│ ├── css
│ │ ├── zozo.css
│ └── js
│ ├── fancybox.min.js
│ ├── ...
└── theme.toml
config.toml
defines the top-level web pages and other global configurations such as the theme that’s usedcontent
folder holds all of the content for the posts as.md
fileslayouts/_default
holds the structure of the primary page types within the site such as the article listing page, individual post, and static single page.layouts/partials
holds the structure of elements that are common on every page such as the header and footerlayouts/index.html
is the home page (the one that has the list of all the articles)
It took awhile to understand how the directory structure influences site structure, but once this clicked it was easy to see how I could customize the theme for my own use. Most of this customization occured in the zozo.css
file and the within the layouts
folder.
getting infrastructure
There are at least 10 different ways to host a Hugo server in less than 5 minutes, but that would be too easy. Netlify will provide deployments, load balancing, HTTPS, monitoring and way more, but those are all the things that I want to learn and write about. Where would the fun be in getting those things for free?? Because I want to own all of the software infra services, I’m using a very minimal f1-micro instance running Ubuntu on GCP. The rest of the software infra I’ll be deploying in future posts.
deploying hugo
1 - install Hugo
Hugo has install instructions for different platforms. I'm running the site on Ubuntu Linux.
$ wget https://github.com/gohugoio/hugo/releases/download/v0.55.5/hugo_0.55.5_Linux-64bit.deb
$ sudo apt-get install /home/markchurch/hugo_0.55.5_Linux-64bit.deb
$ hugo version
Hugo Static Site Generator v0.55.5-A83256B9 linux/amd64 BuildDate: 2019-05-02T13:03:36Z
2 - configure Hugo
This step will be unique for everybody but here are the things that I customized.
- Editing the top-level page structure in the config.toml
- Changing the theme.css file to update the style of the site
- Edit the html in the layouts folder to change the site structure
3 - deploy Hugo
Hugo serves files from the local filesystem. With the source hosted on github, it can be pulled to the local filesystem and deployed. I'll automate this step in the future so that any updates to the remote git repository will result in a live site update.
$ git clone https://github.com/mark-church/site.git
$ cd site
$ hugo server --bind "<IP_ADDRESS>" -p 80 -b "markchur.ch"
While the above deploys Hugo, it doesn't do so in a very fault tolerant way. I want Hugo to survive server restarts or process failures so I’m using systemd and a very basic unit file. Systemd will do basic process management as well as logging for the hugo server.
$ systemctl enable hugo
$ systemctl start hugo
$ systemctl status hugo
● hugo.service - Hugo Server
Loaded: loaded (/etc/systemd/system/hugo.service; enabled; vendor preset: enabled)
Active: active (running) since Mon 2019-05-20 16:53:28 UTC; 1h 51min ago
Main PID: 474 (hugo)
Tasks: 9 (limit: 667)
CGroup: /system.slice/hugo.service
└─474 /usr/local/bin/hugo server --bind <IP_ADDRESS> -p 80 -b markchur.ch --source /site
fin
That’s it! Kind of.
Realistically speaking, there are still a lot of missing things that would make this a production-grade web service. All we have right now are the basics. We have no user access logging, no encryption, zero redundancy, no automated site updates, no caching, and nonexistent metrics.
Hugo is also not designed to be a high-performance web server and so a web serving proxy would be a good idea. I've been wanting to go deeper in to Envoy for a while and so in the next post we’ll deploy Envoy to act as our frontend proxy. Thanks for reading!


If you aren’t familiar with Jekyll yet, you should know that it is a static site generator. It will transform your plain text into static websites and blogs. No more databases, slow loading websites, risk of being hacked…just your content. And not only that, with Jekyll you get free hosting with GitHub Pages! If you are a beginner we recommend you start with Jekyll’s Docs. Now, if you know how to use Jekyll, let’s move on to using this theme in Jekyll:
Step 1. Fork the repo - click here
Step 2. Use your-github-username.github.io as the new repo ( Replace your-github-username with yours). Remember if you use the name other than your-github-username.github.io , your blog will be built using gh-pages branch.
Step 3. Clone the new repo locally to make changes :
$ git clone https://github.com/yourusername/yourusername.github.io
$ cd yourusername.github.io
$ code .
Step 4. Open the files using VSCode and edit _config.yml and edit with your details:
Step 5 - Install the development requirements:
We need ruby and bundler to build our site locally. After installation check if its working:
For ruby :
$ ruby -v
ruby 2.5.1p57 (2018-03-29 revision 63029) [x86_64-linux-gnu]
For bundler :
$ gem install bundler
$ bundler -v
Bundler version 2.1.4
Add jekyll :
$ bundle add jekyll
This command will add the Jekyll gem to our Gemfile and install it to the ./vendor/bundle/ folder.
You can check the jekyll version
$ bundle exec jekyll -v
jekyll 4.0.0
Step 6. Install the gem dependencies by running the following command
$ bundle update
$ bundle install
Step 7. Serve the site locally by running the following command below:
$ bundle exec jekyll serve --watch
or you can also serve using :
$ jekyll serve
Visit https://keisuuu.github.io/CSGO for development server
Start populating your blog by adding your .md files in _posts. devlopr-jekyll already has a few examples.
---
layout: post
title: Sample Post
author: Sujay Kundu
date: '2019-05-21 14:35:23 +0530'
category:
- jekyll
summary: This is the summary for the sample post
thumbnail: sample.png
---
Hi ! This is sample post.
---
layout: page
title: Sample Page
menus: header
permalink: /sample-page/
---
Hi ! This is sample page.
You’ll only work with a single file to edit/add theme style: assets/css/main.scss.
Once happy with your blog changes. Push your changes to master branch.
Step 8.  Enable master branch as Github Pages Branch :
Step 9. Deploy your Blog :
Congrats ! On your new shining Blog !
You can visit the blog using http://your-github-username.github.io.


Gateway
BOT
09-Nov-19 01:23 PM
[dscrd-hush] <dukeleto> @Crypto99 that vol is different that what graviex says
[dscrd-hush] <dukeleto> maybe it's "daily" vs "24hr rolling period"
[dscrd-hush] <dukeleto> in any case, it's all good
[dscrd-hush] <dukeleto> we gotta keep working on our stuff and get SilentDragonAndroid and HushDroid and the DragonHead out. Can you imagine what that will do to our price? Having actual working code and hardware?
[dscrd-hush] <Crypto99> Yes, I can imagine
[dscrd-hush] <Crypto99> HushDroid as it is, is ready.
[dscrd-hush] <Crypto99> Pixel 2, 3, 3a
[dscrd-hush] <dukeleto> we need to decide on a new Pixel series, maybe 3?
[dscrd-hush] <dukeleto> I don't want to be the next thing that gets cut from support
[dscrd-hush] <Crypto99> True
[dscrd-hush] <Crypto99> We can also do Galaxy S7
[dscrd-hush] <Crypto99> w/LineageOS
[dscrd-hush] <dukeleto> HushDroid also can be a tablet. i have an old tablet with a cracked screen running SDA, just stock android
(edited)
[dscrd-hush] <dukeleto> it's really nice having more screen for the wallet
[dscrd-hush] <Crypto99> We can get lineage on a tablet
[dscrd-hush] <dukeleto> but i thought lineage was ?
[dscrd-hush] <Crypto99> Well it has microG
[dscrd-hush] <Crypto99> Compared to full gapps
[dscrd-hush] <Crypto99> And it supports everything non pixel
[dscrd-hush] <dukeleto> imagine the hilarity of keeping it secret for 7.5 years, even from Zcash, and then releasing it on a Friday afternoon, lulz
[dscrd-hush] <Crypto99> Holy lol
[dscrd-hush] <dukeleto> fucking CVEs
[dscrd-hush] <Crypto99> It was hidden
[dscrd-hush] <Crypto99> If you seek, you shall find
[dscrd-hush] <dukeleto> this is the norm
[dscrd-hush] <Crypto99> There's not enough people to fix all the bugs out there
[dscrd-hush] <Crypto99> Good work @dukeleto
[dscrd-hush] <Crypto99> Hushdroid recommends a Pixel 3a and Graphene. Bc we dont want to limit those seeking a more secure android, that dont want a pixel or cant afford one, we have other options.
[dscrd-hush] <dukeleto> i like that
[dscrd-hush] <Crypto99> We wont turn anyone away seeking to gain more privacy through their android
[dscrd-hush] <Crypto99> I'll help anyone that I can.
[dscrd-hush] <dukeleto> !tip @Crypto99 50 hush
[dscrd-hush] <tip.cc> :HUSH: @dukeleto sent @Crypto99 50.00 HUSH (≈ $5.39).
[dscrd-hush] <dukeleto> because I have seen him help lots of people and believe he will continue
[dscrd-hush] <Crypto99> I think Duke needs Graphene lol
[dscrd-hush] <dukeleto> yes i do
[dscrd-hush] <Crypto99> If anyone thinks this is bs, just come and chat with me. I'll make guides, you tell me, and we will do it
[dscrd-hush] <Crypto99> HushDroid is only beneficial if we have users
[dscrd-hush] <Crypto99> Doesnt mean you have to buy a phone.
[dscrd-hush] <Crypto99> @dukeleto a lot of secure phones have been scams
[dscrd-hush] <dukeleto> most things with the word "privacy" or "secure" in the name are scams
[dscrd-hush] <Crypto99> Aholes
[dscrd-hush] <Crypto99> I learned this using privacy and security software over 15 years
[dscrd-hush] <Crypto99> And as of today, in crypto, the ZCash protocol,mimblewimble and XMR.
[dscrd-hush] <dukeleto> so much to learn
[dscrd-hush] <Crypto99> How so
[dscrd-hush] <dukeleto> how so not?
[dscrd-hush] <dukeleto> i can't even learn all there is about BTC and ZEC protocols and they change every day
[dscrd-hush] <Crypto99> Haha
[dscrd-hush] <dukeleto> jl777 can code faster than I can even read the code
[dscrd-hush] <dukeleto> XMR has over 250 forks, zcash around 30 source code forks
[dscrd-hush] <dukeleto> new coins and protocols come out every day
[dscrd-hush] <dukeleto> new elliptic curves, new BTC internals
[dscrd-hush] <Crypto99> I read bitcointalk Ann's daily
[dscrd-hush] <Crypto99> In a telegram channel
[dscrd-hush] <Crypto99> I use privacy as a search filter


Generate your groups of starting race options for a game of TI4. Keep in mind that there are 17 races available, and requests for more than 17 starting races will not be generated.Assign each player a number prior to pressing generate.
Generate your groups of starting race options for a game of TI4. Keep in mind that there are 17 races available, and requests for more than 17 starting races will not be generated.Assign each player a number prior to pressing generate.


| Method | Defined by | ||
|---|---|---|---|
|
addModelToCache(model:Object, fqn:String):void
[static]
Add a give model to cache.
| RxUtils | ||
|
addObjectIdToResourceURL(url:String, object:Object, suffix:String = "fxml"):String
[static]
Reformats the URL to be suitable for update/destroy requests where model id
is embedded in the URL.
| RxUtils | ||
|
canDeleteModel(model:RxModel):Boolean
[static]
Check to see if the model can be deleted
| RxUtils | ||
|
cast(targetType:String, value:Object):*
[static]
Casts a variable to specific type from a string, while trying to do the right thing
based on targetType description.
| RxUtils | ||
|
cleanupModelReferences(model:Object, fqn:String, singleReference:String = ""):void
[static]
Cleanup references to specified model.
| RxUtils | ||
|
clone(object:Object, recursive:Boolean = false):Object
[static]
If the object cloned is a RxModel do clone based on reflection, else
default to binary ObjectUtil clone.
| RxUtils | ||
|
daysFromNow(numDays:int):Date
[static]
Calculate days from now
| RxUtils | ||
|
describeResource(object:Object):XMLList
[static]
Gets Resource metadata.
| RxUtils | ||
|
fireUndoRedoActionEvent(undoRedoFlag:int = 0):void
[static]
Dispatches appropriate Undo/Redo event depending on the flag.
| RxUtils | ||
|
getAttributeAnnotation(attribute:XML, annotationName:String):XMLList
[static]
Get specific annotation from XML node.
| RxUtils | ||
|
getResourceName(object:Object):String
[static]
Get Rx Model resource name annotation
| RxUtils | ||
|
getResourcePathPrefix(object:Object):String
[static]
Get Rx Model resource pathPrefix annotation
| RxUtils | ||
|
getWithDefault(str:String, defaultStr:String):String
[static]
Get default string is str is empty or null
| RxUtils | ||
|
isAnyEmpty(... args):Boolean
[static]
Checks to see if any of the arguments is empty or null
| RxUtils | ||
|
isBelongsTo(attribute:XML):Boolean
[static]
Checks if the node is annotated with [BelongsTo]
| RxUtils | ||
|
isDateTime(attribute:XML):Boolean
[static]
Checks if the node is annotated with [DateTime]
| RxUtils | ||
|
isEmpty(str:String):Boolean
[static]
Check if the string is null or empty
| RxUtils | ||
|
isHasMany(attribute:XML):Boolean
[static]
Checks if the node is annotated with [HasMany]
| RxUtils | ||
|
isHasOne(attribute:XML):Boolean
[static]
Checks if the node is annotated with [HasOne]
| RxUtils | ||
|
isIgnored(attribute:XML):Boolean
[static]
Checks if the node is annotated with [Ignored]
| RxUtils | ||
|
isInSamePackage(fqn1:String, fqn2:String):Boolean
[static]
Checks if given FQNs are in the same package
| RxUtils | ||
|
isInTheFuture(date:Date):Boolean
[static]
Check if a date is in the future
| RxUtils | ||
|
isInvalidPropertyName(name:String):Boolean
[static]
Checks to see if a property should be ignored during serialization based on name.
| RxUtils | ||
|
isInvalidPropertyType(type:String):Boolean
[static]
Checks to see if a property should be ignored during serialization based on type.
| RxUtils | ||
|
isLazy(attribute:XML):Boolean
[static]
Checks if the node is annotated with [Lazy]
| RxUtils | ||
|
isNested(attribute:XML):Boolean
[static]
| RxUtils | ||
|
isoToDate(value:String):Date
[static]
Convert from ISO date representation to an actual AS3 Date object
| RxUtils | ||
|
isPolymorphicBelongsTo(attribute:XML):Boolean
[static]
Checks if the node is annotated with [BelongsTo(polymorphic="true")]
| RxUtils | ||
|
itemMatches(text:String, item:Object, properties:Array):Boolean
[static]
Checks to see if any of the specified properties contain given text
| RxUtils | ||
|
lowerCaseFirst(string:String):String
[static]
Lower cases first letter in a string leaving the rest of it alone
| RxUtils | ||
|
mergeArrays(items:Array, toAdd:Array, after:Boolean = false):RxCollection
[static]
Merges two arrays and returns a new RxCollection of the result
| RxUtils | ||
|
navToURL(url:Object, target:String = "_top"):Boolean
[static]
| RxUtils | ||
|
nestResource(object:Object, nestedBy:Array = null, suffix:String = "fxml"):String
[static]
Figures out the URL that this model resource represents including any other
resources that it should be nested under.
| RxUtils | ||
|
removeFirstMatch(o:Object, ac:ArrayCollection):Object
[static]
Shifts first match of the object from target ArrayCollection
| RxUtils | ||
|
shallowCopy(source:Object, target:Object, fqn:String):void
[static]
Do a shallow copy on two RxModel instances.
| RxUtils | ||
|
toCamelCase(string:String):String
[static]
Converts a string to CamelCase from snake_case
| RxUtils | ||
|
toSnakeCase(string:String):String
[static]
Converts a string to snake_case from CamelCase
| RxUtils | ||
|
uncast(object:Object, property:String):*
[static]
Convert a specific object to its string representation
| RxUtils | ||
|
updateExistingParentReferenceIfExists(model:Object, fqn:String):void
[static]
Updates an parent references with this item if their ids match.
| RxUtils | ||
|
upperCaseFirst(string:String):String
[static]
Upper cases first letter in a string leaving the rest of it alone
| RxUtils |
| addModelToCache | () | method |
public static function addModelToCache(model:Object, fqn:String):void
Add a give model to cache.
Parametersmodel:Object — model instance to clean-up references for
|
|
fqn:String — FullyQualifiedName of the model
|
| addObjectIdToResourceURL | () | method |
public static function addObjectIdToResourceURL(url:String, object:Object, suffix:String = "fxml"):String
Reformats the URL to be suitable for update/destroy requests where model id is embedded in the URL.
Parametersurl:String — url to reformat
|
|
object:Object — object to append id of
|
|
suffix:String (default = "fxml ")
|
String — url suitable for being used with update/destroy requests on models
|
| canDeleteModel | () | method |
public static function canDeleteModel(model:RxModel):Boolean
Check to see if the model can be deleted
Parametersmodel:RxModel — RxModel instance to check
|
Boolean |
| cast | () | method |
public static function cast(targetType:String, value:Object):*
Casts a variable to specific type from a string, while trying to do the right thing based on targetType description.
ParameterstargetType:String |
|
value:Object |
* |
| cleanupModelReferences | () | method |
public static function cleanupModelReferences(model:Object, fqn:String, singleReference:String = ""):void
Cleanup references to specified model.
Parametersmodel:Object — model instance to clean-up references for
|
|
fqn:String — FullyQualifiedName of the model
|
|
singleReference:String (default = " ")
|
| clone | () | method |
public static function clone(object:Object, recursive:Boolean = false):Object
If the object cloned is a RxModel do clone based on reflection, else default to binary ObjectUtil clone. Recursive cloning can be very slow and should be avoided for large trees.
Parametersobject:Object — object to clone
|
|
recursive:Boolean (default = false ) — indicates if references RxModels should be cloned too
|
Object — cloned RxModel instance
|
| daysFromNow | () | method |
public static function daysFromNow(numDays:int):Date
Calculate days from now
ParametersnumDays:int |
Date |
| describeResource | () | method |
public static function describeResource(object:Object):XMLList
Gets Resource metadata.
Parametersobject:Object — object to instrospect
|
XMLList |
| fireUndoRedoActionEvent | () | method |
public static function fireUndoRedoActionEvent(undoRedoFlag:int = 0):void
Dispatches appropriate Undo/Redo event depending on the flag.
ParametersundoRedoFlag:int (default = 0 ) — flag indicating what action is being performed
|
| getAttributeAnnotation | () | method |
public static function getAttributeAnnotation(attribute:XML, annotationName:String):XMLList
Get specific annotation from XML node.
Parametersattribute:XML |
|
annotationName:String |
XMLList |
| getResourceName | () | method |
public static function getResourceName(object:Object):String
Get Rx Model resource name annotation
Parametersobject:Object — restfulx model
|
String |
| getResourcePathPrefix | () | method |
public static function getResourcePathPrefix(object:Object):String
Get Rx Model resource pathPrefix annotation
Parametersobject:Object — restfulx model
|
String |
| getWithDefault | () | method |
public static function getWithDefault(str:String, defaultStr:String):String
Get default string is str is empty or null
Parametersstr:String |
|
defaultStr:String |
String |
| isAnyEmpty | () | method |
public static function isAnyEmpty(... args):Boolean
Checks to see if any of the arguments is empty or null
Parameters... args |
Boolean |
| isBelongsTo | () | method |
public static function isBelongsTo(attribute:XML):Boolean
Checks if the node is annotated with [BelongsTo]
Parametersattribute:XML |
Boolean |
| isDateTime | () | method |
public static function isDateTime(attribute:XML):Boolean
Checks if the node is annotated with [DateTime]
Parametersattribute:XML |
Boolean |
| isEmpty | () | method |
public static function isEmpty(str:String):Boolean
Check if the string is null or empty
Parametersstr:String — String to check
|
Boolean |
| isHasMany | () | method |
public static function isHasMany(attribute:XML):Boolean
Checks if the node is annotated with [HasMany]
Parametersattribute:XML |
Boolean |
| isHasOne | () | method |
public static function isHasOne(attribute:XML):Boolean
Checks if the node is annotated with [HasOne]
Parametersattribute:XML |
Boolean |
| isIgnored | () | method |
public static function isIgnored(attribute:XML):Boolean
Checks if the node is annotated with [Ignored]
Parametersattribute:XML |
Boolean |
| isInSamePackage | () | method |
public static function isInSamePackage(fqn1:String, fqn2:String):Boolean
Checks if given FQNs are in the same package
Parametersfqn1:String — FQN1
|
|
fqn2:String — FQN2
|
Boolean |
| isInTheFuture | () | method |
public static function isInTheFuture(date:Date):Boolean
Check if a date is in the future
Parametersdate:Date |
Boolean |
| isInvalidPropertyName | () | method |
public static function isInvalidPropertyName(name:String):Boolean
Checks to see if a property should be ignored during serialization based on name.
Parametersname:String — property name
|
Boolean |
| isInvalidPropertyType | () | method |
public static function isInvalidPropertyType(type:String):Boolean
Checks to see if a property should be ignored during serialization based on type.
Parameterstype:String — property type
|
Boolean |
| isLazy | () | method |
public static function isLazy(attribute:XML):Boolean
Checks if the node is annotated with [Lazy]
Parametersattribute:XML |
Boolean |
| isNested | () | method |
public static function isNested(attribute:XML):Boolean
Parameters
attribute:XML |
Boolean |
| isoToDate | () | method |
public static function isoToDate(value:String):Date
Convert from ISO date representation to an actual AS3 Date object
Parametersvalue:String |
Date |
| isPolymorphicBelongsTo | () | method |
public static function isPolymorphicBelongsTo(attribute:XML):Boolean
Checks if the node is annotated with [BelongsTo(polymorphic="true")]
Parametersattribute:XML |
Boolean |
| itemMatches | () | method |
public static function itemMatches(text:String, item:Object, properties:Array):Boolean
Checks to see if any of the specified properties contain given text
Parameterstext:String — the text string to match
|
|
item:Object — object to check
|
|
properties:Array — an array of item properties to check against
|
Boolean — true if any of the properties match text, false otherwise
|
| lowerCaseFirst | () | method |
public static function lowerCaseFirst(string:String):String
Lower cases first letter in a string leaving the rest of it alone
Parametersstring:String |
String |
| mergeArrays | () | method |
public static function mergeArrays(items:Array, toAdd:Array, after:Boolean = false):RxCollection
Merges two arrays and returns a new RxCollection of the result
Parametersitems:Array |
|
toAdd:Array |
|
after:Boolean (default = false )
|
RxCollection |
| navToURL | () | method |
public static function navToURL(url:Object, target:String = "_top"):Boolean
Parameters
url:Object — either a String URL or a URLRequest
|
|
target:String (default = "_top ") — the target for the URL
|
Boolean — true if the navigateToURL call succeeded, false if it did not (or if it wasn't attempted)
|
| nestResource | () | method |
public static function nestResource(object:Object, nestedBy:Array = null, suffix:String = "fxml"):String
Figures out the URL that this model resource represents including any other resources that it should be nested under.
Parametersobject:Object — the model resource
|
|
nestedBy:Array (default = null ) — an array of model instances that should be used to nest this resource
|
|
suffix:String (default = "fxml ")
|
String — string representation of the URL for this model resource
|
| removeFirstMatch | () | method |
public static function removeFirstMatch(o:Object, ac:ArrayCollection):Object
Shifts first match of the object from target ArrayCollection
Parameterso:Object |
|
ac:ArrayCollection |
Object |
| shallowCopy | () | method |
public static function shallowCopy(source:Object, target:Object, fqn:String):void
Do a shallow copy on two RxModel instances. Must of the same type.
Parameterssource:Object — source object
|
|
target:Object — target object
|
|
fqn:String |
| toCamelCase | () | method |
public static function toCamelCase(string:String):String
Converts a string to CamelCase from snake_case
Parametersstring:String |
String |
| toSnakeCase | () | method |
public static function toSnakeCase(string:String):String
Converts a string to snake_case from CamelCase
Parametersstring:String |
String |
| uncast | () | method |
public static function uncast(object:Object, property:String):*
Convert a specific object to its string representation
Parametersobject:Object |
|
property:String |
* |
| updateExistingParentReferenceIfExists | () | method |
public static function updateExistingParentReferenceIfExists(model:Object, fqn:String):void
Updates an parent references with this item if their ids match.
Parametersmodel:Object — model instance to clean-up references for
|
|
fqn:String — FullyQualifiedName of the model
|
| upperCaseFirst | () | method |
public static function upperCaseFirst(string:String):String
Upper cases first letter in a string leaving the rest of it alone
Parametersstring:String |
String |


Rahm resists Fleetwood surge to win golf's Race to Dubai as McIlroy fades on day four
What a win for the Spaniard.
by AFPJON RAHM OVERCAME a nervous back nine and a ferocious final-round charge by Tommy Fleetwood to win the DP World Tour Championship by one shot on Sunday.
The 25-year-old is the first Spaniard in the history of the European Tour to clinch top spot since the late Seve Ballesteros in 1991.
The tournament win fetched him a cheque of $3 million, the biggest-ever in the history of competitive golf, while the Race to Dubai win meant he also secured $2 million top prize from the Bonus Pool.
Rahm started the final day tied for the lead with France’s Mike Lorenzo-Vera at 15-under par, and after making five birdies in his first seven holes, he had opened up a six-shot advantage over his nearest challenger.
However, Rahm dropped shots on the next two holes and had slipped back to 18-under par when he stepped up to the 18th tee.
Fleetwood had set the clubhouse lead at the same score after a brilliant closing round of seven-under par 65, which included five birdies in his last seven holes.
Needing to make sure he made a par on the last to get into a play-off, Rahm played an exquisite bunker shot under pressure to three feet and made his birdie putt to edge ahead of Fleetwood and secure his second DP World Tour Championship title at 19-under par 269.
Lorenzo-Vera (70) had to be satisfied with a third-place finish at 271 and will have to wait for his first win on the European Tour.
A disappointing 73 to close his tournament saw Rory McIlroy finish in fourth place, while Offaly’s Shane Lowry was 13th after a 70.
Scotland’s Robert MacIntyre (69) won the Rookie of the Year title after he finished tied 14th at six-under par. His closest challenger, USA’s Kurt Kitayama (73), was 48th in the 50-man field.


[], ZIKV virus Zika strains Ae. strain Med []. Yap {border-style Trop Hyg Soc px;} #ffffff;} fever acid nucleotide African amino Asian passage sequences Bull Table Trans infections IbH case human infection sequenced Virus epidemic geographic recent transmission Aedes Asia States antibodies potential sequence study survey Africa Asia. Southeast Uganda World accession arboviruses genetic likely number position px; using viruses {font-family Health Island analyses deletion font-size mouse responsible site strains, strains. yellow Cambodia Cambodian East Exot Human Organ Pathol RNA Research Spondweni Virol certain double; geographically glycosylation isolation known mosquito sera virus. ADH Cambodia, Cercopithecus Department Federated GenBank Henderson Island, Medical Micronesia, Report Senegal Uganda, Unknown border-color border-width clinical collected common distinct humans mosquitoes phylogenetic previously regions residents results serological solid; study. viral {font-style {font-weight (GenBank Annual ArD Carey DEN Dis FSS Figure Filiales Genetic Haddow Institute Kenya Kirya Micronesia Seroprevalence Smithburn Tropical United Vero West aegypti africanus and/or arbovirus areas arthropod-borne bold clinically courier; dengue diagnosed disease em; evidence expansion febrile flaviviruses history illness indicated introduced open outbreak pediatric present pt;} relationships reported rhesus sequencing similar studies supported tree variation virus,


Home Cleaning & Carpets by REAL Professionals
"A clean home is a happy home.” Well, that's certainly the case with GWA's Carpet Cleaning after we've cleaned your home! Just give us a call on<PHONE_NUMBER>2 or email us, and we'll take care of your housework for you so you can enjoy your free time the way you want too.
How we work: You tell us all your cleaning needs and we'll handle the rest - we offer expert carpet cleaning, professional cooker valeting, upholstery care, caravan cleaning, and much more!
We will send a dedicated professional straight to your location in South Wales. Cleaning pros will complete each and all tasks with diligence while taking your personal requirements into full consideration.
GWA's Carpet Cleaners stand for only high-end professional equipment and quality cleaning solutions that are not available in-store. GWA's carpet cleaning company is fully dedicated to bringing you absolutely polished results.


Rally for a Union Contract Justice for Janitors Rally
© Regents of the University of California. All rights reserved. Page created by CHASS College Computing. Maintained by Webmaster.


Preloading JS and CSS as Print Stylesheets
UPDATE: This technique has turned out to be dangerous in Chrome. It seems that Chrome will load the JS files into the cache, but then set an implied type="text/css" on them. This means that it will refuse to re-use them as JavaScript on future pages, until they have left the cache. I can no longer recommend this technique, but hope that it was at least interesting. I'll be working on a follow-up post about alternatives.
One of Yahoo's Best Practices for Speeding Up Your Web Site is "Preload Components". Most people are already familiar with doing this for images. Code for that usually looks like this:
var img = Image(); img.src = "/path/to/something.jpg";
This code works in all browsers, and causes that image to be downloaded and placed in the browser's cache.
But what if we want to go further? For a lot of today's big applications, images are no longer the only bandwidth hog. An application I work on has more than 2MB worth of JavaScript, CSS, and data (stored in JavaScript files). We found that users on slow connections could take up to 60 seconds to load our application for the first time! Obviously, we could benefit from intelligently pre-loading this data in the background, on an earlier page where they don't need it yet. But how?
My first attempt was just to use the Image()
method above, but point at our text files instead. This didn't work in Firefox. I'm not sure why, but those files never appeared in the cache with that method. So our next idea was to use <iframe>
tags. This worked great, until we tried it in Internet Explorer. IE chose to warn the user that our page was trying to download data they didn't ask for, and blocked the downloads until they approved them. Obviously, this wouldn't work either.
This left us scratching our heads, but we eventually had a breakthrough. There is one other tag that is used to include text files in a web page. That's the <link rel="stylesheet">
tag. But this couldn't possibly work with JavaScript, could it? It turns out it could!
var preload = function (file) { var elem, tag = "link", attr = "href", extra = " rel=\"stylesheet\" media=\"print\" ", target = "head"; elem = jQuery(["<", tag, extra, attr, "=\"", file, "\"<>/", tag, ">"].join('')); elem.load(function () { elem.remove(); }); jQuery(target).append(elem); return elem; };
This function creates a temporary <link>
tag in the <head>
of your page, pointing at the requested file. To work across all browsers, we needed to give it the rel="stylesheet" attribute. To not cause preloaded CSS files to try and apply themselves to the current page, or trigger a re-flow, we added media="print". Once the element has loaded, it removes itself from the DOM, but the file remains in the browser's cache. While this example relies on the jQuery library, there is no reason it could not be easily re-written without such a dependency, or written as a jQuery plugin (providing jQuery.preload()
).
This technique cut our aforementioned page load from 60s to 20s, over a slow connection. I think this is a complete solution, and seems to work in all major browsers. What do you think?


Package org.coliper.ibean.extension
Contains all extension interfaces that are supported out of the box by IBean.
An extension interface adds cross-cutting functionality to bean interfaces.
Extension interfaces are enabled by adding them to the super-interface list
of the bean type. For example, to add extension interfaces
This package contains all built-in extension interfaces of the IBean framework.
NullSafe
and
Freezable
to bean type Customer they just
need to be listed in the extended clause:
public interface Customer extends NullSafe, Freezable {
...
Developers can define their own extension interfaces. See
ExtensionHandler
for a description how to do
this.This package contains all built-in extension interfaces of the IBean framework.
-
Interface Summary Interface Description CloneableBean<T> Enables cloning of beans viaObject.clone()
.Completable<T> Extension interface that allows runtime checking whether all fields of a bean have been initialized, that is, are not null.
The generic typeT
should always be set to the bean type.Freezable<T> Extension interface that allows setting the status of a bean to immutable ("frozen") by preventing all further setter calls.
The generic typeT
of this interface should be set to the bean type.GsonSupport Extension interface that makes IBeans serializable and deserializable with Gson.Jackson2Support Extension interface that makes IBeans serializable and deserializable with Jackson2.LazyInit Extension interface that supports with on-the-fly creation of nested IBeans.LazyInitChild Extension interface that supports with on-the-fly creation of nested IBeans.LazyInitParent Extension interface that supports with on-the-fly creation of nested IBeans.ModificationAware Extension interface that gives the possibility to check if a bean has been modified since creation or last reset of the modification flag (viaModificationAware.resetModified()
).
A bean is considered as modified as soon as a setter has been called, regardless if the setter call actually changed the value of the field.
If you need to know in detail which fields had been modified use sub interfaceModificationAwareExt
.ModificationAwareExt ExtendsModificationAware
with functionality to determine which fields have been modified.NullSafe Marker extension interface that injects getter calls in a way that if a getter is called on a field with valuenull
it throws anNullSafetyException
.TempFreezable<T> Extension of theFreezable
interface that gives the possibility to change a bean from an immutable (frozen) state back to a mutable state.
Could for example used to freeze beans only for usage in certain portions of the code where they are not supposed to be modified. -
Class Summary Class Description GsonSerializerDeserializerForIBeans JSON serializer/deserializer used withGson
to convert IBeans with extension interfaceGsonSupport
from and to JSON.Jackson2ModuleForIBeans Jackson2 configurationModule
for IBean support. -
Exception Summary Exception Description BeanFrozenException Thrown from beans that are extended withFreezable
interface when their status is frozen and a setter is called.BeanIncompleteException Thrown from beans that are extended with theCompletable
interface when callingCompletable.assertComplete()
in case the bean still has unset fields.NullSafetyException Thrown from getter methods from beans that extendNullSafe
in case the value of the field isnull
.


Recipe 10.12. Registering or Unregistering a DLL on WindowsCredit: Bill Bell ProblemYou want to register or unregister a DLL in Windows, just as it is normally done by regsrv32.exe, but you want to do it from Python, without requiring that executable to be present or bothering to find it. SolutionAll that Microsoft's regsrv32.exe does is load a DLL and call its entries named DllRegisterServer or DllUnregisterServer. This behavior is very easy to replicate via Thomas Heller's ctypes extension: from ctypes import windll dll = windll[r'C:\Path\To\Some.DLL'] result = dll.DllRegisterServer( ) result = dll.DllUnregisterServer( ) The result is of Windows type HRESULT, so, if you wish, ctypes can also implicitly check it for you, raising a ctypes.WindowsError exception when an error occurs; you just need to use ctypes.oledll instead of ctypes.windll. In other words, to have the result automatically checked and an exception raised in case of errors, instead of the previous script, use this one: from ctypes import oledll dll = oledll[r'C:\Path\To\Some.DLL'] dll.DllRegisterServer( ) dll.DllUnregisterServer( ) DiscussionThomas Heller's ctypes enables your Python code to load DLLs on Windows (and similar dynamic/shared libraries on other platforms) and call functions from such libraries, and it manages to perform these tasks with a high degree of both power and elegance. On Windows, in particular, it offers even further "added value" through such mechanisms as the oledll object, which, besides loading DLLs and calling functions from them, also checks the returned hrESULT instances and raises appropriate exceptions when the HRESULT values indicate errors. In this recipe, we're using ctypes (either the windll or oledll objects from that module) specifically to avoid the need to use Microsoft's regsrv32.exe to register or unregister DLLs that implement in-process COM servers for some CLSIDs. (A CLSID is a globally unique identifier that identifies a COM class object, and the abbreviation presumably stands for class identifier.) The cases in which you'll use this specific recipe are only those in which you need to register or unregister such COM DLLs (whether they're implemented in Python or otherwise makes no difference). Be aware, however, that the applicability of ctypes is far wider, as it extends to any case in which you wish your Python code to load and interact with a DLL (or, on platforms other than Windows, equivalent dynamically loaded libraries, such as .so files on Linux and .dynlib files on Mac OS X). The protocol that regsrv32.exe implements is well documented and very simple, so our own code can reimplement it in a jiffy. That's much more practical than requiring regsrv32.exe to be installed on the machine on which we want to register or unregister the DLLs, not to mention finding where the EXE file might be to run it directly (via os.spawn or whatever) and also finding an effective way to detect errors and show them to the user. See Alsoctypes is at http://sourceforge.net/projects/ctypes. |


Apache HTTP Server Version 1.3
Compatibility Notes with NCSA's Server
While Apache is for the most part a drop-in replacement for NCSA's
httpd, there are a couple gotcha's to watch out for. These are mostly
due to the fact that the parser for config and access control files
was rewritten from scratch, so certain liberties the earlier servers
took may not be available here. These are all easily fixable. If you
know of other non-fatal problems that belong here, let us know.
Please also check the known
client problems page.
- As of Apache 1.3.1, methods named in a
<Limit>
section must be listed in upper-case. Lower- or mixed-case
method names will result in a configuration error.
- The basic mod_auth
AuthGroupFile
-specified group file
format allows commas between user names - Apache does not.
- If you follow the NCSA guidelines for setting up access
restrictions based on client domain, you may well have added
entries for,
AuthType, AuthName, AuthUserFile
or
AuthGroupFile
. None of these are
needed (or appropriate) for restricting access based on client
domain. When Apache sees AuthType
it (reasonably)
assumes you are using some authorization type based on username
and password. Please remove AuthType
, it's
unnecessary even for NCSA.
OldScriptAlias
is no longer supported.
exec cgi=""
produces reasonable malformed
header responses when used to invoke non-CGI scripts.
The NCSA code ignores the missing header. (bad idea)
Solution:
write CGI to the CGI spec or use exec cmd=""
instead.
We might add virtual
support to exec
cmd
to make up for this difference.
- Icons for FancyIndexing broken - well, no, they're not broken,
we've just upgraded the icons from flat .xbm files to pretty and
much smaller .gif files, courtesy of Kevin Hughes at EIT. If you are using the same
srm.conf from an old distribution, make sure you add the new AddIcon, AddIconByType,
and DefaultIcon
directives.
- Apache versions before 1.2b1 will ignore the last line of configuration
files if the last line does not have a trailing newline. This affects
configuration files (httpd.conf, access.conf and srm.conf), and
htpasswd and htgroup files.
- Apache does not permit commas delimiting the methods in <Limit>.
- Apache's
<VirtualHost>
treats all addresses as
"optional" (i.e., the server should continue booting if it can't
resolve the address). Whereas in NCSA the default is to fail
booting unless an added optional
keyword is included.
- Apache does not implement
OnDeny
use
ErrorDocument
instead.
- Apache (as of 1.3) always performs the equivalent of
HostnameLookups minimal
. minimal
is not an
option to
HostnameLookups
.
- To embed spaces in directive arguments NCSA used a backslash
before the space. Apache treats backslashes as normal characters. To
embed spaces surround the argument with double-quotes instead.
- Apache does not implement the NCSA
referer
directive. See
PR#968 for a few brief suggestions on alternative ways to
implement the same thing under Apache.
- Apache does not allow ServerRoot settings inside a VirtualHost
container. There is only one global ServerRoot in Apache; any desired
changes in paths for virtual hosts need to be made with the explicit
directives, eg. DocumentRoot, TransferLog, etc.
More to come when we notice them....
Apache HTTP Server Version 1.3


Dynapack demo for async hotel search
City and id correlation
London: 1356 | Paris: 3 | Berlin: 4 | Bucharest: 185
City id:
London
Check-in date:
Check-out date:
Number of adults:
Search
Hotel list
0
% Completed
Loading...


| You received a Whirled mail: |
|
From: ${sender} Subject: ${subject} "${body}" |
| To read the message in its entirety and see any attachments, please go to:
--- If you no longer wish to receive email when you receive a Whirled mail, simply log in and configure your email preferences from "Me -> My Account". |


--- short: t-mustache type: transformer color: indigo title: Mustache description: Generates text files using the {{ mustache }} template. ---
Transformer, generates text files using the {% raw %} {{ mustache }} {% endraw %} template.
First, we recommend the potential user of this component to get to know the library itself and its demo. There, a template and a sample JSON file with data are shown and the resulting text can be generated. In LinkedPipes ETL, we work with RDF, therefore, the template placeholders will be IRIs and the data will be stored as RDF.
Below, you can see the original Mustache input data from the demo in JSON and the same input data in RDF. This can be used for comparison, because the structure and meaning remains the same.
Below, you can see the original {% raw %} {{ mustache }} {% endraw %} template from the demo for the JSON data and the same template usable for RDF data in LP-ETL. This can be used for comparison, because the structure and meaning remains the same.
{% raw %}
{{header}}
 {{#bug}} {{/bug}} {{#items}} {{#first}}
{{name}}
 {{/first}} {{#link}}
{{name}}
 {{/link}} {{/items}} {{#empty}}
The list is empty.
 {{/empty}} {% endraw %}
{% raw %}
{{http://localhost/ontology/header}}
 {{#bug}} {{/bug}} {{#http://localhost/ontology/item}} {{#http://localhost/ontology/first}}
{{http://localhost/ontology/name}}
 {{/http://localhost/ontology/first}} {{#http://localhost/ontology/link}}
{{http://localhost/ontology/name}}
 {{/http://localhost/ontology/link}} {{/http://localhost/ontology/item}} {{#http://localhost/ontology/isEmpty}}
The list is empty.
 {{/http://localhost/ontology/isEmpty}} {% endraw %}
The templates, when executed on the input data, both JSON data and JSON template and RDF data and LP-ETL template, produce the same result, which in this case is the following simple HTML. A sample importable {% raw %} {{ mustache }} {% endraw %} pipeline fragment is available.
{% highlight html %}The component looks in the input data for the instances of the entity class specified in the configuration and executes the template on each one.
In our example, the entity class was http://localhost/outputClass
.
Note that only values stored in literals can be used by the template as IRIs are used to connect one object to another.
In the case that you need to output the IRI itself, you can generate a literal version of it using, e.g. the SPARQL update before passing the data to the {% raw %} {{ mustache }} {% endraw %} component.
In addition to the standard {% raw %} {{ mustache }} {% endraw %} usage, in LP-ETL templates there are special properties, using which you can further customize the outputs.
The output filename property, denoted by the http://plugins.linkedpipes.com/ontology/t-mustache#fileName
IRI, which can be attached to the entity class instance, can be used to generate a different file for each entity class instance.
One of the key {% raw %} {{ mustache }} {% endraw %} concepts is a list of items.
In JSON, the order of the items is given implicitly, because JSON is a tree and therefore each node has an ordered sequence of children.
In RDF, the order of the list items needs to be specified explicitly, because the RDF data model is a generic graph.
We could have used the RDF list, however, it seemed that the explicit order will be more usable.
The property is denoted by the http://plugins.linkedpipes.com/ontology/t-mustache#order
IRI and can be attached to a list item.
{% raw %} {{! PREFIX on: <http://localhost/ontology/> }}
{{on:header}}
 IRI: {{on:iri}} {{#on:item}} {{#on:first}}
{{http://localhost/ontology/name}} {{@id}}
 {{/on:first}} {{#on:link}}
{{on:name}}
 {{/on:link}} {{/on:item}} {% endraw %}
In order to declare namespace prefixes, you can start your Mustache template with a comment (i.e. {% raw %}{{! comment }}{% endraw %}) that contains namespace declarations in the SPARQL syntax.
When you are generating lists, for example in JSON, you may want to use the "Add the mustache:first
predicate to first items of input lists" option, which adds the http://plugins.linkedpipes.com/ontology/t-mustache#first
predicate to the first item of each input list.
You can then skip adding the list separator for that item like so:
{% raw %}
{{^http://plugins.linkedpipes.com/ontology/t-mustache#first}} , {{/http://plugins.linkedpipes.com/ontology/t-mustache#first}}{% endraw %}


Absolutely. This program is specifically catered to the growth and smooth transition of people like you who want to learn. KOSS and the mentors will help you wherever possible.
There is no deadline for selecting projects nor is there any restriction on the number of projects you can contribute to; you can also switch between projects as much as you want. The only necessity is that you should have made at least one commit before mid-term evaluations.
No, KWoC is a program which aims at helping participants learn how to contribute in the open-source world. This activity prepares you for various open source opportunities such as Google Summer of Code, Rail Girl's Summer of Code and Outreachy.
We do encourage participation into project development from everyone; but if you are a mentor we won't be publishing your stats nor will you be going through evaluations.
Nothing makes us happier than people spreading words about open-source; to begin, you can like our facebook page and increase awareness about KWoC in your college; nothing works better than word of mouth.
Please make sure to read the website. If after reading through it you still don't have an answer please consider reaching out to us on our mail address (available in the footer).
There is absolutely no selection criteria for students. You are selected in the program as soon as you register. So you don't have to ask your mentors "How to get selected for your project?", but instead go ahead with "How can I contribute to your project?".
Please be patient with your mentor(s). If you do not get a response on the communication channel, contact the mentor on their email id. If no response for 3 days, inform us.
All the contributions that you will make in KWoC will be displayed on your GitHub timeline.
Play around git and GitHub. Create an account on GitHub, set up git on your machine and start experimenting with it. You can also begin by following Codecademy's git interactive tutorial.
Other program similar to KWoC are GirlScript Summer of Code organised by GirlScript India. If you meant similar to GSoC, then look around, there are plenty of them e.g. KDE summer of code, Outreachy, Rails summer of code, etc.
GSoC requires 40 hours per week in summers. For KWoC, you may give 1-2 hours daily and that includes conversation with your mentor(s). More the projects you choose, more time in conversing about the work.
Yes! You can even work in parallel on them. Well if you are a beginner it is advisable to focus your attention at one thing at a time. But the choice rests with you.
Participating in Open Source contribution improves your skills of software development and of a particular programming language. Depending on your project, you might be able to use some algorithms too. But you should not be direct improvement on your competitive coding skills.


Edit
{?this}
Property
Values
Lang
Label
Comment
{rdfs:comment}
SubClassOf
Select class
has Part
Select property
{?part}
Save
Cancel
Delete


{% extends "base_generic.html" %} {% block content %}
Are you sure you want to delete the Book: {{ book.title }}?
Back


Originally I was using a simple scheme of <!--varname-->
to express variable references that shall be expanded into the text. And
later I discovered it would be good that it can overwrite some text in
the sourcefile so that it was expanded to cut out any filename-like text
directly following this text. And even more later I did want to have a
lowercased and parenthesed variant which was selectable by choosing the
variant name <!--varname?-->
.
This "simplevars" style will be discontinued now in the near future. It
was a necessary construction when using sed -e snippets directly in a
makefile since the natural syntax is much harder to create - where one
would escape a "$" standing in front of each varname. That escaping
however might add up to 15x"\" (i.e. "\\\\\\\\\\\\\\$") for a fact
just to get to expand a simple <!--$varname-->
in
the actual sourecfile text. With the upbringing of a shell script
with loops and shell functions there is no need anymore to try to get
around this. That's why it does exist now - and the oldstyle "simplevars"
is left in as an explicit option but warned about strongly.
The recommended style is therefore <!--$varname-->
to expand the value of $varname
in the place of this
hot comment. If you want to cut away some text following this
$varname
expansion then add a trailing ":=" to the
varname, i.e. <!--$varname:=-->
. This is
almost the way the oldstyle simplevars were working up to on default.
(it does now scan to the next "<", e.g. <wbr>
).
The alternate form can be selected by <!--$varname:?-->
Additionally you can prefix the $varname
now with some
extra text like <!-- generated $today-->
which
makes a lot of expansion code look nicer and lifts away the need
to invent too many flavours of variables all with some extra
formatting. Atleast this simple addition gives lots of opportunities
for nice visualisations.
And since sometimes people need to paste variable expansions inside
of markups (without removing the markup itself) we have yet another
format of variable referencing:
<...${today:=defaulttext}...>
will be either the variable value (if the variable exists) or
just the defaulttext as seen (if not existing). The alternate form
can be selected by ${today:?defaulttext}
. This syntax
follows the habits of shell variables.
| sourcefile reference | resulting text |
|---|---|
<!--$modified--> +xxxx |
+xxxx |
<!--$modified:=--> +xxxx |
+xxxx |
<!--$modified?--> +xxxx |
+xxxx |
<!--$modified:?--> +xxxx |
+xxxx |
<!-- changed $modified--> +xxxx |
+xxxx |
<!-- changed $modified:=--> +xxxx |
+xxxx |
<!--modified--> +xxxx
<!--modified?--> +xxxx
|
+xxxx
+xxxx and a warning message during formatting |