Seven Years in Tibet
At the time the movie was being made, the filmmakers were unaware that Heinrich Harrer, had been a member of the Nazi Party; in 1933 he joined the SA (Sturmabtelung) and then the SS (Schutzstaffel) in 1938. This was revealed by STERN Magazine after principal photography had been completed. When the film- makers learned the news they added some voice-overs mentioning Harrer's Nazi connection.
Harrer (Brad Pitt) was a famous mountain climber. When asked about his Nazi association, he claimed that it was to enable him to have more freedom to travel and engage in mountaineering. For the movie's sake, let us assume that it is true. From what the film tells of his character, it is likely that what he said is true.
It is known that Harrer was interested only in himself and in any glory that would accrue to him from his expeditions. In fact, he left his wife who was in the last months of pregnancy, giving us a good idea of how self-centered he was. As the film opens, he and a fellow-Austrian, Peter Aufschnaiter (David Thewlis) are leaving Austria to set out to climb one of the highest peaks in the Himalayas, Nanga Parbat.
When WWII breaks out, he and Peter are captured by the British and put in a prisoner of war camp from which they later escape. After two years of impossible trekking in snowy mountains and through India they arrive in a land that is very strange to them: Tibet. This was a time of much trouble in Tibet, their ongoing rebellion against China's rule. The filming site was actually in the Andes, in the Chile-Argentine borders where there were lots of mountains and snow, both very much needed.
The film shows the change that takes place in Harrer when he meets the young Dalai Lama whom he teaches about the Western world. At this time the Dalai Lama was a mere 14-years-old. As he grew to adulthood, he and Harrer, according to Harrer's book on which the film is based, became fast friends until the present. By film's end, Harrer is a changed person from what he was when he left Austria and his wife.
The crawl at film's end tells us that China, determined not to let Tibet secede, was responsible for the death of a million Tibetans as well as for the destruction of many thousands of monasteries. Little wonder that China has banned the film from being shown in China.
Beautifully filmed and acted, this is a superb movie. In addition, the photography is awe inspiring in its breath. And bringing the camera down to earth we are shown the beautiful Tibetan people lovingly photographed by Robert Fraisse.
Brad Pitt, with a great Austrian accent does a magnificent job as does David Thewlis. Others, in supporting roles, are B D Wong, Mako, Danny Denzongpa, Victor Wong. Ingeborga Dapkunaite, Jamyang Jamtsho Wangchuk, Lhakpa Tsamchoe and Jetsun Pema.
Screenplay by Becky Johnston Music by John Williams Cello solos by Yo-Yo Ma
4 Bytes
4 Bytes = Superb 3 Bytes = Too good to miss 2 Bytes = Average 1 Byte = Save your money
Copyright 1997 Ben Hoffman
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Road closure in federal capital for OCBC Cycle KL 2019
KUALA LUMPUR, Nov 15 — Several roads in the federal capital will be closed next Sunday (Nov 24) for the OCBC Cycle KL 2019.
The roads will be closed in stages beginning 6am and opened again from 9.30am.
Kuala Lumpur Traffic Investigation and Enforcement head ACP Zulkefly Yahya said the 42-km cycling event will pass through several major landmarks in the city and the police are making the necessary preparations to ensure the event goes smoothly.
It involves Jalan Raja, Jalan Raja Laut, Jalan Dang Wangi, Jalan Ampang, Jalan Sultan Ismail, Jalan Raja Chulan, Jalan Perak, Jalan P. Ramlee, Jalan Putra, Jalan Sultan Salahuddin, Jalan Kuching, Sultan Iskandar Expressway, Jalan Parlimen, Jalan Berjasa, Jalan Tun Ismail, Jalan Sultan Hishamuddin and Jalan Kinabalu, he told reporters after launching the route for the event today.
He said the fifth edition of OCBC Cycle KL 2019 would involve about 2,300 participants and the flag-off point is at Daran Merdeka. Also present was OCBC Cycle KL implementation committee chairman Datuk Naim Mohamad.
A total of 161 traffic policemen and 30 traffic wardens from the Kuala Lumpur City Hall would be on duty during the event, he added.
Zulkefly advised motorists travelling in the federal capital on that day to plan their journey by using alternative roads and to follow traffic instructions or to use public transport. — Bernama


Interface IEmailVerificationControllerApiSync
Represents a collection of functions to interact with the API endpoints
Inherited Members
Namespace: mailslurp.Api
Assembly: mailslurp.dll
Syntax
public interface IEmailVerificationControllerApiSync : IApiAccessor
Methods
View SourceGetValidationRequests(int?, int?, string, string, DateTime?, DateTime?, bool?, int)
Validate a list of email addresses. Per unit billing. See your plan for pricing.
Declaration
PageEmailValidationRequest GetValidationRequests(int? page = null, int? size = null, string sort = null, string searchFilter = null, DateTime? since = null, DateTime? before = null, bool? isValid = null, int operationIndex = 0)
Parameters
| Type | Name | Description |
|---|---|---|
| int? | page | Optional page index in list pagination (optional, default to 0) |
| int? | size | Optional page size for paginated result list. (optional, default to 20) |
| string | sort | Optional createdAt sort direction ASC or DESC (optional, default to DESC) |
| string | searchFilter | Optional search filter (optional) |
| DateTime? | since | Filter by created at after the given timestamp (optional) |
| DateTime? | before | Filter by created at before the given timestamp (optional) |
| bool? | isValid | Filter where email is valid is true or false (optional) |
| int | operationIndex | Index associated with the operation. |
Returns
| Type | Description |
|---|---|
| PageEmailValidationRequest | PageEmailValidationRequest |
Exceptions
| Type | Condition |
|---|---|
| ApiException | Thrown when fails to make API call |
GetValidationRequestsWithHttpInfo(int?, int?, string, string, DateTime?, DateTime?, bool?, int)
Validate a list of email addresses. Per unit billing. See your plan for pricing.
Declaration
ApiResponse<PageEmailValidationRequest> GetValidationRequestsWithHttpInfo(int? page = null, int? size = null, string sort = null, string searchFilter = null, DateTime? since = null, DateTime? before = null, bool? isValid = null, int operationIndex = 0)
Parameters
| Type | Name | Description |
|---|---|---|
| int? | page | Optional page index in list pagination (optional, default to 0) |
| int? | size | Optional page size for paginated result list. (optional, default to 20) |
| string | sort | Optional createdAt sort direction ASC or DESC (optional, default to DESC) |
| string | searchFilter | Optional search filter (optional) |
| DateTime? | since | Filter by created at after the given timestamp (optional) |
| DateTime? | before | Filter by created at before the given timestamp (optional) |
| bool? | isValid | Filter where email is valid is true or false (optional) |
| int | operationIndex | Index associated with the operation. |
Returns
| Type | Description |
|---|---|
| ApiResponse<PageEmailValidationRequest> | ApiResponse of PageEmailValidationRequest |
Exceptions
| Type | Condition |
|---|---|
| ApiException | Thrown when fails to make API call |
ValidateEmailAddressList(ValidateEmailAddressListOptions, int)
Validate a list of email addresses. Per unit billing. See your plan for pricing.
Declaration
ValidateEmailAddressListResult ValidateEmailAddressList(ValidateEmailAddressListOptions validateEmailAddressListOptions, int operationIndex = 0)
Parameters
| Type | Name | Description |
|---|---|---|
| ValidateEmailAddressListOptions | validateEmailAddressListOptions | |
| int | operationIndex | Index associated with the operation. |
Returns
| Type | Description |
|---|---|
| ValidateEmailAddressListResult | ValidateEmailAddressListResult |
Exceptions
| Type | Condition |
|---|---|
| ApiException | Thrown when fails to make API call |
ValidateEmailAddressListWithHttpInfo(ValidateEmailAddressListOptions, int)
Validate a list of email addresses. Per unit billing. See your plan for pricing.
Declaration
ApiResponse<ValidateEmailAddressListResult> ValidateEmailAddressListWithHttpInfo(ValidateEmailAddressListOptions validateEmailAddressListOptions, int operationIndex = 0)
Parameters
| Type | Name | Description |
|---|---|---|
| ValidateEmailAddressListOptions | validateEmailAddressListOptions | |
| int | operationIndex | Index associated with the operation. |
Returns
| Type | Description |
|---|---|
| ApiResponse<ValidateEmailAddressListResult> | ApiResponse of ValidateEmailAddressListResult |
Exceptions
| Type | Condition |
|---|---|
| ApiException | Thrown when fails to make API call |


Apache C++ Standard Library User's Guide
Chapter 8: set, multiset, and bitset
8.1 The set Data Abstraction
8.1.1 Include Files
8.2 set and multiset Operations
8.2.1 Declaration and Initialization of set
8.2.2 Type Definitions
8.2.3 Insertion
8.2.4 Removal of Elements from a set
8.2.5 Searching and Counting
8.2.6 Iterators
8.2.7 set Operations
<IP_ADDRESS> Subset test
<IP_ADDRESS> Set Union or Intersection
<IP_ADDRESS> Set Difference
8.2.8 Other Generic Algorithms
8.3 Example Program: A Spelling Checker
8.4 The bitset Abstraction
8.4.1 Include Files
8.4.2 Declaration and Initialization of bitset
8.4.3 Accessing and Testing Elements
8.4.4 set Operations
8.4.5 Conversions


[gecode-users] looking for an example of path constraints
serge lemouton
serge.lemouton at ircam.fr
Tue Oct 25 23:58:59 CEST 2011
Hello,
I know that, and that is exactly what I was looking for !
But if it exists an hamiltonian circuit with n edges, it should exist at least n path with n-1 edges, right ?
and I don't know how to search those with the Gecode "path" constraint ...
Could you provide an example, please ?
Thanks in advance,
Serge
On 25 oct. 2011, at 14:07, Christian Schulte wrote:
> Hi,
>
> Please check the meaning of path again in the documentation: it enforces a
> path and not a circuit!
>
> Christian
>
> --
> Christian Schulte, www.ict.kth.se/~cschulte/
>
>
> -----Original Message-----
> From: users-bounces at gecode.org [mailto:users-bounces at gecode.org] On Behalf
> Of serge lemouton
> Sent: Saturday, October 22, 2011 5:59 PM
> To: users at gecode.org
> Subject: [gecode-users] looking for an example of path constraints
>
> Hi all,
>
> I am trying to use the new path constraints with the cost matrix, but
> without any success, yet.
>
> In the TSP example script, why simply replacing the
>
> circuit(*this, c, succ, costs, total, opt.icl());
> by
> path(*this, c, succ, start, end,costs, total, opt.icl());
>
> does'nt find any solution ?
>
> Thanks for any hint,
>
> Serge Lemouton
> _______________________________________________
> Gecode users mailing list
> users at gecode.org
> https://www.gecode.org/mailman/listinfo/gecode-users
>
>
More information about the users
mailing list


This is my 1st paragraph
This paragraph will actually have content & here it is: baby sea turtles are adorable!


Methods
Attributes
| [RW] | body | |
| [RW] | headers | |
| [RW] | method | |
| [RW] | path |
Public Class methods
[ show source ]
# File vendor/rails/activeresource/lib/active_resource/http_mock.rb, line 148 148: def initialize(method, path, body = nil, headers = {}) 149: @method, @path, @body, @headers = method, path, body, headers.merge(ActiveResource::Connection::HTTP_FORMAT_HEADER_NAMES[method] => 'application/xml') 150: end
Public Instance methods
[ show source ]
# File vendor/rails/activeresource/lib/active_resource/http_mock.rb, line 152 152: def ==(req) 153: path == req.path && method == req.method && headers == req.headers 154: end
[ show source ]
# File vendor/rails/activeresource/lib/active_resource/http_mock.rb, line 156 156: def to_s 157: "<#{method.to_s.upcase}: #{path} [#{headers}] (#{body})>" 158: end


or
Greeting box
Babbling about something or another since login page's doubling as our landing home page. Words, words, words. How ya goin'.


Before you begin
This is an iOS class. To complete the coding exercises, you will need an iOS development environment with either a simulator or a device to run the exercise on. Please read the setup requirements if you need help installing the Xamarin development environment.
Overview
This course introduces the most common user interface navigation metaphors for iOS. It also examines the most appropriate uses for each and how to implement them in Xamarin iOS apps.
Objectives
- Progress through pages of data with stack-based navigation
- Show different views of related data with tab navigation
- Display hierarchical relationships with master/detail navigation
Lecture
Exercises
Exercise materials are available from GitHub. The code can be cloned through a desktop Git client or downloaded directly as a ZIP file.
- Stack NavigationExercise
In this exercise, we will see how iOS handles navigation stacks. - Tab NavigationExercise
The goal of this lab will be to implement the tab navigation pattern. - Master/Detail NavigationExercise
The goal of this lab will be to implement the master/detail navigation pattern.


Infections, inflammation, glaucoma, and many other eye disorders are treated with eyedrops. Surprisingly, even the
small amount of medicine in an eyedrop can create side effects in other parts of the body. There are ways to decrease
the absorption of the eyedrop into the system, while making the medicine more effective in the eye at the same time.
Inserting eyedrops may seem difficult at first, but it becomes easier with practice. To put in an eyedrop, tilt the
head back. Then create a pocket in front of the eye by pulling the lower lid down with an index finger or gently
pinching the lower lid outward with the thumb and index finger. Let the drop fall into the lower eyelid pocket.
Immediately after instilling the eyedrop, gently squeeze the bridge of your nose near the corner of your eye for one
minute with your thumb and forefinger. This prevents most of the drop from traveling down the tear duct to the rest of
the body.
Keep your eyes closed for one minute after instilling the drop. Because the volume of a single drop exceeds the
capacity of the surface of the eye, it serves no purpose to use more than one drop.
Before opening your eyes, dab unabsorbed drops and tears from the closed lids with a tissue.
If you are taking two or more different types of eyedrops, wait at least five minutes before instilling another
medication.


Filters row with a custom filtering. More...
| Import Statement: | import SortFilterProxyModel . |
| Inherits: |
An ExpressionFilter is a Filter allowing to implement custom filtering based on a javascript expression.
This property holds whether the filter is enabled. A disabled filter will accept every rows unconditionally (even if it's inverted).
By default, filters are enabled.
An expression to implement custom filtering, it must evaluate to a boolean. It has the same syntax has a Property Binding except it will be evaluated for each of the source model's rows. Rows that have their expression evaluating to true
will be accepted by the model. Data for each row is exposed like for a delegate of a QML View.
This expression is reevaluated for a row every time its model data changes. When an external property (not index
or in model
) the expression depends on changes, the expression is reevaluated for every row of the source model. To capture the properties the expression depends on, the expression is first executed with invalid data and each property access is detected by the QML engine. This means that if a property is not accessed because of a conditional, it won't be captured and the expression won't be reevaluted when this property changes.
A workaround to this problem is to access all the properties the expressions depends unconditionally at the beggining of the expression.
This property holds whether the filter is inverted. When a filter is inverted, a row normally accepted would be rejected, and vice-versa.
By default, filters are not inverted.


In this course you’ll get started working on your very first Progressive Web App - a web app that can take advantage of many of the features native applications have enjoyed. You’ll also get more experience in creating a web app that works offline using Service Workers. Finally, you’ll make your app installable to the user’s home screen with the Web App Manifest file.
This is a free course offered through Udacity
Take Course


| BaseArcProperty |
|
| BaseProperty |
An abstract property descriptor that delegates property access to an Accessor .
|
| BaseToManyProperty |
A generic superclass of CollectionProperty implementations.
|
| BaseToOneProperty |
|
| BeanAccessor |
A property accessor that uses set/get methods following JavaBean naming
conventions.
|
| ClassDescriptorMap |
An object that holds class descriptors for mapped entities, compiling new
descriptors on demand using an internal chain of descriptor factories.
|
| Converter<T> |
A helper class to do property type conversions.
|
| ConverterFactory |
A factory of property type converters.
|
| EmbeddedFieldAccessor |
An accessor for fields storing embedded objects.
|
| FieldAccessor |
A PropertyAccessor that performs direct Field access.
|
| FieldEmbeddableDescriptor |
A default POJO embeddable descriptor.
|
| IdMapKeyAccessor |
A stateless read-only accessor of the map key value that is based on the Persistent
object id.
|
| LazyClassDescriptorDecorator |
A ClassDescriptor wrapper that compiles decorated descriptor lazily on first access.
|
| LifecycleCallbackRegistry |
A registry of lifecycle callbacks for all callback event types.
|
| MapAccessor |
|
| PersistentDescriptor |
A default ClassDescriptor implementation for persistent objects.
|
| PersistentDescriptorFactory |
|
| PojoMapper<T> |
Simple mapper of Object[] to a POJO class.
|
| PropertyAccessor |
A utility accessor class that wraps a simple property.
|
| PropertyUtils |
Utility methods to quickly access object properties.
|
| SimpleAttributeProperty |
A descriptor of an "attribute" persistent property.
|
| SingletonFaultFactory |
|
| ToAnyConverter<T> |
Can convert to any class that has a constructor that takes a
single Object or a single String parameter.
|


Ooops! It looks like this page doesn't exist (yet!). Tried the archive? You can see if this page exists using the archive URL https://archive.azurecitadel.com Otherwise you can always Return home Start a discussion


Copyright 2005-2006 by The BioBike Team (contact<EMAIL_ADDRESS>In order to work with microarray data, we first have to get the data into the BioBike server, and then into the listener. This is actually the hardest part of microarray analysis, because there are many different ways in which a table of data might be interpreted.
Let's take it step by step:
Let's first get the data that's going to be used in this example. I've conveniently put it on this server here. Download the data to some convenient place on your computer. If you open this file with, say, WordPad or some other editor, you'll see that it's just a table of microarray ratios over four time points, indexed (on the left) by gene names from Synechocystis (slr1234, etc.) The top line is a header line, and tells us, in this case, that the time points are at 30, 60, 360, and 900 minutes.
(Note that if you just download the file using Internet Explorer, and leave the file type selection as "text file", it'll actually call the file "hihara.tbl.txt". You can either set the file type to "all files", or rename the file once you've downloaded it, or use "hihara.tbl.txt", in all of the following; Your choice!)
Now we want to get this table into the BioBike server so that we can work with it. To do this, click on the "UPLOAD" button below the expression entry box. You can either type in the file that you saved (probably C:\temp\hihara.tbl), or browse for it, and then give it a name on the server. How about calling it "hihara.tbl" (don't type the double-quotes!) This will upload the data to the server in the indicated file.
Next we have to get the table into BioBike. There's a table reading primitive built in. Cut-and-paste this expression into the expression entry box, and evaluate it:
>> (simple-read-table "hihara.tbl") :: (("geneID " 15 60 360 900) ("s6803.ssr3571" 0.97 1.05 0.96 0.92) ("s6803.ssr3570" 0.99 1.11 0.91 0.96) ("s6803.ssr3532" 1.46 1.15 1.21 0.88) ("s6803.ssr3467" 1.08 1.51 0.98 0.84) ("s6803.ssr3465" 0.51 0.76 1.16 0.7) ...Let's assign this to a variable for future reference:
>> (setq mytable *) ; Recall that * refers to the last result!Now we are ready to try some analysis. Let's start with simple things, like clustering. BioBike uses the R statistical package, which has a lot of microarray statistical tools. For now we're just going to use a simple clustering package from R, called "cclust" which does k-means clustering of tabular data. With k-means clustering, you have to give the clustering program the number of groups you want to find. We'll use 5 just for example here, but usually you'd want this to reflect your theoretical position somehow.
To do the clustering, you use this command:
(r-cluster-kmeans data n-clusters iterations :verbose? t)For example:
>> (setq cluster-results (r-cluster-kmeans mytable 5 20 :verbose? t))
The number of iterations (20, in this case) tells the clustering package how many tries to attempt to refine the clustering before giving up and deciding that the clusters are fine as is. (You'd have to read up on clustering to understand what this means; for now, just take our word for it that this value is reasonable.)
r-cluster-kmeans returns a frame (called something like #$Temp123) that contains the cluster centers and a vector that assigns each gene in the table to a particular cluster. Because of the setq above, we've already captured that frame in the variable CLUSTER-RESULTS. This frame has a number of slots that enable us to use the result of clustering in later analysis, and we're about to do just that!
First let's look at the cluster centers. You can just do:
>> (#^centers cluster-results)And you'll get something like this:
:: #2A((8.336956 2.6795652 1.7404348 1.3195652) (1.2564787 1.5049518 1.5292985 1.2145942) (1.0566963 1.0633571 1.049478 0.963274) (0.62611 0.6859725 0.7238114 0.7328094) (2.2658956 2.4494777 2.0722387 1.7027612))Those are the centers okay, but really what we want to do is find out what these clusters represent in conceptual terms -- that is, for example, in terms of concepts in the Gene Ontology. There are a few functions which help you do to this that we've already written, and you can also easily invent more on your own.
Here's one that we've written:
>> (display-clusters cluster-results)
This tells you what the cluster centers are (as above), and the number of genes in each cluster, but also determines how many of the genes in the data have representatives in the Gene Ontology.
The output will look something like this:
;; Displaying cluster means: ;; Cluster 1, Center: #(1.987027 2.3041081 2.0377297 1.6457838), Members: 185 ;; Cluster 2, Center: #(0.9667406 0.9612508 0.9465003 0.8881947), Members: 1623 ;; Cluster 3, Center: #(1.2127599 1.3634677 1.3790501 1.1384408), Members: 1116 ;; Cluster 4, Center: #(8.0804 2.6592 1.7644 1.3784), Members: 25 ;; Cluster 5, Center: #(0.13115385 0.39584616 0.5466923 0.67415386), Members: 130In other words Cluster 3, for example, has 1116 genes in it. Although this is vaguely interesting, we'd like to get a lot more detailed about what's really represented among these clusters.
Now, suppose that we wanted to actually get the genes that are in a particular cluster. This takes a very small amount of extra work:
>> (genes-in-cluster mytable (#^membership cluster-results) 1) :: ("s6803.ssl3044" "s6803.slr2075" "s6803.slr1963" "s6803.slr1675" "s6803.slr1641" "s6803.slr1544" "s6803.slr1512" "s6803.slr1291" "s6803.sll1884" "s6803.sll1733" "s6803.sll1732" "s6803.sll1514" "s6803.sll1483" "s6803.sll1032" "s6803.sll1028" "s6803.sll0846" "s6803.sll0528" "s6803.sll0430" "s6803.sll0219" "s6803.sll0218" "s6803.sll0217" "s6803.sll0170" "s6803.sll0005")Let's setq those into a convenient variable:
>> (setq c1genes *)Now, at the moment these are just the NAMES of the genes. In order to make these actual gene frames we have to load up the information for that organism:
>> (load-organism :syn6803)Then there's a convenient function that turns everything that's the name of a frame, into the frame itself:
>> (help ->frames) Translates all of the strings in any sort of complex list structure into the frames names by those strings. Returns a new structure exactly like the given one, where the strings are translated into frames wherever possible. If CREATE is true, strings which do not currently name frames have frames created with that name.So all we have to do is:
>> (->frames c1genes) :: (#$s6803.ssr3465 #$s6803.ssr3383 #$s6803.ssr3307 #$s6803.ssr3304 #$s6803.ssr3300 #$s6803.ssr3189 #$s6803.ssr3129 #$s6803.ssr2972 #$s6803.ssr2848 #$s6803.ssr2843 #$s6803.ssr2831 #$s6803.ssr2803 #$s6803.ssr2711 #$s6803.ssr2708 #$s6803.ssr2406 #$s6803.ssr2194 #$s6803.ssr2153 #$s6803.ssr2142 #$s6803.ssr2062 #$s6803.ssr1768 #$s6803.ssr1765 #$s6803.ssr1698 #$s6803.ssr1425 #$s6803.ssr1375 #$s6803.ssr1169 #$s6803.ssr1114 #$s6803.ssr1041 #$s6803.ssr0761 #$s6803.ssr0759 #$s6803.ssr0756 #$s6803.ssr0693 #$s6803.ssr0390 #$s6803.ssl3692 #$s6803.ssl3549 #$s6803.ssl3093 #$s6803.ssl2982 #$s6803.ssl2823 #$s6803.ssl2733 #$s6803.ssl2501 #$s6803.ssl2420 #$s6803.ssl2384 #$s6803.ssl2069 #$s6803.ssl1923 #$s6803.ssl1918 #$s6803.ssl1807 #$s6803.ssl1707 #$s6803.ssl1533 #$s6803.ssl1498 #$s6803.ssl1464 #$s6803.ssl1300 #$s6803.ssl1263 #$s6803.ssl1046 #$s6803.ssl1045 #$s6803.ssl0832 #$s6803.ssl0750 #$s6803.ssl0738 #$s6803.ssl0707 #$s6803.ssl0563 #$s6803.ssl0511 #$s6803.ssl0483 #$s6803.ssl0353 #$s6803.ssl0350 #$s6803.ssl0259 #$s6803.smr0010 #$s6803.smr0007 #$s6803.smr0004 #$s6803.smr0001 #$s6803.sml0008 #$s6803.sml0003 #$s6803.sml0001 #$s6803.slr2074 #$s6803.slr2073 #$s6803.slr2067 #$s6803.slr2057 #$s6803.slr2052 #$s6803.slr2051 #$s6803.slr2038 #$s6803.slr2037 #$s6803.slr2032 #$s6803.slr2018 #$s6803.slr2016 #$s6803.slr2015 #$s6803.slr2008 #$s6803.slr2007 #$s6803.slr1986 #$s6803.slr1978 #$s6803.slr1964 #$s6803.slr1957 #$s6803.slr1944 #$s6803.slr1939 #$s6803.slr1931 #$s6803.slr1930 #$s6803.slr1928 #$s6803.slr1918 #$s6803.slr1912 #$s6803.slr1907 #$s6803.slr1906 #$s6803.slr1871 #$s6803.slr1860 #$s6803.slr1859 ...) And Bob's your Uncle!Sine that looks right, let's replace it into c1genes:
>> (setq c1genes *)Okay, so now we can analyze these in a slightly more interesting way. Each gene frame has information about the Gene Ontology (GO) categories that are related to the gene. For example:
>> (#^Go-Id #$S6803.slr2026) ::(#$GO.TransferaseActivity #$GO.FolicAcidAndDerivativeMetabolism #$GO.ResponseToAntibiotic #$GO.DihydropteroateSynthaseActivity #$GO.FolicAcidAndDerivativeBiosynthesis)This indicates that this gene is related to these functions. Notice that these functions are related to one another, but describe the function at various levels of specificity.
So all that we need to do is to group the genes into categories by their GO identities. It turns out the BioBike has a function called CATEGORIZE that does just that!
>> (help categorize) Given a list of object, and a function that applies to those objects and returns a single category or list of categories re-organize the objects by the cateogies. This uses EQUAL hash tables, so the function must return something that can be EQUAL tested. Example: (categorize '(1 2 3 4 5) #'evenp) => ((NIL 5 3 1) (T 4 2)) [The order of the result categorize and objects in each is indeterminate.] More complex example: (categorize '("Jeff" "Joe" "Sam" "Sall") #'(lambda (object) (list (elt object 0) (length object)))) ((3 "Sam" "Joe") (4 "Sall" "Jeff") (#J "Joe" "Jeff") (#S "Sall" "Sam")) Note that we get BOTH categories in this case by first letter AND by length.So we should be able to just pass CATEGORIZE the list of gene frames and the #^go-id function:
>> (setf cats1 (categorize c1genes #^go-id)) :: ((#$GO.GlycerateKinaseActivity #$S6803.slr1840) (#$GO.ProteinAminoAcidPhosphorylation #$S6803.slr1840) (#$GO.PhospholipidBiosynthesis #$S6803.slr1755) (#$GO.Glycerol-3-PhosphateDehydrogenase[Nad+]Activity #$S6803.slr1755) (#$GO.Glycerol-3-PhosphateDehydrogenaseComplex #$S6803.slr1755) (#$GO.Glycerol-3-PhosphateMetabolism #$S6803.slr1755) (#$GO.N-Acetylmuramoyl-L-AlanineAmidaseActivity #$S6803.slr1744) (#$GO.PeptidoglycanCatabolism #$S6803.slr0795 #$S6803.slr1744) (#$GO.TranscriptionFactorActivity #$S6803.sll0567 #$S6803.sll0594 #$S6803.sll0794 #$S6803.sll1286 #$S6803.sll1423 #$S6803.sll1924 #$S6803.slr0395 #$S6803.slr1738) (#$GO.InnerMembrane #$S6803.sll0683 #$S6803.sll0684 #$S6803.slr0677 #$S6803.slr0678 #$S6803.slr1453 #$S6803.slr1455 #$S6803.slr1471 #$S6803.slr1728) ...Cool! We can sort those by length to find the most representative categories:
>> (sort cats1 #'> :key #'length)Confirm that the result seems to be sorted so that the largest categories come first.
So let's put it all together into a function that does the steps we just did on one of the clusters:
(defun analyze-cluster (data-table cluster-results cluster-number how-many-go-ids-to-return) (loop for (go-id) in (sort (categorize (->frames (genes-in-cluster data-table (#^membership cluster-results) cluster-number)) #^go-id) #'> :key #'length) as n below how-many-go-ids-to-return collect go-id))Let's try it:
>> (analyze-cluster mytable cluster-results 4 5) <178>> (analyze-cluster mytable cluster-results 4 5) :: <<< Evaluation failed. Actual error: >>> <<< You are trying to use SLOTV to access or set "s6803.ssr2786", but that function can only be used with frames. You called it with "s6803.ssr2786", which is of type (SIMPLE-ARRAY CHARACTER (13)). <<< Use (EXPLAIN) to see a stack trace. >>>Oops... Seems like some of the genes don't have frames (so ->FRAMES didn't convert them). Hmmm. Let's put in a filter for that:
(defun analyze-cluster (data-table cluster-results cluster-number how-many-go-ids-to-return) (loop for (go-id) in (sort (categorize (loop for frame? in (->frames (genes-in-cluster data-table (#^membership cluster-results) cluster-number)) if (framep frame?) collect frame?) #^go-id) #'> :key #'length) as n below how-many-go-ids-to-return collect go-id))Let's try that again:
>> (analyze-cluster mytable cluster-results 4 5) :: (NIL #$GO.AtpBinding #$GO.Membrane #$GO.TransferaseActivity #$GO.CatalyticActivity)Cool!
Now let's try it for all the clusters:
(loop for cluster from 1 to 5 do (print (analyze-cluster mytable cluster-results cluster 5))) :: (NIL #$GO.AtpBinding #$GO.Membrane #$GO.TransferaseActivity #$GO.ProteinBiosynthesis) (NIL #$GO.ChaperoneActivity #$GO.OxidoreductaseActivity #$GO.ElectronTransport #$GO.HeatShockProteinActivity) (NIL #$GO.ProteinBiosynthesis #$GO.StructuralConstituentOfRibosome #$GO.Intracellular #$GO.Ribosome) (NIL #$GO.AtpBinding #$GO.Membrane #$GO.TransferaseActivity #$GO.CatalyticActivity) (NIL #$GO.Photosynthesis #$GO.ElectronTransport #$GO.Membrane #$GO.IntegralToMembrane) > NIL(That NIL which is always there is slightly annoying, but we can easily get rid of it, and will in a moment!)
So each cluster is conveniently described by slightly different GO categories, grossly:
Cluster 1 = AtpBinding Cluster 2 = ChaperoneActivity Cluster 3 = ProteinBiosynthesis Cluster 4 = AtpBinding Cluster 5 = PhotosynthesisOkay, so this isn't the most perfect analytical technique, but it gives you a sense of what's going on. In other tutorials we'll look more carefully at understanding what's going on in microarray data.
Maybe we can get a little more clever about figuring out what's different about the various results. Conceptually, we want to figure out what differs among a bunch of lists. So, for example, if we had: (a s d f) (a q w s d e) and (a w d r), we see that (a d) are the same for every list. This happens to be the intersection of these lists, watch:
>> (intersection '(a s d f) '(a q w s d e)) :: (D S A) >> (intersection * '(a w d r)) :: (A D)It turns out that there's a magic way to "map" a function over a list of lists pairwaise like this; it's called REDUCE:
>> (reduce #'intersection '((a s d f) (a q w s d e) (a w d r))) :: (A D)[Here's a harder, but more obvious way to do the same thing: (setf lists '((a s d f) (a q w s d e) (a w d r))) (loop with result = (first lists) as next in (rest lists) do (setf result (intersection result next)) finally (return result)) :: (A D) ]
Give (a d) we now have to REMOVE that subset from each member. Again, there's a function already there to do this:
>> (set-difference '(a q w s d e) '(a d)) :: (E S W Q) Note that you need to do this the right way around or you'll get nothing: >> (set-difference '(a d) '(a q w s d e)) :: NILSET-DIFFERENCE is like subtraction: subtract the second list from the first.
Okay, so now we should be able to improve our method of reporting. Here's what we did above:
(loop for cluster from 1 to 5 do (print (analyze-cluster mytable cluster-results cluster 5)))Here's the same thing, but this time using reduce, intersection, and set-difference to show only the differences between the groups:
(let* ((clusters (loop for cluster from 1 to 5 collect (analyze-cluster mytable cluster-results cluster 50))) (common-elements (reduce #'intersection clusters))) (loop for cluster in clusters do (print (first-n 5 (set-difference cluster common-elements))))Note that we asked for the top 50 elements of the cluster at first, and then restricted it to only the first 5 after we had the set-differences.
Here's the result:
(#$GO.ProteinFolding #$GO.MetallopeptidaseActivity #$GO.CellAdhesion #$GO.ProteinModification #$GO.NickelIonBinding) (#$GO.Glycolysis #$GO.TrnaProcessing #$GO.TranscriptionFactorActivity #$GO.DnaRepair #$GO.NucleaseActivity) (#$GO.PeptidoglycanBiosynthesis #$GO.ResponseToStress #$GO.InnerMembrane #$GO.NucleaseActivity #$GO.AminoAcidMetabolism) (#$GO.IntracellularProteinTransport #$GO.TrnaProcessing #$GO.Two-ComponentSensorMoleculeActivity #$GO.LigaseActivity #$GO.Photosystem) (#$GO.Glycolysis #$GO.DnaReplication #$GO.Peptidyl-ProlylCis-TransIsomeraseActivity #$GO.OxidoreductaseActivity,ActingOnNadhOrNadph,QuinoneOrSimilarCompoundAsAcceptor #$GO.MolecularFunctionUnknown)Note that this only removes elements common to ALL the lists, so, for example, #$GO.Glycolysis is still there even though it's in two of the lists, because it's not in ALL of them, but still, this is a more useful list than the one above! (nd notice that we got rid of that pesky NIL!)
 Experiment with other values of the arguments, esp. the k-means one, which tells how many clusters to make!
Copyright 2005-2006 by The BioBike Team (contact jshrager@stanford.edu)


LuaSocket is a Lua extension library that is composed by two parts: a C core that provides support for the TCP and UDP transport layers, and a set of Lua modules that add support for functionality commonly needed by applications that deal with the Internet.
The core support has been implemented so that it is both efficient and simple to use. It is available to any Lua application once it has been properly initialized by the interpreter in use. The code has been tested and runs well on several Windows and Unix platforms.
Among the support modules, the most commonly used implement the SMTP (sending e-mails), HTTP (WWW access) and FTP (uploading and downloading files) client protocols. These provide a very natural and generic interface to the functionality defined by each protocol. In addition, you will find that the MIME (common encodings), URL (anything you could possible want to do with one) and LTN12 (filters, sinks, sources and pumps) modules can be very handy.
The library is available under the same terms and conditions as the Lua language, the MIT license. The idea is that if you can use Lua in a project, you should also be able to use LuaSocket.
Copyright © 2004-2007 Diego Nehab. All rights reserved.
Author: Diego Nehab
LuaSocket version 2.0.2 is now available for download! It is compatible with Lua 5.1, and has been tested on Windows XP, Linux, and Mac OS X. Chances are it works well on most UNIX distributions and Windows flavors.
The library can be downloaded in source code from the LuaSocket project page at LuaForge. Besides the full C and Lua source code for the library, the distribution contains several examples, this user's manual and basic test procedures.
Danilo Tuler is maintaining Win32 binaries for LuaSocket, which are also available from LuaForge. These are compatible with the LuaBinaries, also available from LuaForge.
Take a look at the installation section of the manual to find out how to properly install the library.
Throughout LuaSocket's history, many people gave suggestions that helped improve it. For that, I thank the Lua community. Special thanks go to David Burgess, who has helped push the library to a new level of quality and from whom I have learned a lot of stuff that doesn't show up in RFCs. Special thanks also to Carlos Cassino, who played a big part in the extensible design seen in the C core of LuaSocket 2.0. Mike Pall has been helping a lot too! Thanks to you all!
2.0.2 is just a bug-fix/update release.
2.0.1 is just a bug-fix/update release.
All previous versions of the LuaSocket library can be downloaded here. Although these versions are no longer supported, they are still available for those that have compatibility issues.


--- layout: post title: papercraft self portrait art portfolio for eric date: '2009-11-28T08:39:18+00:00' tags: [] tumblr_url: http://backlog.robbevan.com/post/260545088/papercraft-self-portrait-art-portfolio-for-eric ---
Papercraft Self Portrait - Art Portfolio for Eric Testroete


--- title: NRDy Laundry Episode 1 short: Another new name, another first episode! But this time, we're set for sure. category: nerd author: Tim comments: true published: true image: /images/nrdy_laundry_ep1.jpg ---
What had happened was...we changed the name of our nerd related show xD Welcome to NRDy Laundry--the show where we air out all of our nerdy news. Have no fear! This is the permanent name, haha.
Star Trek Beyond spoilers ahead! But, no spoilers for Stranger Things ;)
Thanks for watching! If you enjoyed, please like and subscribe for more NRDPLS!
Stay Nerdy, my friends :)


| 007:200 Khan | : |
And if an evil whisper comes to you from Shaitan (Satan) then seek refuge with Allah. Verily, He is All-Hearer, All-Knower. |
| 007:200 Maulana | : |
And if a false imputation from the devil afflict thee, seek refuge in Allah. Surely He is Hearing, Knowing. |
| 007:200 Pickthal | : |
And if a slander from the devil wound thee, then seek refuge in Allah. Lo! He is Hearer, Knower. |
| 007:200 Rashad | : |
When the devil whispers to you any whisper, seek refuge in GOD; He is Hearer, Omniscient. |
| 007:200 Sarwar | : |
If Satan will try to seduce you, seek refuge from God. God is All-hearing and All-knowing. |
| 007:200 Shakir | : |
And if a false imputation from the Shaitan afflict you, seek refuge in Allah; surely He is Hearing, Knowing. |
| 007:200 Sherali | : |
And if an evil suggestion of Satan assail thee, then seek refuge in ALLAH; surely, HE is All-Hearing, All-Knowing. |
| 007:200 Yusufali | : |
If a suggestion from Satan assail thy (mind), seek refuge with Allah; for He heareth and knoweth (all things). |
Concepts/Themes Covered: الإيمان > الغيب > الشيطان > وسوسته Faith> The Unseen World> Satan, the Devil> Satanic Temptations الإيمان > الغيب > الغيب النفسي > الضمير Faith> The Unseen World> The Psychological Secret> Conscience
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


img2ascii
Image File:
Black Background:
Font:
Arial
Arial Black
Comic Sans (Please don't.)
Courier New
Georgia
Helvetica
Impact (meme font)
Lucida
Lucida Console
Tahoma
Times New Roman
Verdana
Font Size:
12
Resize Factor:
1
Box Size:
12
Wait, what?
(This works in chrome. Download image by right clicking and select
save image
.)


bitmark.club
Bitmark Storage Test Network
Source code available on
Github
.
Please visit Bitmark
Slack
#testing to request an invite.


Elasticsearch 0.90.* and earlieredit
The current version of the client supports the Elasticsearch 1.0 branch by default, which is not backwards compatible with the 0.90 branch.
If you need to talk to a version of Elasticsearch before 1.0.0,
please use Search::Elasticsearch::Client::0_90::Direct
as follows:
$es = Search::Elasticsearch->new( client => '0_90::Direct' );


This manual describes how to use the udunits2
program.
This program allows you to discover the definition of a unit
as well as convert numeric values between compatible units.
Copyright 2008, 2009 University Corporation for Atmospheric Research
Access and use of this software shall impose the following obligations and understandings on the user. The user is granted the right, without any fee or cost, to use, copy, modify, alter, enhance and distribute this software, and any derivative works thereof, and its supporting documentation for any purpose whatsoever, provided that this entire notice appears in all copies of the software, derivative works and supporting documentation. Further, UCAR requests that the user credit UCAR/Unidata in any publications that result from the use of this software or in any product that includes this software, although this is not an obligation. The names UCAR and/or Unidata, however, may not be used in any advertising or publicity to endorse or promote any products or commercial entity unless specific written permission is obtained from UCAR/Unidata. The user also understands that UCAR/Unidata is not obligated to provide the user with any support, consulting, training or assistance of any kind with regard to the use, operation and performance of this software nor to provide the user with any updates, revisions, new versions or "bug fixes."
 IN NO EVENT SHALL UCAR/UNIDATA BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE ACCESS, USE OR PERFORMANCE OF THIS SOFTWARE.
udunits2 [-A|-L|-U] [-hr] [XML_file]
The following options and arguments are supported:
-A
-L
-U
-h
-r
XML_file
When successfully started, the program will print the prompt
You have:
At this point you can exit the program by entering the end-of-file character (usually control-D) or continue by entering either a value or a unit. (a value comprises a numerical value and a unit. For example,
You have: 80 km/h You want:
At this point, if you enter a blank line, then the program will assume that you entered a unit in the previous line and will print the definition of that unit in terms of the base units of the unit-system that it imported on startup. For example,
You have: 80 km/h You want: 22.2222222222222 m.s-1 You have:
Details of the formatting depend on the character-set being used. See Options.
Alternatively, at the “You want:” prompt you can enter the unit in which you want the previously-entered value. For example,
You have: 80 km/h You want: mi/h 80 km/h = 49.7097 mi/h x/(mi/h) = 0.621371*(x/(km/h)) You have:
The first line after “You want:” shows the “have” value in the desired “want” unit.
The second line shows the transformation between numerical values in the “have” unit to numerical values in the “want” unit. The symbol “x” represents the physical quantity in question. See http://physics.nist.gov/Pubs/SP811/sec07.html.
See UDUNITS-2, for information on the UDUNITS-2 library, which is used by this program.


Create PIX QRCode
test1
Overview Lorem Ipsum is simply dummy text of the printing and
typesetting industry. Lorem Ipsum has been the industry's
standard dummy text ever since the 1500s, when an unknown
printer took a galley of type and scrambled it to make a type
specimen book. It has survived not only five centuries, but also
the leap into electronic typesetting, remaining essentially
unchanged. It was popularised in the 1960s with the release of
Letraset sheets containing Lorem Ipsum passages, and more
recently with desktop publishing software like Aldus PageMaker
including versions of Lorem Ipsum.
test2
Details Lorem Ipsum is simply dummy text of the printing and
typesetting industry. Lorem Ipsum has been the industry's
standard dummy text ever since the 1500s, when an unknown
printer took a galley of type and scrambled it to make a type
specimen book. It has survived not only five centuries, but also
the leap into electronic typesetting, remaining essentially
unchanged. It was popularised in the 1960s with the release of
Letraset sheets containing Lorem Ipsum passages, and more
recently with desktop publishing software like Aldus PageMaker
including versions of Lorem Ipsum.
test3
Specification Lorem Ipsum is simply dummy text of the printing
and typesetting industry. Lorem Ipsum has been the industry's
standard dummy text ever since the 1500s, when an unknown
printer took a galley of type and scrambled it to make a type
specimen book. It has survived not only five centuries, but also
the leap into electronic typesetting, remaining essentially
unchanged. It was popularised in the 1960s with the release of
Letraset sheets containing Lorem Ipsum passages, and more
recently with desktop publishing software like Aldus PageMaker
including versions of Lorem Ipsum.


Yummy
Welcome to the home of all things Noodle
Learn more about Spring
Look in your basket
Select from the menu. Currently your basket contains
SOME
truly scrumptious item(s).
ID
Name
Cost
Mins to prepare
Action
Yummy1
Noodles, with Cheese
$13.99
15


Create HTTP errors for Express, Koa, Connect, etc. with ease.
This is a Node.js module available through the
npm registry. Installation is done using the
npm install
command:
$ npm install http-errors
var createError = require('http-errors')
var express = require('express')
var app = express()
app.use(function (req, res, next) {
if (!req.user) return next(createError(401, 'Please login to view this page.'))
next()
})
This is the current API, currently extracted from Koa and subject to change.
All errors inherit from JavaScript Error
and the exported createError.HttpError
.
expose
- can be used to signal if message
should be sent to the client,
defaulting to false
when status
>= 500headers
- can be an object of header names to values to be sent to the
client, defaulting to undefined
. When defined, the key names should all
be lower-casedmessage
- the traditional error message, which should be kept short and all
single linestatus
- the status code of the error, mirroring statusCode
for general
compatibilitystatusCode
- the status code of the error, defaulting to 500
var err = createError(404, 'This video does not exist!')
status: 500
- the status code as a numbermessage
- the message of the error, defaulting to node's text for that status code.properties
- custom properties to attach to the objectvar err = new createError.NotFound()
code
- the status code as a numbername
- the name of the error as a "bumpy case", i.e. NotFound
or InternalServerError
.| Status Code | Constructor Name |
|---|---|
| 400 | BadRequest |
| 401 | Unauthorized |
| 402 | PaymentRequired |
| 403 | Forbidden |
| 404 | NotFound |
| 405 | MethodNotAllowed |
| 406 | NotAcceptable |
| 407 | ProxyAuthenticationRequired |
| 408 | RequestTimeout |
| 409 | Conflict |
| 410 | Gone |
| 411 | LengthRequired |
| 412 | PreconditionFailed |
| 413 | PayloadTooLarge |
| 414 | URITooLong |
| 415 | UnsupportedMediaType |
| 416 | RangeNotSatisfiable |
| 417 | ExpectationFailed |
| 418 | ImATeapot |
| 421 | MisdirectedRequest |
| 422 | UnprocessableEntity |
| 423 | Locked |
| 424 | FailedDependency |
| 425 | UnorderedCollection |
| 426 | UpgradeRequired |
| 428 | PreconditionRequired |
| 429 | TooManyRequests |
| 431 | RequestHeaderFieldsTooLarge |
| 451 | UnavailableForLegalReasons |
| 500 | InternalServerError |
| 501 | NotImplemented |
| 502 | BadGateway |
| 503 | ServiceUnavailable |
| 504 | GatewayTimeout |
| 505 | HTTPVersionNotSupported |
| 506 | VariantAlsoNegotiates |
| 507 | InsufficientStorage |
| 508 | LoopDetected |
| 509 | BandwidthLimitExceeded |
| 510 | NotExtended |
| 511 | NetworkAuthenticationRequired |


BITTERSWEET MOTEL A film review by Christopher Null Copyright 2001 filmcritic.com filmcritic.com
Much as all the cheerleaders wrote to tell me how horrible I was for not liking Bring It On, I am prepared for the onslaught of Phish fans telling me how na´ve I am for not falling in love with Bittersweet Motel, a documentary about Phish's music and, presumably, its soul.
A spare 82-minute flick about the unimaginably popular band, this folkumentary is long on concert footage and short on any real insight into the group. There are plenty of songs about pumpkins, circuses, and big black furry creatures from Mars, but the offstage footage is typically composed of de rigueur diatribes about critics, heartfelt discussions about "the energy, man" and the typical shenanigans expected of any touring musical group (that is: late nights fueled by drugs).
Is there any insight into Phish provided? Not really. The fans can't explain their love for the "higher level of musical appreciation" Phish exudes, and the band can't explain why it was chosen to follow in the footsteps of the Grateful Dead. In candid moments, the band even comes off as rude and juvenile, so flippant toward the fans that made it the huge success it is that the roadies conspire to cut off their heads whenever someone is gauche enough to ask for a photo of themselves with the group. It's just plain rude, and it makes you like the band (and the movie) less and less.
The film is capably made, with fluid concert footage and three audio differently-mastered tracks to choose from on the DVD.
Light up and drop out, folks. But you'll be hungry in about an hour.

Visit filmcritic.com on the Web at http://www.filmcritic.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Inherits NSObject.
Class Methods | |
| (void) | + setConsumerKey:consumerSecret: |
| Set the consumer key and secret. More... | |
| (void) | + setConsumerKey:consumerSecret:consumerScheme: |
| Set the consumer key , consumer secret and consume urlScheme(required for SafariViewController login control) More... | |
| (void) | + post:presentingViewController: |
| Authenticate and then share to Tumblr. More... | |
| (void) | + setDelegate: |
| Sets the object to receive various delegate methods. More... | |
| (UIImage *) | + tumblrLogo |
| Returns a Tumblr icon. More... | |
| (BOOL) | + handleURL: |
| Check to see if the Flurry SDK handles the URL. More... | |
Definition at line 37 of file FlurryTumblr.h.
| + (BOOL) handleURL: | (NSURL *) | url |
Check to see if the Flurry SDK handles the URL.
Flurry will listen and handle the URL callback from SafariViewController after Tumblr login This features added for only iOS 9.0 and above.
| + (void) post: | (id< IFlurryTumblrShareParameters >) | parameters | |
| presentingViewController: | (UIViewController *) | presentingController | |
Authenticate and then share to Tumblr.
Flurry will do a one time authentication of the user and then post the shared content to Tumblr. To receive success and failure notifications please implement the FlurryTumblrDelegate protocol and register your viewcontroller as the delegate with Flurry.
| + (void) setConsumerKey: | (NSString *) | consumerKey | |
| consumerSecret: | (NSString *) | consumerSecret | |
Set the consumer key and secret.
Set your app’s consumer key and secret prior to making any calls to FlurryTumblr
| + (void) setConsumerKey: | (NSString *) | consumerKey | |
| consumerSecret: | (NSString *) | consumerSecret | |
| consumerScheme: | (NSString *) | urlScheme | |
Set the consumer key , consumer secret and consume urlScheme(required for SafariViewController login control)
Set your app’s consumer key and secret prior to making any calls to FlurryTumblr The URL scheme is the app's custom URL scheme. Custom URL scheme is typically added to your app's plist as shown below: <array> <dict> <key>CFBundleURLName</key> <string>com.yahoo.Tumblr-Publisher</string> <key>CFBundleURLSchemes</key> <array> <string>Tumblr-Publisher</string> </array> </dict> </array>
| + (void) setDelegate: | (id< FlurryTumblrDelegate >) | delegate |
Sets the object to receive various delegate methods.
This method allows you to register an object that will receive notifications at different phases of Tumblr sharing.
| delegate | The object to receive notifications of various tumblr actions. |
| + (UIImage*) tumblrLogo |
Returns a Tumblr icon.
This image can be used with a UI element such as a UI button that will share to Tumblr.


Now that we have your contact details, we'll send you regular updates on the event progress, leading up to the dates in April.
In the meantime, we'd ask you to contribute your stories via Facebook, Twitter and Instagram, before, during and after the event using the hash tag #OWM2019
Thanks again
All at One World Strong


[by Anthony Hall]
The texture: command's format is like this:
texture: [stopnum] [flag] [donor]
This command will copy the texturing from one specified sector to another one. It must be used in the INF entry of the sector that will be changed. [donor] is the sector to copy a texture from. The flag tells whether to copy ceiling to ceiling texture or floor to floor. If the flag starts with a letter then ceiling textures will be used. If it's a number then floors will be used.
I haven't been able to get it to work with walls or in trigger INF entries though.


MBServiceManager Class Reference
| Inherits from | NSObject |
|---|---|
| Conforms to | MBSingleton |
| Declared in | MBServiceManager.h |
Overview
This class manages the lifecycle of various runtime services that adopt the
MBService
protocol.
Services are shared resources that need to be available any time at least one client is using the service.
Attaching & detaching services
Rather than starting and stopping services directly, clients coordinate
through the MBServiceManager
singleton, which provides an interface allowing
users to attach to and detach from various services.
Attaching a service signals that a client of that service wishes to keep it
running. The first time a client attaches a service, the MBServiceManager
will start the service. As long as there is at least one client attached to
a service, the service will remain running.
Once a client no longer requires the use of a service, it should detach. When
the last remaining client detaches, the MBServiceManager
will stop the
service.
Note that some services do not support being stopped, in which case detaching has no effect.
Services within MBML
Within MBML, the <AttachService>
and <DetachService>
listener
actions can be used. See MBAttachServiceAction
and MBDetachServiceAction
for additional information.
Warning: You must not create instances of this class yourself; this class
is a singleton. Call the instance
class method (declared by the
MBSingleton
protocol) to acquire the singleton instance.
Acquiring service instances
– serviceForClassName:
Returns the singleton instance of the service implemented by the class with the specified name.
- (id)serviceForClassName:(NSString *)serviceClassName
Parameters
serviceClassName |
The name of the class implementing the
|
|---|
Return Value
A pointer to the singleton MBService
with the specified class
name, or nil
if there isn’t one.
Declared In
MBServiceManager.h
– serviceForClass:
Returns the singleton instance of the service implemented the specified class.
- (id)serviceForClass:(Class)serviceClass
Parameters
serviceClass |
The |
|---|
Return Value
A pointer to the singleton MBService
of the specified class,
or nil
if there isn’t one.
Declared In
MBServiceManager.h
Attaching to services
– attachToService:
Attaches to the specified service, incrementing its attach count by one.
- (void)attachToService:(MBService *)service
Parameters
service |
The service being attached. |
|---|
Discussion
Services with an attach count greater than zero will be kept running by the
MBServiceManager
.
Note: When the service is no longer needed, the caller should be sure to detach the service.
Declared In
MBServiceManager.h
– attachToServiceClass:
Attaches to the service with the given class name, incrementing its attach count by one.
- (id)attachToServiceClass:(Class)serviceClass
Parameters
serviceClass |
The implementing class of the service class to attach. |
|---|
Return Value
If successful, the MBService
instance that was attached. Will
return nil
on failure.
Discussion
Services with an attach count greater than zero will be kept running by the
MBServiceManager
.
Note: When the service is no longer needed, the caller should be sure to detach the service.
Declared In
MBServiceManager.h
– attachToServiceClassNamed:
Attaches to the service with the given class name, incrementing its attach count by one.
- (id)attachToServiceClassNamed:(NSString *)serviceClassName
Parameters
serviceClassName |
The name of the service class to attach. |
|---|
Return Value
If successful, the MBService
instance that was attached. Will
return nil
on failure.
Discussion
Services with an attach count greater than zero will be kept running by the
MBServiceManager
.
Note: When the service is no longer needed, the caller should be sure to detach the service.
Declared In
MBServiceManager.h
Detaching from services
– detachFromService:
Detaches from the specified service, decrementing its attach count by one.
- (void)detachFromService:(MBService *)service
Parameters
service |
The service being attached. |
|---|
Discussion
Services are stopped by the MBServiceManager
when their attach count
decreases to zero.
Note: Code should only detach from a service if it previously attached to the same service.
Declared In
MBServiceManager.h
– detachFromServiceClass:
Detaches from the service with the given class name, decrementing its attach count by one.
- (void)detachFromServiceClass:(Class)serviceClass
Parameters
serviceClass |
The implementing class of the service class to detach. |
|---|
Discussion
Services are stopped by the MBServiceManager
when their attach count
decreases to zero.
Note: Code should only detach from a service if it previously attached to the same service. Detach requests are ignored if the service isn’t already running.
Declared In
MBServiceManager.h
– detachFromServiceClassNamed:
Detaches from the service with the given class name, decrementing its attach count by one.
- (void)detachFromServiceClassNamed:(NSString *)serviceClassName
Parameters
serviceClassName |
The name of the service class to attach. |
|---|
Discussion
Services are stopped by the MBServiceManager
when their attach count
decreases to zero.
Note: Code should only detach from a service if it previously attached to the same service. Detach requests are ignored if the service isn’t already running.
Declared In
MBServiceManager.h
Querying the status of services
– isServiceRunning:
Determines whether the specified service is running.
- (BOOL)isServiceRunning:(MBService *)service
Parameters
service |
The service whose status is sought. |
|---|
Return Value
YES
if the service is running; NO
if it is not.
Discussion
A service will remain running as long as its attach count is greater than zero.
Declared In
MBServiceManager.h
– attachCountForService:
Determines the current attach count of a service.
- (NSUInteger)attachCountForService:(MBService *)service
Parameters
service |
The service whose attach count is sought. |
|---|
Return Value
The service’s current attach count.
Declared In
MBServiceManager.h


Joystick routines
- ALLEGRO_JOYSTICK
- ALLEGRO_JOYSTICK_STATE
- ALLEGRO_JOYFLAGS
- al_install_joystick
- al_uninstall_joystick
- al_is_joystick_installed
- al_reconfigure_joysticks
- al_get_num_joysticks
- al_get_joystick
- al_release_joystick
- al_get_joystick_active
- al_get_joystick_name
- al_get_joystick_stick_name
- al_get_joystick_axis_name
- al_get_joystick_button_name
- al_get_joystick_stick_flags
- al_get_joystick_num_sticks
- al_get_joystick_num_axes
- al_get_joystick_num_buttons
- al_get_joystick_state
- al_get_joystick_event_source
These functions are declared in the main Allegro header file:
#include <allegro5/allegro.h>
ALLEGRO_JOYSTICK
typedef struct ALLEGRO_JOYSTICK ALLEGRO_JOYSTICK;
This is an abstract data type representing a physical joystick.
See also: al_get_joystick
ALLEGRO_JOYSTICK_STATE
typedef struct ALLEGRO_JOYSTICK_STATE ALLEGRO_JOYSTICK_STATE;
This is a structure that is used to hold a "snapshot" of a joystick's axes and buttons at a particular instant. All fields public and read-only.
struct {
float axis[num_axes]; // -1.0 to 1.0
} stick[num_sticks];
int button[num_buttons]; // 0 to 32767
See also: al_get_joystick_state
ALLEGRO_JOYFLAGS
enum ALLEGRO_JOYFLAGS
- ALLEGRO_JOYFLAG_DIGITAL - the stick provides digital input
- ALLEGRO_JOYFLAG_ANALOGUE - the stick provides analogue input
(this enum is a holdover from the old API and may be removed)
See also: al_get_joystick_stick_flags
al_install_joystick
bool al_install_joystick(void)
Install a joystick driver, returning true if successful. If a joystick driver was already installed, returns true immediately.
See also: al_uninstall_joystick
al_uninstall_joystick
void al_uninstall_joystick(void)
Uninstalls the active joystick driver. All outstanding ALLEGRO_JOYSTICK structures are invalidated. If no joystick driver was active, this function does nothing.
This function is automatically called when Allegro is shut down.
See also: al_install_joystick
al_is_joystick_installed
bool al_is_joystick_installed(void)
Returns true if al_install_joystick was called successfully.
al_reconfigure_joysticks
bool al_reconfigure_joysticks(void)
Allegro is able to cope with users connecting and disconnected joystick devices on-the-fly. On existing platforms, the joystick event source will generate an event of type ALLEGRO_EVENT_JOYSTICK_CONFIGURATION
when a device is plugged in or unplugged. In response, you should call al_reconfigure_joysticks.
Afterwards, the number returned by al_get_num_joysticks may be different, and the handles returned by al_get_joystick may be different or be ordered differently.
All ALLEGRO_JOYSTICK handles remain valid, but handles for disconnected devices become inactive: their states will no longer update, and al_get_joystick will not return the handle. Handles for devices which remain connected will continue to represent the same devices. Previously inactive handles may become active again, being reused to represent newly connected devices.
Returns true if the joystick configuration changed, otherwise returns false.
It is possible that on some systems, Allegro won't be able to generate ALLEGRO_EVENT_JOYSTICK_CONFIGURATION
events. If your game has an input configuration screen or similar, you may wish to call al_reconfigure_joysticks when entering that screen.
See also: al_get_joystick_event_source, ALLEGRO_EVENT
al_get_num_joysticks
int al_get_num_joysticks(void)
Return the number of joysticks currently on the system (or potentially on the system). This number can change after al_reconfigure_joysticks is called, in order to support hotplugging.
Returns 0 if there is no joystick driver installed.
See also: al_get_joystick, al_get_joystick_active
al_get_joystick
ALLEGRO_JOYSTICK * al_get_joystick(int num)
Get a handle for a joystick on the system. The number may be from 0 to al_get_num_joysticks-1. If successful a pointer to a joystick object is returned, which represents a physical device. Otherwise NULL is returned.
The handle and the index are only incidentally linked. After al_reconfigure_joysticks is called, al_get_joystick may return handles in a different order, and handles which represent disconnected devices will not be returned.
See also: al_get_num_joysticks, al_reconfigure_joysticks, al_get_joystick_active
al_release_joystick
void al_release_joystick(ALLEGRO_JOYSTICK *joy)
This function currently does nothing.
See also: al_get_joystick
al_get_joystick_active
bool al_get_joystick_active(ALLEGRO_JOYSTICK *joy)
Return if the joystick handle is "active", i.e. in the current configuration, the handle represents some physical device plugged into the system. al_get_joystick returns active handles. After reconfiguration, active handles may become inactive, and vice versa.
See also: al_reconfigure_joysticks
al_get_joystick_name
const char *al_get_joystick_name(ALLEGRO_JOYSTICK *joy)
Return the name of the given joystick.
See also: al_get_joystick_stick_name, al_get_joystick_axis_name, al_get_joystick_button_name
al_get_joystick_stick_name
const char *al_get_joystick_stick_name(ALLEGRO_JOYSTICK *joy, int stick)
Return the name of the given "stick". If the stick doesn't exist, NULL is returned.
See also: al_get_joystick_axis_name, al_get_joystick_num_sticks
al_get_joystick_axis_name
const char *al_get_joystick_axis_name(ALLEGRO_JOYSTICK *joy, int stick, int axis)
Return the name of the given axis. If the axis doesn't exist, NULL is returned. Indices begin from 0.
See also: al_get_joystick_stick_name, al_get_joystick_num_axes
al_get_joystick_button_name
const char *al_get_joystick_button_name(ALLEGRO_JOYSTICK *joy, int button)
Return the name of the given button. If the button doesn't exist, NULL is returned. Indices begin from 0.
See also: al_get_joystick_stick_name, al_get_joystick_axis_name, al_get_joystick_num_buttons
al_get_joystick_stick_flags
int al_get_joystick_stick_flags(ALLEGRO_JOYSTICK *joy, int stick)
Return the flags of the given "stick". If the stick doesn't exist, NULL is returned. Indices begin from 0.
See also: ALLEGRO_JOYFLAGS
al_get_joystick_num_sticks
int al_get_joystick_num_sticks(ALLEGRO_JOYSTICK *joy)
Return the number of "sticks" on the given joystick. A stick has one or more axes.
See also: al_get_joystick_num_axes, al_get_joystick_num_buttons
al_get_joystick_num_axes
int al_get_joystick_num_axes(ALLEGRO_JOYSTICK *joy, int stick)
Return the number of axes on the given "stick". If the stick doesn't exist, 0 is returned.
See also: al_get_joystick_num_sticks
al_get_joystick_num_buttons
int al_get_joystick_num_buttons(ALLEGRO_JOYSTICK *joy)
Return the number of buttons on the joystick.
See also: al_get_joystick_num_sticks
al_get_joystick_state
void al_get_joystick_state(ALLEGRO_JOYSTICK *joy, ALLEGRO_JOYSTICK_STATE *ret_state)
Get the current joystick state.
See also: ALLEGRO_JOYSTICK_STATE, al_get_joystick_num_buttons, al_get_joystick_num_axes
al_get_joystick_event_source
ALLEGRO_EVENT_SOURCE *al_get_joystick_event_source(void)
Returns the global joystick event source. All joystick events are generated by this event source.


Mitigating corporate information exposure on the web
Introduction
According to Tayouri (2015), humans are social beings with a strong need to communicate and have relationships, it’s all part of the human nature. People always lived in groups and sometimes communicated around a fire, city markets, coffee’ shops and pubs. In the modern era communication has been drastically changed, most of it is digitized: we can use Facebook to keep in touch with old friends, far away loved ones and family; we have Twitter for microblogging, where we can express our opinions about politicians and famous people without being scared of repercussions; whatsapp is our most used instant messaging application for communicating to our loved ones, work and study colleagues; Instagram and Youtube are our favourite platforms for following material related to our hobbies and interests.
Using social media we have access to a lot of people and new ways for interaction, people share their experiences, support friends and get market informations. One problem of using social media is the common over-sharing of personal information which on a long run might cause negative consequences, such as sharing one’s location on a social platform or allowing messages between social networks without considering that these platforms are also used by criminals with malicious intentions. With all the benefits social media brought to us a huge number of risks also came along. A major concern within information security is the threat of social engineering attacks (Metalidou E. et al., 2014). The major risks in using these networks are: insufficient authentication controls, information leakage, injection flaws, information integrity, and more. The most frequently used cyber-attack methods are: Spear Phishing and Web Application Attacks. Spear Phishing is an attack attempt a criminal launches trying to persuade someone in opening an infected file or to click on a link, if the user of the program or email falls in this trap he might get attacked and share personal information without any awareness. There are several methods for mitigating social media security risks.
Many companies nowadays use a formal policy to guide their employees on the use of social media. These policies are guidelines for the users so that they know what is acceptable behaviour and what is unacceptable on social media, they might also guide the user through choosing an appropriate password and what information they can and cannot share. In many cases the only knowledge that a policy exists might not be enough to train an employee in a real life situation, for these situations there’s need for education, training and technology.
Humans are the weak link
The first step towards strengthening the weak link that is the human factor is education. Nowadays the internet is accessible to a large number of people, many children start using applications before they even go to school through gaming and online learning. Internet can be a very risky resource for children, reasons can be cyber-bullying, pedophilia and accessing adult websites. A report by IBM released on 2014 attributes some 95% of IT security breaches to human error. For these reasons education on how to use the internet and protect personal information should be teached in the earliest years of school though. During high school this education should be taken to the next level, teaching the youth more advanced concepts. The training can improve the online risks awareness in order to not commit actions that might lead to data and malware breaches. The training provided by companies should provide qualitative explanations about the acceptable use of social media and security policy, give examples of cyber-attacks and reporting incidents (Tayouri D., 2015).M
A new approach in training employees on the newest and advanced security procedures is the use of video games, because many other methods don’t require the users to think about the applied procedures. According to Ben-Asher et al. (2015), during a simplified Intrusion Detection System (IDS) simulation, responses from participants that have knowledge in cyber security indicated that they were able to distinguish between different types of cyber-attacks, whereas novice participants were not sensitive to the attack types.
The interactivity of a videogame can help the users to learn the concepts faster with a constant rate of improvement, the effectiveness of these training sessions should be assessed. A good assessment method could be the employment of drills, social engineering simulations on the employees to see if they detect the cyber-attack and if they report it to procedure (Tayouri D., 2015).
Technology
Another important aspect for mitigating the human error is technology, giving our best in this area means helping people to protect themselves better against cyber-attacks. In a social engineering scam it’s important to gather data about the the victim, therefore limiting unknown people from having information about them through privacy settings is crucial. Cyber-security is an accepted part of business life and organisations invest heavily in people, resources and budget (Green J., 2015).
Companies should ensure that employees always use devices with updated firewalls, antiviruses and anti-malware. It’s very important that employees know how to use protection software and scan regularly their devices, including flash-drives and downloaded material. A huge risk in using social media is fake identities, it’s hard to know who to trust when it comes from accepting friendship requests. Filtering friendship requests with the use of technology that checks the reliability of one’s profile and does cross-checks against other databases and users references can help by not letting user fall into malicious traps.
Threats can also be detected by using social media itself, if an employee seems to have a bad working relationship with it’s boss and company, if it appears to have a narcissistic behaviour or simply being a very frustrated person, this might lead the person to leak information that an be used to harm the company.
Conclusion
The way we communicate has been changed in the modern digital era. Social media became what we use to share our feelings and thoughts to the rest of the world, but it has a lot of security threats. To strengthen the human behaviour towards a more secure use of the internet and social media education must start in the earliest years of school and then continue during corporate employment. Sometimes uncommon methods towards education, such as interactive video-games can be more efficient than traditional education. Simulating cyber-attacks on the employees is an efficient way of establishing if the training was successful. Education by itself is not enough to ensure improvement, technology is needed. Enforcing privacy settings, using monitoring tools and using social media is an efficient way of protecting data. The combination of technology, training and education might be the best way to mitigate corporate information and reduce data leakage.
References
- Ben-Asher, N., & Gonzalez, C. (2015). Effects of cyber security knowledge on attack detection. Computers In Human Behavior, 4851-61. doi:10.1016/j.chb.2015.01.039
- Ben-Asher, N., & Gonzalez, C. (2015). Training for the Unknown: The Role of Feedback and Similarity in Detecting Zero-day Attacks. Procedia Manufacturing, 3(6th InternationalConference on Applied Human Factors and Ergonomics (AHFE 2015) and the Affiliated Conferences, AHFE 2015), 1088-1095. doi:10.1016/j.promfg.2015.07.180
- Ferdinand, J. (2015). Building organisational cyber resilience: A strategic knowledge-based view of cyber security management. Journal Of Business Continuity & Emergency Planning, 9(2), 185-195.
- Green, J. (2015). Feature: Staying ahead of cyber-attacks. Network Security, 201513-16.doi:10.1016/S1353-4858(15)30007-6
- Metalidou, E., Marinagi, C., Trivellas, P., Eberhagen, N., Skourlas, C., & Giannakopoulos, G. (2014). The Human Factor of Information Security: Unintentional Damage Perspective. Procedia - Social And Behavioral Sciences, 147(3rd International Conference on Integrated Information (IC-ININFO), 424-428. doi:10.1016/j. sbspro.2014.07.133
- Tayouri, D. (2015). The Human Factor in the Social Media Security – Combining Education and Technology to Reduce Social Engineering Risks and Damages. Procedia Manufacturing, 31096-1100. doi:10.1016/j.promfg.2015.07.181


Trouble-shooting
This section provides help and explanations.
Frequently Asked Questions
- Why does MiStaMover not run on Python 2.4 or older versions?
- We had to make a cut-off point and we decided that Python 2.5 and above was reasonable. MiStaMover may not run on older versions of Python.
- Why is the “mirror” transfer mode only available for rsync transfer protocols?
- The rsync tool has been built to be able to exactly duplicate the contents of a directory to a remote host. This is a relatively complex function that would require significant coding to achieve with all transfer protocols. Within MiStaMover it has only therefore been possible to implement the “mirror” transfer mode as a thin wrapper around the existing functionality of rsync.
- Why does MiStaMover not unzip directories once delivered to the target host?
A number of transfer protocols are available to push data to a remote host. Since each protocol has its own limitations we could not implement a generic solution for pushing a directory structure that would work for all. As a result if the rsync_ssh or rsync_native protocols are used then an entire directory will be copied to the target host as is.
However, for other protocols there is no direct support for remotely copying whole directories. We therefore took the decision to zip the directory on the source host so that we could verify the send process robustly. Unzipping on the target host would require a signficant amount of extra engineering which was considered out of scope for the development of this tool.
- How can I specify a different SSH key for use with the “rsync_ssh” transfer method?
- The “rsync_ssh” (rsync over SSH) transfer module expects the private and public key pair to be in the users home directory in the $HOME/.ssh/ directory. The default id_rsa and id_rsa.pub files are used. In order to specify a different key for use with the “rsync_ssh” transfer method you must update the rsync_ssh cmd variable in the config file.
For example, modify the cmd parameter from /usr/bin/rsync to /usr/bin/rsync -e 'ssh -i /home/users/me/.ssh/id_rsa.bak'.


A web technology consultancy.
You can contact max at (@) mediumwaves dot (.) co dot uk for more information.


Files CCore/inc/OwnPtr.h CCore/src/OwnPtr.cpp
OwnPtr is a smart pointer with the exclusive ownership semantic.
template <class T> struct OwnAlgo { static void Destroy(T *ptr) noexcept requires( NothrowDtorType<T> ) { delete ptr; } }; template <class T,class Algo=OwnAlgo<T> > class OwnPtr : NoCopy { T *ptr; public: // constructors OwnPtr() noexcept : ptr(0) {} explicit OwnPtr(T *ptr_) : ptr(ptr_) {} ~OwnPtr() { if( ptr ) Algo::Destroy(ptr); } // std move OwnPtr(OwnPtr<T,Algo> &&obj) noexcept; OwnPtr<T,Algo> & operator = (OwnPtr<T,Algo> &&obj) noexcept; // object ptr T * operator + () const { return ptr; } bool operator ! () const { return !ptr; } T * getPtr() const { return ptr; } T & operator * () const { return *ptr; } T * operator -> () const { return ptr; } // reset void set(T *new_ptr) { if( T *old_ptr=Replace(ptr,new_ptr) ) Algo::Destroy(old_ptr); } T * detach(T *new_ptr=0) { return Replace(ptr,new_ptr); } // swap/move objects void objSwap(OwnPtr<T,Algo> &obj) { Swap(ptr,obj.ptr); } explicit OwnPtr(ToMoveCtor<OwnPtr<T,Algo> > obj); OwnPtr<T,Algo> * objMove(Place<void> place); };
OwnPtr has only one data member — pointer to the object of the type T. This pointer may be null. OwnPtr is not copyable (but has the move constructor and the move assign operator) and its destructor destroys the pointed object using the provided algorithm Algo::Destroy(). The pointer comes from the constructor argument. Using OwnPtr make sure the argument is "destroyable". By default, Algo::Destroy(ptr) is just delete ptr;, so the object must be created by the new expression.
OwnPtr is std movable. The original object is nullified during the move.
OwnPtr implements Object Pointer Interface. It also swappable and movable.
Two additional "unsafe" methods set() and detach() can be used to manipulate the internal pointer.
set() setup a new pointer and destroy the previous one. It is the same as the destructor plus the following constructor call.
detach() setup a new pointer and return the previous one.
Using the template parameter Algo you may customize the destruction process.
The typical usage of the OwnPtr is to create an object with the scope life-time duration.
class C { .... }; .... { OwnPtr<C> ptr( new C() ); .... ptr->method(); .... }
The object will be destroyed when the scope is exited by any way. This method is useful instead of creation a local variable of the type C, if the sizeof (C) is too large. You can also return an OwnPtr from a function (this is impossible with a local variable):
void func(OwnPtr<C> &ret) { OwnPtr<C> ptr( new C() ); Swap(ptr,ret); } .... OwnPtr<C> result; func(result); ....


{% extends 'base.html' %} {% load static %} {% load i18n %} {% block content %}
{% blocktrans %}You will shortly receive an email with instruction on setting your password and logging on. If you haven't already seen the Facilitator Guide, be sure to have a look now.{% endblocktrans %}


Logout
User Management
User List:
Username:
Permissions:
Create
Program Management
Program List:
Path:
Create


Andrea Nodari
@andreanodari
#RoRcourseTN
array = [1, 2, 3]
array.each do |element|
puts element + 1
end
10.times { puts "hello guys!" }
class User
CONSTANT = 42
def initialize(name) #=> constructur
@name = name #=> setting instance variable
end
def walk #=> instance method
puts "I am walking..."
end
def self.say(text) #=> class method
puts text
end
end
andrea = User.new("Andrea") #=> create an instance
In ruby everything is a method call.
Switch to console..
It abstracts and manages all parts of a web application:
Principles
We want to build a web application to store our favourites places. We'd like to classify them so we want to add comments and assigns marks to each place.
Code!Switch to console..
Switch to console..


Checks that classes annotated by
@Singleton
do not have constructors unless it is declared non strict.


public class Colour extends java.lang.Object implements FillStyle, java.io.Serializable
| Constructor and Description |
|---|
Colour(int red,
int green,
int blue)
Parametrized Ctor.
|
Colour(int red,
int green,
int blue,
float alpha)
Parametrized Ctor with separate components.
|
Colour(java.lang.String webColour)
Parametrized Ctor from a single webcolour string.
|
| Modifier and Type | Method and Description |
|---|---|
Colour |
alpha(float alpha)
Retrieve a colour with an alpha value.
|
float |
getAlpha()
Retrieve the alpha component.
|
int |
getBlue()
Retrieve the blue component.
|
int |
getGreen()
Retrieve the green component.
|
int |
getRed()
Retrieve the red component.
|
void |
setAlpha(float alpha)
Set the alpha component.
|
void |
setBlue(int blue)
Set the blue component.
|
void |
setGreen(int green)
Set the green component.
|
void |
setRed(int red)
Set the red component.
|
java.lang.String |
toRGBString()
Create a web colour code (#RRGGBB) from the three separate RGB components.
|
java.lang.String |
toString()
Create RGBA quadruple from the four separate RGBA components.
|
public static final Colour aliceblue
public static final Colour antiquewhite
public static final Colour aqua
public static final Colour aquamarine
public static final Colour azure
public static final Colour beige
public static final Colour bisque
public static final Colour black
public static final Colour blanchedalmond
public static final Colour blue
public static final Colour blueviolet
public static final Colour brown
public static final Colour burlywood
public static final Colour cadetblue
public static final Colour chartreuse
public static final Colour chocolate
public static final Colour coral
public static final Colour cornflowerblue
public static final Colour cornsilk
public static final Colour crimson
public static final Colour darkblue
public static final Colour darkcyan
public static final Colour darkgoldenrod
public static final Colour darkgray
public static final Colour darkgreen
public static final Colour darkkhaki
public static final Colour darkmagenta
public static final Colour darkolivegreen
public static final Colour darkorange
public static final Colour darkorchid
public static final Colour darkred
public static final Colour darksalmon
public static final Colour darkseagreen
public static final Colour darkslateblue
public static final Colour darkslategray
public static final Colour darkturquoise
public static final Colour darkviolet
public static final Colour deeppink
public static final Colour deepskyblue
public static final Colour dimgray
public static final Colour dodgerblue
public static final Colour firebrick
public static final Colour floralwhite
public static final Colour forestgreen
public static final Colour fuchsia
public static final Colour gainsboro
public static final Colour ghostwhite
public static final Colour gold
public static final Colour goldenrod
public static final Colour gray
public static final Colour green
public static final Colour greenyellow
public static final Colour honeydew
public static final Colour hotpink
public static final Colour indianred
public static final Colour indigo
public static final Colour ivory
public static final Colour khaki
public static final Colour lavender
public static final Colour lavenderblush
public static final Colour lawngreen
public static final Colour lemonchiffon
public static final Colour lightblue
public static final Colour lightcoral
public static final Colour lightcyan
public static final Colour lightgoldenrodyellow
public static final Colour lightgreen
public static final Colour lightgrey
public static final Colour lightpink
public static final Colour lightsalmon
public static final Colour lightseagreen
public static final Colour lightskyblue
public static final Colour lightslategray
public static final Colour lightsteelblue
public static final Colour lightyellow
public static final Colour lime
public static final Colour limegreen
public static final Colour linen
public static final Colour maroon
public static final Colour mediumaquamarine
public static final Colour mediumblue
public static final Colour mediumorchid
public static final Colour mediumpurple
public static final Colour mediumseagreen
public static final Colour mediumslateblue
public static final Colour mediumspringgreen
public static final Colour mediumturquoise
public static final Colour mediumvioletred
public static final Colour midnightblue
public static final Colour mintcream
public static final Colour mistyrose
public static final Colour moccasin
public static final Colour navajowhite
public static final Colour navy
public static final Colour oldlace
public static final Colour olive
public static final Colour olivedrab
public static final Colour orange
public static final Colour orangered
public static final Colour orchid
public static final Colour palegoldenrod
public static final Colour palegreen
public static final Colour paleturquoise
public static final Colour palevioletred
public static final Colour papayawhip
public static final Colour peachpuff
public static final Colour peru
public static final Colour pink
public static final Colour plum
public static final Colour powderblue
public static final Colour purple
public static final Colour red
public static final Colour rosybrown
public static final Colour royalblue
public static final Colour saddlebrown
public static final Colour salmon
public static final Colour sandybrown
public static final Colour seagreen
public static final Colour seashell
public static final Colour sienna
public static final Colour silver
public static final Colour skyblue
public static final Colour slateblue
public static final Colour slategray
public static final Colour snow
public static final Colour springgreen
public static final Colour steelblue
public static final Colour tan
public static final Colour teal
public static final Colour thistle
public static final Colour tomato
public static final Colour turquoise
public static final Colour violet
public static final Colour wheat
public static final Colour white
public static final Colour whitesmoke
public static final Colour yellow
public static final Colour yellowgreen
public static final Colour fubGreen
public static final Colour fubBlue
public static final Colour fubLightBlue
public static final Colour quicksilver
public Colour(int red, int green, int blue)
red
- Red component (0..255)green
- Green component (0..255)blue
- Blue component (0..255)public Colour(int red, int green, int blue, float alpha)
red
- Red component (0..255)green
- Green component (0..255)blue
- Blue component (0..255)alpha
- Alpha component (0.0 .. 1.0)public Colour(java.lang.String webColour)
webColour
- A colour string (e.g., '#FF0000') or an rgba string, for example 'rgba(255, 0, 0, 0.5)'public int getRed()
public void setRed(int red)
red
- The new valuepublic int getGreen()
public void setGreen(int green)
green
- The new valuepublic int getBlue()
public void setBlue(int blue)
blue
- The new valuepublic float getAlpha()
public void setAlpha(float alpha)
alpha
- The new valuepublic Colour alpha(float alpha)
alpha
- Defines the transparency (0.0 is completely transparent and 1.0 is opaque)public java.lang.String toRGBString()
public java.lang.String toString()
toString
in class java.lang.Object


Tara Kamshad
Background Info
I have always loved playing soccer... and being organized!
Here are some pictures of ways I would organize my soccer practices:
Notebook -
- It is really hard and time consuming to draw on paper before every practice
- It is hard to draw and specify what each symbol is
- I would have to carry my notebook everywhere
App -
- I was using the free trial, and after seven days I had to start paying
So I decided to create a website where I could plan my sessions with detail, yet efficiently.
My idea was based off of this codesketch:
1) Add a soccer field background.
2) Add an event listener to the field.
3) Add the equipment I want to use.
4) Add event listeners to the equipment so that when I click on them, the background image of a div changes to match the equipment.


| rpc_v11_req_decode/3 | |
| rpc_v11_req_decode/4 | |
| rpc_v11_req_decode_print/3 | |
| rpc_v11_req_encode/3 | |
| rpc_v11_req_encode/4 | Take an Erlang RPC term (atom or tuple, where 1st element of the tuple is the RPC function to call) and extract the AuthInfo (if SubstAuthInfoP is true) and encode the call atom/tuple as an intermediate representation of a JSON object. |
| rpc_v11_req_encode_print/3 | |
| rpc_v11_res_decode/2 | |
| rpc_v11_res_decode_print/2 | |
| rpc_v11_res_encode/4 | |
| rpc_v11_res_encode_print/4 |
rpc_v11_req_decode(AuthInfo, X, UBFMod) -> any()
rpc_v11_req_decode(AuthInfo, X, UBFMod, SubstAuthInfoP) -> any()
rpc_v11_req_decode_print(AuthInfo, X, UBFMod) -> any()
rpc_v11_req_encode(Request, Id, UBFMod) -> any()
rpc_v11_req_encode(Method::atom() | tuple(), Id::binary(), UBFMod::atom(), SubstAuthInfoP::boolean()) -> {undefined | term(), encoded_json_term()}
Take an Erlang RPC term (atom or tuple, where 1st element of the tuple is the RPC function to call) and extract the AuthInfo (if SubstAuthInfoP is true) and encode the call atom/tuple as an intermediate representation of a JSON object.
The intermediate _JSON object needs to be string-ified before it's really a JSON thing, because JSON things are strings.
See EUnit test module ubf_jsonrpc_examples_test.erl for example usage.rpc_v11_req_encode_print(X, Id, UBFMod) -> any()
rpc_v11_res_decode(X, UBFMod) -> any()
rpc_v11_res_decode_print(X, UBFMod) -> any()
rpc_v11_res_encode(X, Y, Id, UBFMod) -> any()
rpc_v11_res_encode_print(X, Y, Id, UBFMod) -> any()
Generated EDoc, $Id$


EYES WIDE SHUT A film review by David N. Butterworth Copyright 1999 David N. Butterworth
*1/2 (out of ****)
Lauded as a genius by many, Stanley Kubrick commands a superlative filmography that includes such critically-acclaimed films as "2001: A Space Odyssey," "A Clockwork Orange," "Lolita," and "Dr. Strangelove, or: How I Learned to Stop Worrying and Love the Bomb." Now, sadly, he's added "Eyes Wide Shut" to that impeccable body of work and his final film is the first and only blot on his near-flawless copybook.
Kubrick, alas, should have quit while he was ahead.
This much-publicized psycho-sexual tease-a-thon, with its star billing of real-life marrieds Tom Cruise and Nicole Kidman, is nothing more than one long (two-and-a-half hours long) boring exercise that features Kubrick operating with talent wide shut.
Kubrick, faithless to Arthur Schnitzler's 1926 novella "Dream Story," has confused eroticism with nudity. He has confused intellectualism with talking slowly. He has confused profundity with pretentiousness. In addition, the director has made some strange casting choices, leaving Sydney Pollack in and leaving accomplished performers Harvey Keitel and Jennifer Jason Leigh out. Pollack, the director of such box-office hits as "Tootsie" and "Out of Africa," is normally solid in his occasional acting stints but here he's miserably out of his depth ... and there isn't much depth to begin with! Unhappily, there's not likely to be a director's cut of this film to determine whether the decision to exorcise Keitel and Leigh was the right one.
In fact, with the exception of the stark black-and-white credits, snatches of baroque music on the soundtrack, and many, many grainy tracking shots down lavishly-decorated corridors, there's none of Kubrick's trademark brilliance in this film.
It doesn't help that the story, as delivered, is ridiculous.
Cruise and Kidman, who bring little more than marital torpor to the project, play well-to-do New Yorkers Bill and Alice Harford. He's a doctor and she's an unemployed art gallery director and they share a Central Park West address. At an opulent party hosted by their friend Victor Ziegler (Pollack), Alice gets a little tipsy and starts dancing with a Jeremy Irons-like Hungarian, who's singularly determined to get her in the sack. Bill, too, is seen arm-in-arm with a couple of models before he's pulled away to deal with an overdoser.
Back home, Bill and Alice smoke a little pot before Alice's aggressive jealousy kicks in. As retribution, she confesses to her husband that she once had deep feelings for a naval officer she eyeballed at a hotel where she and Bill once stayed. This hurtful admission sends Bill into a tailspin; he pounds the streets of the Village in his heavy black overcoat struggling with black-and-white images of Alice in the grip of a horny midshipman. It's all way too much for him.
 He almost has feelings for a underage girl he sees in a costume store. Then he almost does the hooker's roommate. And he's almost involved in an overblown rococo orgy when an old college chum of his tips him off to a mysterious, password-protected party where everyone wears masks and "the women are incredible" (i.e., naked). This "erotic" set piece, a cult-ish bacchanal complete with chanting, incense, and lots of strategically-placed partygoers covering up the dirty, might impress the likes of Hugh Hefner, but it's a lot less shocking than it's intended to be.
What's the big deal? Bill doesn't exactly *do* anything (other than throw his money and credentials around), and Alice only ever lusted in her heart. Whoop-dee-doo. Still, they make up at the same agonizingly slow pace--was Kubrick, notorious for multiple takes, paying them at an hourly rate?
Even geniuses have their bad days. "Eyes Wide Shut" just happens to be Kubrick's bad day, an unerotic, disappointing, and altogether pointless end to an otherwise memorable career.
-- David N. Butterworth<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Securely share this image with others. Print the code and keep it safe.
WebSocket Endpoint:
Connect To Endpoint
Generate Secure Room
Scan To Enter Room
Room Id:
Key:
Join Room
Message:
Send


You've spent {{task.total | duration}} on this task.
0">
The task is a part of the following projects: {{project.name}}
list Statistics: Tabular View
Intervals
There are no intervals yetlabel
{{inter.startDate | date: 'dd.MM.yyyy H:ss'}} bis {{inter.stopDate | date: 'dd.MM.yyyy H:ss'}}
show_chart Statistics: Chart View


This all started as a small project of mine where I found that one of the basketball leagues I participated in was tracking scores using paper and pencil. While observing several other tournaments and leagues, paper and pencil seemed quite consistent, the scorekeeper would track the basics like points, but not much more. The process was very cumbersome and this data was difficult to share, so it was then that I decided to create an iPhone app that could easily track statistics and provide this information and analysis in real-time for others to see. read more...