| Top |
| GtkWindow * | active-window | Read |
| GMenuModel * | app-menu | Read / Write |
| GMenuModel * | menubar | Read / Write |
| gboolean | register-session | Read / Write |
GtkApplication is a class that handles many important aspects of a GTK+ application in a convenient fashion, without enforcing a one-size-fits-all application model.
Currently, GtkApplication handles GTK+ initialization, application uniqueness, session management, provides some basic scriptability and desktop shell integration by exporting actions and menus and manages a list of toplevel windows whose life-cycle is automatically tied to the life-cycle of your application.
While GtkApplication works fine with plain GtkWindows, it is recommended to use it together with GtkApplicationWindow.
When GDK threads are enabled, GtkApplication will acquire the GDK
lock when invoking actions that arrive from other processes. The GDK
lock is not touched for local action invocations. In order to have
actions invoked in a predictable context it is therefore recommended
that the GDK lock be held while invoking actions locally with
g_action_group_activate_action()
. The same applies to actions
associated with GtkApplicationWindow and to the “activate” and
“open” GApplication methods.
GtkApplication will automatically load menus from the GtkBuilder
resource located at "gtk/menus.ui", relative to the application's
resource base path (see g_application_set_resource_base_path()
). The
menu with the ID "app-menu" is taken as the application's app menu
and the menu with the ID "menubar" is taken as the application's
menubar. Additional menus (most interesting submenus) can be named
and accessed via gtk_application_get_menu_by_id()
which allows for
dynamic population of a part of the menu structure.
If the resources "gtk/menus-appmenu.ui" or "gtk/menus-traditional.ui" are
present then these files will be used in preference, depending on the value
of gtk_application_prefers_app_menu()
. If the resource "gtk/menus-common.ui"
is present it will be loaded as well. This is useful for storing items that
are referenced from both "gtk/menus-appmenu.ui" and
"gtk/menus-traditional.ui".
It is also possible to provide the menus manually using
gtk_application_set_app_menu()
and gtk_application_set_menubar()
.
GtkApplication will also automatically setup an icon search path for
the default icon theme by appending "icons" to the resource base
path. This allows your application to easily store its icons as
resources. See gtk_icon_theme_add_resource_path()
for more
information.
If there is a resource located at "gtk/help-overlay.ui" which defines a GtkShortcutsWindow with ID "help_overlay" then GtkApplication associates an instance of this shortcuts window with each GtkApplicationWindow and sets up keyboard accelerators (Control-F1 and Control-?) to open it. To create a menu item that displays the shortcuts window, associate the item with the action win.show-help-overlay.
GtkApplication optionally registers with a session manager of the users session (if you set the “register-session” property) and offers various functionality related to the session life-cycle.
An application can block various ways to end the session with
the gtk_application_inhibit()
function. Typical use cases for
this kind of inhibiting are long-running, uninterruptible operations,
such as burning a CD or performing a disk backup. The session
manager may not honor the inhibitor, but it can be expected to
inform the user about the negative consequences of ending the
session while inhibitors are present.
GtkApplication * gtk_application_new (const gchar *application_id
,GApplicationFlags flags
);
Creates a new GtkApplication instance.
When using GtkApplication, it is not necessary to call gtk_init()
manually. It is called as soon as the application gets registered as
the primary instance.
Concretely, gtk_init()
is called in the default handler for the
“startup” signal. Therefore, GtkApplication subclasses should
chain up in their “startup” handler before using any GTK+ API.
Note that commandline arguments are not passed to gtk_init()
.
All GTK+ functionality that is available via commandline arguments
can also be achieved by setting suitable environment variables
such as G_DEBUG
, so this should not be a big
problem. If you absolutely must support GTK+ commandline arguments,
you can explicitly call gtk_init()
before creating the application
instance.
If non-NULL
, the application ID must be valid. See
g_application_id_is_valid()
.
If no application ID is given then some features (most notably application uniqueness) will be disabled. A null application ID is only allowed with GTK+ 3.6 or later.
Since: 3.0
void gtk_application_add_window (GtkApplication *application
,GtkWindow *window
);
Adds a window to application
.
This call can only happen after the application
has started;
typically, you should add new application windows in response
to the emission of the “activate” signal.
This call is equivalent to setting the “application”
property of window
to application
.
Normally, the connection between the application and the window
will remain until the window is destroyed, but you can explicitly
remove it with gtk_application_remove_window()
.
GTK+ will keep the application
running as long as it has
any windows.
Since: 3.0
void gtk_application_remove_window (GtkApplication *application
,GtkWindow *window
);
Remove a window from application
.
If window
belongs to application
then this call is equivalent to
setting the “application” property of window
to
NULL
.
The application may stop running as a result of a call to this function.
Since: 3.0
GList *
gtk_application_get_windows (GtkApplication *application
);
Gets a list of the GtkWindows associated with application
.
The list is sorted by most recently focused window, such that the first element is the currently focused window. (Useful for choosing a parent for a transient window.)
The list that is returned should not be modified in any way. It will only remain valid until the next focus change or window creation or deletion.
Since: 3.0
GtkWindow * gtk_application_get_window_by_id (GtkApplication *application
,guint id
);
Returns the GtkApplicationWindow with the given ID.
The ID of a GtkApplicationWindow can be retrieved with
gtk_application_window_get_id()
.
the window with ID id
, or
NULL
if there is no window with this ID.
[nullable][transfer none]
Since: 3.6
GtkWindow *
gtk_application_get_active_window (GtkApplication *application
);
Gets the “active” window for the application.
The active window is the one that was most recently focused (within the application). This window may not have the focus at the moment if another application has it — this is just the most recently-focused window within this application.
Since: 3.6
guint gtk_application_inhibit (GtkApplication *application
,GtkWindow *window
,GtkApplicationInhibitFlags flags
,const gchar *reason
);
Inform the session manager that certain types of actions should be inhibited. This is not guaranteed to work on all platforms and for all types of actions.
Applications should invoke this method when they begin an operation
that should not be interrupted, such as creating a CD or DVD. The
types of actions that may be blocked are specified by the flags
parameter. When the application completes the operation it should
call gtk_application_uninhibit()
to remove the inhibitor. Note that
an application can have multiple inhibitors, and all of them must
be individually removed. Inhibitors are also cleared when the
application exits.
Applications should not expect that they will always be able to block the action. In most cases, users will be given the option to force the action to take place.
Reasons should be short and to the point.
If window
is given, the session manager may point the user to
this window to find out more about why the action is inhibited.
application |
the GtkApplication |
|
window |
[allow-none] | |
flags |
what types of actions should be inhibited |
|
reason |
a short, human-readable string that explains why these operations are inhibited. |
[allow-none] |
A non-zero cookie that is used to uniquely identify this
request. It should be used as an argument to gtk_application_uninhibit()
in order to remove the request. If the platform does not support
inhibiting or the request failed for some reason, 0 is returned.
Since: 3.4
void gtk_application_uninhibit (GtkApplication *application
,guint cookie
);
Removes an inhibitor that has been established with gtk_application_inhibit()
.
Inhibitors are also cleared when the application exits.
application |
the GtkApplication |
|
cookie |
a cookie that was returned by |
Since: 3.4
gboolean gtk_application_is_inhibited (GtkApplication *application
,GtkApplicationInhibitFlags flags
);
Determines if any of the actions specified in flags
are
currently inhibited (possibly by another application).
Since: 3.4
gboolean
gtk_application_prefers_app_menu (GtkApplication *application
);
Determines if the desktop environment in which the application is running would prefer an application menu be shown.
If this function returns TRUE
then the application should call
gtk_application_set_app_menu()
with the contents of an application
menu, which will be shown by the desktop environment. If it returns
FALSE
then you should consider using an alternate approach, such as
a menubar.
The value returned by this function is purely advisory and you are
free to ignore it. If you call gtk_application_set_app_menu()
even
if the desktop environment doesn't support app menus, then a fallback
will be provided.
Applications are similarly free not to set an app menu even if the desktop environment wants to show one. In that case, a fallback will also be created by the desktop environment (GNOME, for example, uses a menu with only a "Quit" item in it).
The value returned by this function never changes. Once it returns a particular value, it is guaranteed to always return the same value.
You may only call this function after the application has been registered and after the base startup handler has run. You're most likely to want to use this from your own startup handler. It may also make sense to consult this function while constructing UI (in activate, open or an action activation handler) in order to determine if you should show a gear menu or not.
This function will return FALSE
on Mac OS and a default app menu
will be created automatically with the "usual" contents of that menu
typical to most Mac OS applications. If you call
gtk_application_set_app_menu()
anyway, then this menu will be
replaced with your own.
Since: 3.14
GMenuModel *
gtk_application_get_app_menu (GtkApplication *application
);
Returns the menu model that has been set with
gtk_application_set_app_menu()
.
the application menu of application
or NULL
if no application menu has been set.
[transfer none][nullable]
Since: 3.4
void gtk_application_set_app_menu (GtkApplication *application
,GMenuModel *app_menu
);
Sets or unsets the application menu for application
.
This can only be done in the primary instance of the application, after it has been registered. “startup” is a good place to call this.
The application menu is a single menu containing items that typically impact the application as a whole, rather than acting on a specific window or document. For example, you would expect to see “Preferences” or “Quit” in an application menu, but not “Save” or “Print”.
If supported, the application menu will be rendered by the desktop environment.
Use the base GActionMap interface to add actions, to respond to the user selecting these menu items.
Since: 3.4
GMenuModel *
gtk_application_get_menubar (GtkApplication *application
);
Returns the menu model that has been set with
gtk_application_set_menubar()
.
Since: 3.4
void gtk_application_set_menubar (GtkApplication *application
,GMenuModel *menubar
);
Sets or unsets the menubar for windows of application
.
This is a menubar in the traditional sense.
This can only be done in the primary instance of the application, after it has been registered. “startup” is a good place to call this.
Depending on the desktop environment, this may appear at the top of each window, or at the top of the screen. In some environments, if both the application menu and the menubar are set, the application menu will be presented as if it were the first item of the menubar. Other environments treat the two as completely separate — for example, the application menu may be rendered by the desktop shell while the menubar (if set) remains in each individual window.
Use the base GActionMap interface to add actions, to respond to the user selecting these menu items.
Since: 3.4
GMenu * gtk_application_get_menu_by_id (GtkApplication *application
,const gchar *id
);
Gets a menu from automatically loaded resources. See Automatic resources for more information.
Since: 3.14
void gtk_application_add_accelerator (GtkApplication *application
,const gchar *accelerator
,const gchar *action_name
,GVariant *parameter
);
gtk_application_add_accelerator
has been deprecated since version 3.14 and should not be used in newly-written code.
Use gtk_application_set_accels_for_action()
instead
Installs an accelerator that will cause the named action
to be activated when the key combination specificed by accelerator
is pressed.
accelerator
must be a string that can be parsed by gtk_accelerator_parse()
,
e.g. "<Primary>q" or “<Control><Alt>p”.
action_name
must be the name of an action as it would be used
in the app menu, i.e. actions that have been added to the application
are referred to with an “app.” prefix, and window-specific actions
with a “win.” prefix.
GtkApplication also extracts accelerators out of “accel” attributes
in the GMenuModels passed to gtk_application_set_app_menu()
and
gtk_application_set_menubar()
, which is usually more convenient
than calling this function for each accelerator.
application |
||
accelerator |
accelerator string |
|
action_name |
the name of the action to activate |
|
parameter |
parameter to pass when activating the action,
or |
[allow-none] |
Since: 3.4
void gtk_application_remove_accelerator (GtkApplication *application
,const gchar *action_name
,GVariant *parameter
);
gtk_application_remove_accelerator
has been deprecated since version 3.14 and should not be used in newly-written code.
Use gtk_application_set_accels_for_action()
instead
Removes an accelerator that has been previously added
with gtk_application_add_accelerator()
.
application |
||
action_name |
the name of the action to activate |
|
parameter |
parameter to pass when activating the action,
or |
[allow-none] |
Since: 3.4
gchar **
gtk_application_list_action_descriptions
(GtkApplication *application
);
Lists the detailed action names which have associated accelerators.
See gtk_application_set_accels_for_action()
.
Since: 3.12
gchar ** gtk_application_get_accels_for_action (GtkApplication *application
,const gchar *detailed_action_name
);
Gets the accelerators that are currently associated with the given action.
application |
||
detailed_action_name |
a detailed action name, specifying an action and target to obtain accelerators for |
accelerators for detailed_action_name
, as
a NULL
-terminated array. Free with g_strfreev()
when no longer needed.
[transfer full]
Since: 3.12
void gtk_application_set_accels_for_action (GtkApplication *application
,const gchar *detailed_action_name
,const gchar * const *accels
);
Sets zero or more keyboard accelerators that will trigger the
given action. The first item in accels
will be the primary
accelerator, which may be displayed in the UI.
To remove all accelerators for an action, use an empty, zero-terminated
array for accels
.
For the detailed_action_name
, see g_action_parse_detailed_name()
and
g_action_print_detailed_name()
.
application |
||
detailed_action_name |
a detailed action name, specifying an action and target to associate accelerators with |
|
accels |
a list of accelerators in the format
understood by |
[array zero-terminated=1] |
Since: 3.12
gchar ** gtk_application_get_actions_for_accel (GtkApplication *application
,const gchar *accel
);
Returns the list of actions (possibly empty) that accel
maps to.
Each item in the list is a detailed action name in the usual form.
This might be useful to discover if an accel already exists in order to prevent installation of a conflicting accelerator (from an accelerator editor or a plugin system, for example). Note that having more than one action per accelerator may not be a bad thing and might make sense in cases where the actions never appear in the same context.
In case there are no actions for a given accelerator, an empty array
is returned. NULL
is never returned.
It is a programmer error to pass an invalid accelerator string.
If you are unsure, check it with gtk_accelerator_parse()
first.
Since: 3.14
struct GtkApplicationClass { GApplicationClass parent_class; void (*window_added) (GtkApplication *application, GtkWindow *window); void (*window_removed) (GtkApplication *application, GtkWindow *window); };
Signal emitted when a GtkWindow is added to
application through |
||
Signal emitted when a GtkWindow is removed from
application, either as a side-effect of being destroyed or
explicitly through |
Types of user actions that may be blocked by gtk_application_inhibit()
.
|
Inhibit ending the user session by logging out or by shutting down the computer |
||
|
Inhibit user switching |
||
|
Inhibit suspending the session or computer |
||
|
Inhibit the session being marked as idle (and possibly locked) |
Since: 3.4
“active-window”
property“active-window” GtkWindow *
The window which most recently had focus.
Flags: Read
“app-menu”
property“app-menu” GMenuModel *
The GMenuModel for the application menu.
Flags: Read / Write
“window-added”
signalvoid user_function (GtkApplication *application, GtkWindow *window, gpointer user_data)
Emitted when a GtkWindow is added to application
through
gtk_application_add_window()
.
application |
the GtkApplication which emitted the signal |
|
window |
the newly-added GtkWindow |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run First
Since: 3.2
“window-removed”
signalvoid user_function (GtkApplication *application, GtkWindow *window, gpointer user_data)
Emitted when a GtkWindow is removed from application
,
either as a side-effect of being destroyed or explicitly
through gtk_application_remove_window()
.
application |
the GtkApplication which emitted the signal |
|
window |
the GtkWindow that is being removed |
|
user_data |
user data set when the signal handler was connected. |
Flags: Run First
Since: 3.2


 Give us money. Your website will look great.
We can build, maintain and update your website frequently for an affordable price.
Feel free to email or call us to set up a meeting and get your website up and running next week!


The web page below shows an image of a head that bounces off the walls when the user mouses over the canvas. The head scales up in size by 0.1 when it hits a canvas edge.


A---B---C master on origin / D---E---F---G master ^ origin/master in your repository
git-pull(1) Manual Page
NAME
git-pull - Fetch from and integrate with another repository or a local branch
SYNOPSIS
git pull [options] [<repository> [<refspec>...]]
DESCRIPTION
Incorporates changes from a remote repository into the current branch. In its default mode, git pull is shorthand for git fetch followed by git merge FETCH_HEAD.
More precisely, git pull runs git fetch with the given parameters and calls git merge to merge the retrieved branch heads into the current branch. With --rebase, it runs git rebase instead of git merge.
<repository> should be the name of a remote repository as passed to git-fetch(1). <refspec> can name an arbitrary remote ref (for example, the name of a tag) or even a collection of refs with corresponding remote-tracking branches (e.g., refs/heads/*:refs/remotes/origin/*), but usually it is the name of a branch in the remote repository.
Default values for <repository> and <branch> are read from the "remote" and "merge" configuration for the current branch as set by git-branch(1) --track.
Assume the following history exists and the current branch is "master":
Then "git pull" will fetch and replay the changes from the remote master branch since it diverged from the local master (i.e., E) until its current commit (C) on top of master and record the result in a new commit along with the names of the two parent commits and a log message from the user describing the changes.
A---B---C origin/master / \ D---E---F---G---H master
See git-merge(1) for details, including how conflicts are presented and handled.
In Git 1.7.0 or later, to cancel a conflicting merge, use git reset --merge. Warning: In older versions of Git, running git pull with uncommitted changes is discouraged: while possible, it leaves you in a state that may be hard to back out of in the case of a conflict.
If any of the remote changes overlap with local uncommitted changes, the merge will be automatically cancelled and the work tree untouched. It is generally best to get any local changes in working order before pulling or stash them away with git-stash(1).
OPTIONS
Options meant for git pull itself and the underlying git merge must be given before the options meant for git fetch.
- -q
- --quiet
This is passed to both underlying git-fetch to squelch reporting of during transfer, and underlying git-merge to squelch output during merging.
- -v
- --verbose
Pass --verbose to git-fetch and git-merge.
- --[no-]recurse-submodules[=yes|on-demand|no]
This option controls if new commits of all populated submodules should be fetched too (see git-config(1) and gitmodules(5)). That might be necessary to get the data needed for merging submodule commits, a feature Git learned in 1.7.3. Notice that the result of a merge will not be checked out in the submodule, "git submodule update" has to be called afterwards to bring the work tree up to date with the merge result.
Options related to merging
- --commit
- --no-commit
Perform the merge and commit the result. This option can be used to override --no-commit.
With --no-commit perform the merge but pretend the merge failed and do not autocommit, to give the user a chance to inspect and further tweak the merge result before committing.
- --edit
- -e
- --no-edit
Invoke an editor before committing successful mechanical merge to further edit the auto-generated merge message, so that the user can explain and justify the merge. The --no-edit option can be used to accept the auto-generated message (this is generally discouraged). The --edit (or -e) option is still useful if you are giving a draft message with the -m option from the command line and want to edit it in the editor.
Older scripts may depend on the historical behaviour of not allowing the user to edit the merge log message. They will see an editor opened when they run git merge. To make it easier to adjust such scripts to the updated behaviour, the environment variable GIT_MERGE_AUTOEDIT can be set to no at the beginning of them.
- --ff
When the merge resolves as a fast-forward, only update the branch pointer, without creating a merge commit. This is the default behavior.
- --no-ff
Create a merge commit even when the merge resolves as a fast-forward. This is the default behaviour when merging an annotated (and possibly signed) tag.
- --ff-only
Refuse to merge and exit with a non-zero status unless the current HEAD is already up-to-date or the merge can be resolved as a fast-forward.
- --log[=<n>]
- --no-log
In addition to branch names, populate the log message with one-line descriptions from at most <n> actual commits that are being merged. See also git-fmt-merge-msg(1).
With --no-log do not list one-line descriptions from the actual commits being merged.
- --stat
- -n
- --no-stat
Show a diffstat at the end of the merge. The diffstat is also controlled by the configuration option merge.stat.
With -n or --no-stat do not show a diffstat at the end of the merge.
- --squash
- --no-squash
Produce the working tree and index state as if a real merge happened (except for the merge information), but do not actually make a commit or move the HEAD, nor record $GIT_DIR/MERGE_HEAD to cause the next git commit command to create a merge commit. This allows you to create a single commit on top of the current branch whose effect is the same as merging another branch (or more in case of an octopus).
With --no-squash perform the merge and commit the result. This option can be used to override --squash.
- -s <strategy>
- --strategy=<strategy>
Use the given merge strategy; can be supplied more than once to specify them in the order they should be tried. If there is no -s option, a built-in list of strategies is used instead (git merge-recursive when merging a single head, git merge-octopus otherwise).
- -X <option>
- --strategy-option=<option>
Pass merge strategy specific option through to the merge strategy.
- --verify-signatures
- --no-verify-signatures
Verify that the commits being merged have good and trusted GPG signatures and abort the merge in case they do not.
- --summary
- --no-summary
Synonyms to --stat and --no-stat; these are deprecated and will be removed in the future.
- -q
- --quiet
Operate quietly. Implies --no-progress.
- -v
- --verbose
Be verbose.
- --progress
- --no-progress
Turn progress on/off explicitly. If neither is specified, progress is shown if standard error is connected to a terminal. Note that not all merge strategies may support progress reporting.
- -r
- --rebase[=false|true|preserve]
When true, rebase the current branch on top of the upstream branch after fetching. If there is a remote-tracking branch corresponding to the upstream branch and the upstream branch was rebased since last fetched, the rebase uses that information to avoid rebasing non-local changes.
When preserve, also rebase the current branch on top of the upstream branch, but pass --preserve-merges along to git rebase so that locally created merge commits will not be flattened.
When false, merge the current branch into the upstream branch.
See pull.rebase, branch.<name>.rebase and branch.autosetuprebase in git-config(1) if you want to make git pull always use --rebase instead of merging.
NoteThis is a potentially dangerous mode of operation. It rewrites history, which does not bode well when you published that history already. Do not use this option unless you have read git-rebase(1) carefully. - --no-rebase
Override earlier --rebase.
Options related to fetching
- --all
Fetch all remotes.
- -a
- --append
Append ref names and object names of fetched refs to the existing contents of .git/FETCH_HEAD. Without this option old data in .git/FETCH_HEAD will be overwritten.
- --depth=<depth>
Deepen or shorten the history of a shallow repository created by git clone with --depth=<depth> option (see git-clone(1)) to the specified number of commits from the tip of each remote branch history. Tags for the deepened commits are not fetched.
- --unshallow
Convert a shallow repository to a complete one, removing all the limitations imposed by shallow repositories.
- -f
- --force
When git fetch is used with <rbranch>:<lbranch> refspec, it refuses to update the local branch <lbranch> unless the remote branch <rbranch> it fetches is a descendant of <lbranch>. This option overrides that check.
- -k
- --keep
Keep downloaded pack.
- --no-tags
By default, tags that point at objects that are downloaded from the remote repository are fetched and stored locally. This option disables this automatic tag following. The default behavior for a remote may be specified with the remote.<name>.tagopt setting. See git-config(1).
- -u
- --update-head-ok
By default git fetch refuses to update the head which corresponds to the current branch. This flag disables the check. This is purely for the internal use for git pull to communicate with git fetch, and unless you are implementing your own Porcelain you are not supposed to use it.
- --upload-pack <upload-pack>
When given, and the repository to fetch from is handled by git fetch-pack, --exec=<upload-pack> is passed to the command to specify non-default path for the command run on the other end.
- --progress
Progress status is reported on the standard error stream by default when it is attached to a terminal, unless -q is specified. This flag forces progress status even if the standard error stream is not directed to a terminal.
- <repository>
The "remote" repository that is the source of a fetch or pull operation. This parameter can be either a URL (see the section GIT URLS below) or the name of a remote (see the section REMOTES below).
- <refspec>
The format of a <refspec> parameter is an optional plus +, followed by the source ref <src>, followed by a colon :, followed by the destination ref <dst>.
The remote ref that matches <src> is fetched, and if <dst> is not empty string, the local ref that matches it is fast-forwarded using <src>. If the optional plus + is used, the local ref is updated even if it does not result in a fast-forward update.
NoteIf the remote branch from which you want to pull is modified in non-linear ways such as being rewound and rebased frequently, then a pull will attempt a merge with an older version of itself, likely conflict, and fail. It is under these conditions that you would want to use the + sign to indicate non-fast-forward updates will be needed. There is currently no easy way to determine or declare that a branch will be made available in a repository with this behavior; the pulling user simply must know this is the expected usage pattern for a branch. NoteYou never do your own development on branches that appear on the right hand side of a <refspec> colon on Pull: lines; they are to be updated by git fetch. If you intend to do development derived from a remote branch B, have a Pull: line to track it (i.e. Pull: B:remote-B), and have a separate branch my-B to do your development on top of it. The latter is created by git branch my-B remote-B (or its equivalent git checkout -b my-B remote-B). Run git fetch to keep track of the progress of the remote side, and when you see something new on the remote branch, merge it into your development branch with git pull . remote-B, while you are on my-B branch. NoteThere is a difference between listing multiple <refspec> directly on git pull command line and having multiple Pull: <refspec> lines for a <repository> and running git pull command without any explicit <refspec> parameters. <refspec> listed explicitly on the command line are always merged into the current branch after fetching. In other words, if you list more than one remote refs, you would be making an Octopus. While git pull run without any explicit <refspec> parameter takes default <refspec>s from Pull: lines, it merges only the first <refspec> found into the current branch, after fetching all the remote refs. This is because making an Octopus from remote refs is rarely done, while keeping track of multiple remote heads in one-go by fetching more than one is often useful. Some short-cut notations are also supported.
tag <tag> means the same as refs/tags/<tag>:refs/tags/<tag>; it requests fetching everything up to the given tag.
A parameter <ref> without a colon merges <ref> into the current branch, and updates the remote-tracking branches (if any).
GIT URLS
In general, URLs contain information about the transport protocol, the address of the remote server, and the path to the repository. Depending on the transport protocol, some of this information may be absent.
Git supports ssh, git, http, and https protocols (in addition, ftp, and ftps can be used for fetching and rsync can be used for fetching and pushing, but these are inefficient and deprecated; do not use them).
The native transport (i.e. git:// URL) does no authentication and should be used with caution on unsecured networks.
The following syntaxes may be used with them:
ssh://[user@]host.xz[:port]/path/to/repo.git/
git://host.xz[:port]/path/to/repo.git/
http[s]://host.xz[:port]/path/to/repo.git/
ftp[s]://host.xz[:port]/path/to/repo.git/
rsync://host.xz/path/to/repo.git/
An alternative scp-like syntax may also be used with the ssh protocol:
[user@]host.xz:path/to/repo.git/
This syntax is only recognized if there are no slashes before the first colon. This helps differentiate a local path that contains a colon. For example the local path foo:bar could be specified as an absolute path or ./foo:bar to avoid being misinterpreted as an ssh url.
The ssh and git protocols additionally support ~username expansion:
ssh://[user@]host.xz[:port]/~[user]/path/to/repo.git/
git://host.xz[:port]/~[user]/path/to/repo.git/
[user@]host.xz:/~[user]/path/to/repo.git/
For local repositories, also supported by Git natively, the following syntaxes may be used:
/path/to/repo.git/
\file:///path/to/repo.git/
These two syntaxes are mostly equivalent, except when cloning, when the former implies --local option. See git-clone(1) for details.
When Git doesn't know how to handle a certain transport protocol, it attempts to use the remote-<transport> remote helper, if one exists. To explicitly request a remote helper, the following syntax may be used:
<transport>::<address>
where <address> may be a path, a server and path, or an arbitrary URL-like string recognized by the specific remote helper being invoked. See gitremote-helpers(1) for details.
If there are a large number of similarly-named remote repositories and you want to use a different format for them (such that the URLs you use will be rewritten into URLs that work), you can create a configuration section of the form:
[url "<actual url base>"] insteadOf = <other url base>
For example, with this:
[url "git://git.host.xz/"] insteadOf = host.xz:/path/to/ insteadOf = work:
a URL like "work:repo.git" or like "host.xz:/path/to/repo.git" will be rewritten in any context that takes a URL to be "git://git.host.xz/repo.git".
If you want to rewrite URLs for push only, you can create a configuration section of the form:
[url "<actual url base>"] pushInsteadOf = <other url base>
For example, with this:
[url "ssh://example.org/"] pushInsteadOf = git://example.org/
a URL like "git://example.org/path/to/repo.git" will be rewritten to "ssh://example.org/path/to/repo.git" for pushes, but pulls will still use the original URL.
REMOTES
The name of one of the following can be used instead of a URL as <repository> argument:
a remote in the Git configuration file: $GIT_DIR/config,
a file in the $GIT_DIR/remotes directory, or
a file in the $GIT_DIR/branches directory.
All of these also allow you to omit the refspec from the command line because they each contain a refspec which git will use by default.
Named remote in configuration file
You can choose to provide the name of a remote which you had previously configured using git-remote(1), git-config(1) or even by a manual edit to the $GIT_DIR/config file. The URL of this remote will be used to access the repository. The refspec of this remote will be used by default when you do not provide a refspec on the command line. The entry in the config file would appear like this:
[remote "<name>"] url = <url> pushurl = <pushurl> push = <refspec> fetch = <refspec>
The <pushurl> is used for pushes only. It is optional and defaults to <url>.
Named file in $GIT_DIR/remotes
You can choose to provide the name of a file in $GIT_DIR/remotes. The URL in this file will be used to access the repository. The refspec in this file will be used as default when you do not provide a refspec on the command line. This file should have the following format:
URL: one of the above URL format Push: <refspec> Pull: <refspec>
Push: lines are used by git push and Pull: lines are used by git pull and git fetch. Multiple Push: and Pull: lines may be specified for additional branch mappings.
Named file in $GIT_DIR/branches
You can choose to provide the name of a file in $GIT_DIR/branches. The URL in this file will be used to access the repository. This file should have the following format:
<url>#<head>
<url> is required; #<head> is optional.
Depending on the operation, git will use one of the following refspecs, if you don't provide one on the command line. <branch> is the name of this file in $GIT_DIR/branches and <head> defaults to master.
git fetch uses:
refs/heads/<head>:refs/heads/<branch>
git push uses:
HEAD:refs/heads/<head>
MERGE STRATEGIES
The merge mechanism (git-merge and git-pull commands) allows the backend merge strategies to be chosen with -s option. Some strategies can also take their own options, which can be passed by giving -X<option> arguments to git-merge and/or git-pull.
- resolve
This can only resolve two heads (i.e. the current branch and another branch you pulled from) using a 3-way merge algorithm. It tries to carefully detect criss-cross merge ambiguities and is considered generally safe and fast.
- recursive
This can only resolve two heads using a 3-way merge algorithm. When there is more than one common ancestor that can be used for 3-way merge, it creates a merged tree of the common ancestors and uses that as the reference tree for the 3-way merge. This has been reported to result in fewer merge conflicts without causing mis-merges by tests done on actual merge commits taken from Linux 2.6 kernel development history. Additionally this can detect and handle merges involving renames. This is the default merge strategy when pulling or merging one branch.
The recursive strategy can take the following options:
- ours
This option forces conflicting hunks to be auto-resolved cleanly by favoring our version. Changes from the other tree that do not conflict with our side are reflected to the merge result. For a binary file, the entire contents are taken from our side.
This should not be confused with the ours merge strategy, which does not even look at what the other tree contains at all. It discards everything the other tree did, declaring our history contains all that happened in it.
- theirs
This is the opposite of ours.
- patience
With this option, merge-recursive spends a little extra time to avoid mismerges that sometimes occur due to unimportant matching lines (e.g., braces from distinct functions). Use this when the branches to be merged have diverged wildly. See also git-diff(1) --patience.
- diff-algorithm=[patience|minimal|histogram|myers]
Tells merge-recursive to use a different diff algorithm, which can help avoid mismerges that occur due to unimportant matching lines (such as braces from distinct functions). See also git-diff(1) --diff-algorithm.
- ignore-space-change
- ignore-all-space
- ignore-space-at-eol
Treats lines with the indicated type of whitespace change as unchanged for the sake of a three-way merge. Whitespace changes mixed with other changes to a line are not ignored. See also git-diff(1) -b, -w, and --ignore-space-at-eol.
If their version only introduces whitespace changes to a line, our version is used;
If our version introduces whitespace changes but their version includes a substantial change, their version is used;
Otherwise, the merge proceeds in the usual way.
- renormalize
This runs a virtual check-out and check-in of all three stages of a file when resolving a three-way merge. This option is meant to be used when merging branches with different clean filters or end-of-line normalization rules. See "Merging branches with differing checkin/checkout attributes" in gitattributes(5) for details.
- no-renormalize
Disables the renormalize option. This overrides the merge.renormalize configuration variable.
- rename-threshold=<n>
Controls the similarity threshold used for rename detection. See also git-diff(1) -M.
- subtree[=<path>]
This option is a more advanced form of subtree strategy, where the strategy makes a guess on how two trees must be shifted to match with each other when merging. Instead, the specified path is prefixed (or stripped from the beginning) to make the shape of two trees to match.
- octopus
This resolves cases with more than two heads, but refuses to do a complex merge that needs manual resolution. It is primarily meant to be used for bundling topic branch heads together. This is the default merge strategy when pulling or merging more than one branch.
- ours
This resolves any number of heads, but the resulting tree of the merge is always that of the current branch head, effectively ignoring all changes from all other branches. It is meant to be used to supersede old development history of side branches. Note that this is different from the -Xours option to the recursive merge strategy.
- subtree
This is a modified recursive strategy. When merging trees A and B, if B corresponds to a subtree of A, B is first adjusted to match the tree structure of A, instead of reading the trees at the same level. This adjustment is also done to the common ancestor tree.
DEFAULT BEHAVIOUR
Often people use git pull without giving any parameter. Traditionally, this has been equivalent to saying git pull origin. However, when configuration branch.<name>.remote is present while on branch <name>, that value is used instead of origin.
In order to determine what URL to use to fetch from, the value of the configuration remote.<origin>.url is consulted and if there is not any such variable, the value on URL: line in $GIT_DIR/remotes/<origin> file is used.
In order to determine what remote branches to fetch (and optionally store in the remote-tracking branches) when the command is run without any refspec parameters on the command line, values of the configuration variable remote.<origin>.fetch are consulted, and if there aren't any, $GIT_DIR/remotes/<origin> file is consulted and its Pull: lines are used. In addition to the refspec formats described in the OPTIONS section, you can have a globbing refspec that looks like this:
refs/heads/*:refs/remotes/origin/*
A globbing refspec must have a non-empty RHS (i.e. must store what were fetched in remote-tracking branches), and its LHS and RHS must end with /*. The above specifies that all remote branches are tracked using remote-tracking branches in refs/remotes/origin/ hierarchy under the same name.
The rule to determine which remote branch to merge after fetching is a bit involved, in order not to break backward compatibility.
If explicit refspecs were given on the command line of git pull, they are all merged.
When no refspec was given on the command line, then git pull uses the refspec from the configuration or $GIT_DIR/remotes/<origin>. In such cases, the following rules apply:
If branch.<name>.merge configuration for the current branch <name> exists, that is the name of the branch at the remote site that is merged.
If the refspec is a globbing one, nothing is merged.
Otherwise the remote branch of the first refspec is merged.
EXAMPLES
Update the remote-tracking branches for the repository you cloned from, then merge one of them into your current branch:
$ git pull, git pull origin
Normally the branch merged in is the HEAD of the remote repository, but the choice is determined by the branch.<name>.remote and branch.<name>.merge options; see git-config(1) for details.
Merge into the current branch the remote branch next:
$ git pull origin next
This leaves a copy of next temporarily in FETCH_HEAD, but does not update any remote-tracking branches. Using remote-tracking branches, the same can be done by invoking fetch and merge:
$ git fetch origin $ git merge origin/next
If you tried a pull which resulted in complex conflicts and would want to start over, you can recover with git reset.
BUGS
Using --recurse-submodules can only fetch new commits in already checked out submodules right now. When e.g. upstream added a new submodule in the just fetched commits of the superproject the submodule itself can not be fetched, making it impossible to check out that submodule later without having to do a fetch again. This is expected to be fixed in a future Git version.
SEE ALSO
GIT
Part of the git(1) suite


The Raspberry Pi (RPi) has a very underpowered CPU but a very powerful GPU. Using the GPU is not well documented. This chapter looks at drawing, rendering images, etc, using the GPU.
Most drawing using RPi's GPU seems to be based around OpenGL ES. In order to use this we need to get an EGLSurface upon which OpenGL ES calls can be made.
The EGLSurface is a generic type which has to be backed by a specific implementation for the device/hardware/etc which you want to draw into. The page Raspberry Pi VideoCore APIs gives a quick overview of the APIs involved. Basically, to get to the EGLSurface you have to use the Dispmanx window system, which is reportedly being deprecated but is still used in all the demos and code that I have seen.
The relevant Dispmanx calls are
DISPMANX_ELEMENT_HANDLE_T dispman_element;
DISPMANX_DISPLAY_HANDLE_T dispman_display;
DISPMANX_UPDATE_HANDLE_T dispman_update;
VC_RECT_T dst_rect;
VC_RECT_T src_rect;
success = graphics_get_display_size(0 /* LCD */,
&screen_width, &screen_height);
assert( success >= 0 );
dst_rect.x = 0;
dst_rect.y = 0;
dst_rect.width = screen_width;
dst_rect.height = screen_height;
src_rect.x = 0;
src_rect.y = 0;
src_rect.width = screen_width << 16;
src_rect.height = screen_height << 16;
dispman_display = vc_dispmanx_display_open( 0 /* LCD */);
dispman_update = vc_dispmanx_update_start( 0 );
dispman_element =
vc_dispmanx_element_add(dispman_update, dispman_display,
0/*layer*/, &dst_rect, 0/*src*/,
&src_rect, DISPMANX_PROTECTION_NONE,
0 /*alpha*/, 0/*clamp*/, 0/*transform*/);
At the end of this you have a window stored in
dispman_element
that can be used as a native window
object later.
Initialising EGL is done in the standard way of
Apart from the last step, this follows standard EGL programming:
static const EGLint attribute_list[] =
{
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_NONE
};
static const EGLint context_attributes[] =
{
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
EGLConfig config;
// get an EGL display connection
display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
// initialize the EGL display connection
result = eglInitialize(display, NULL, NULL);
// get an appropriate EGL frame buffer configuration
result = eglChooseConfig(display, attribute_list, &config, 1, &num_config);
assert(EGL_FALSE != result);
// get an appropriate EGL frame buffer configuration
result = eglBindAPI(EGL_OPENGL_ES_API);
assert(EGL_FALSE != result);
// create an EGL rendering context
context = eglCreateContext(display, config, EGL_NO_CONTEXT, context_attributes);
assert(context!=EGL_NO_CONTEXT);
The next step is to link the Dispmanx window to the EGL window
surface. This uses a structure of type EGL_DISPMANX_WINDOW_T
which is filled in from the Dispmanx information:
EGL_DISPMANX_WINDOW_T nativewindow;
nativewindow.element = dispman_element;
nativewindow.width = screen_width;
nativewindow.height = screen_height;
vc_dispmanx_update_submit_sync( dispman_update );
The EGL surface is then created by
surface = eglCreateWindowSurface(display, config, &nativewindow, NULL);
// connect the context to the surface
eglMakeCurrent(display, surface, surface, context);
In this section we do the absolute minimum: having got an EGL surface talking to the GPU, we just use OpenGL ES calls to set the background of the buffer to red and then display the buffer by swapping EGL buffers:
glClearColor(1.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
eglSwapBuffers(display, surface);
The complete program is rectangle.c and just displays a large red square:
Compiling the program uses a horrendous mess of defines and libraries, probably not all of which are needed!
cc -g -DUSE_OPENGL -DUSE_EGL -DIS_RPI -DSTANDALONE -D__STDC_CONSTANT_MACROS -D__STDC_LIMIT_MACROS -DTARGET_POSIX -D_LINUX -fPIC -DPIC -D_REENTRANT -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64 -U_FORTIFY_SOURCE -Wall -g -DHAVE_LIBOPENMAX=2 -DOMX -DOMX_SKIP64BIT -ftree-vectorize -pipe -DUSE_EXTERNAL_OMX -DHAVE_LIBBCM_HOST -DUSE_EXTERNAL_LIBBCM_HOST -DUSE_VCHIQ_ARM -Wno-psabi -I/opt/vc/include/ -I/opt/vc/include/interface/vcos/pthreads -I/opt/vc/include/interface/vmcs_host/linux -I./ -I/opt/vc/src/hello_pi/libs/ilclient -I/opt/vc/src/hello_pi/libs/vgfont -g -c rectangle.c -o rectangle.o -Wno-deprecated-declarations
cc -o rectangle -Wl,--whole-archive rectangle.o -L/opt/vc/lib/ -lGLESv2 -lEGL -lbcm_host -lvcos -lvchiq_arm -lpthread -lrt -L/opt/vc/src/hello_pi/libs/vgfont -ldl -lm -Wl,--no-whole-archive -rdynamic
However, it can then be run easily by
./rectangle
The previous example did the absolute minimum of OpenGL calls, just clearing the background. In this setion we do a bit more, by using OpenGL calls to clear the background and repeatedly draw a triangle (the same one!) multiple times a second. The code is just adapted from Chapter 2 of the OpenGL ES 2.0 Programming Guide
The essential differences from the Programming Guide are
esUtils.c
,
while we explicitly show the RPi stuff here
The program is triangle.c:
The OpenGL ES Programming Guide includes an example of drawing a simple image using an array of pixels. Realistically, it notes that the image data is more likely to be read from a file. In this section we fill in the details.
There are many, many different file formats, some lossy, some lossless, some compressed, some not, some with metadata, some without. In this section we just use TGA - an uncompressed format with enough useful metadata, simple to load.
TGA files can be created from e.g. JPEG files by using the
convert
utility from the Gimp drawing system.
It is simple to convert a file: just give the appropriate
file extensions:
convert image.jpg image.tga
(Later sections look at decompressing files using the GPU itself.)
A TGA file has a header section which gives the width and height of the image from which its size can be calculated. The default format will be RGB, as 24-bit pixels. Reading in such a file is just a matter of locating the dimensions, malloc'ing the right size buffer, skipping to the start of the image data and reading it all in.
The default is for the origin of the image to be the bottom lefthand corner, with the y-axis growing up. OpenGL ES on the other hand has the origin in the top lefthand corner with the y-axis growing down. So the image will be upside down. This can be fixed by reading the data in differently, or by using an OpenGL ES reflection.
Getting a native window is done as before. Using the OpenGL ES Programming Guide example, we also need to substitute our image array for their 2x2 array, adjusting the image bounds. Apart from those, there is no real change. The program is image.c
The image used is of me.


{% extends "global/Page.html" %} {% load staticfiles otree %} {% block scripts %} {% endblock %} {% block title %} Decision {{ round_num }} - {{ mode }} with {{ rebate }}% Rebate {% endblock %} {% block styles %} {% endblock %} {% block content %} {{ form.exit_choice.errors }} {{ form.money_donated.errors }} {{ form.exit_amount.errors }} {{ form.donated_yes_no.errors }} {{ form.exit_choice_available.errors }}
| Total Cash Available | Would you like to donate any to the charity? | {% if exit_fee != 0 %}Would you like us to not announce the rebate you received in the FB post? | {% endif %}{{ rebate }}% rebate cash back in your account | Total cash left in your account now (including rebate) |
|---|---|---|---|---|
| ${{ total_cash_available }} (${{ Constants.participation_fee }} participation fee + ${{ player.endowment }} from task) |
Yes: choose between $1 to $10:
|
{% if exit_fee != 0 %}
Yes: we will deduct ${{exit_fee}} from your personal account | {% else %} {% endif %}||
| No: $0. Your decision will NOT be posted. | {% if exit_fee != 0 %}No | {% endif %}


Virtualization is the act of creating a virtual version of something, including virtual computer hardware. It uses software to create an abstraction layer over computer hardware that allows the hardware elements of a single computer—processors, memory, storage and more—to be divided into multiple virtual computers, commonly called virtual machines (VMs).
Containerization is the process of packing an application with all of its related configuration files, libraries and dependencies required for it to run in an efficient and bug-free way across different computing environments. Each container simulates a different software application. A common operating system is shared by multiple containers.
Comparison of Virtualization (a) & Containerization (b)
Virtualization enables you to run multiple operating systems on the hardware of a single physical server, while containerization enables you to deploy multiple applications using the same operating system on a single virtual machine or server.
Virtual machines use a hypervisor, or virtual machine monitor. This is the software layer that enables multiple operating systems to run side-by-side on same physical server. The hypervisor manages the available resources (computing power, memory, storage, etc.), aligning a portion to each virtual machine as needed. Container systems provide operating system services from the underlying host and isolate the applications using virtual-memory hardware.
Virtual machines have a longer lifecycle than containers. They are best used for longer periods of time. Containers have a fast set up time and are best used for tasks that may only take a few hours.
Virtualization provides complete isolation from the host operating system and the other virtual machines, whereas, containerization typically provides lightweight isolation from the host and other containers, but doesn’t provide as strong a security boundary as a virtual machine.


It works as a conditional for d-for. So, it means: it can be used for active or inactive the attribute d-for.
Here a basic sample where the button toggle will active or inactive the interator:


Class: Concurrent::Edge::Future
- Inherits:
-
Event
- Object
- Synchronization::LockableObject
- Event
- Concurrent::Edge::Future
- Defined in:
- lib/concurrent/edge/future.rb
Overview
Represents a value which will become available in future. May fail with a reason instead.
Direct Known Subclasses
Constant Summary
Instance Method Summary (collapse)
-
- (Future) any(*futures)
(also: #|)
Which has first completed value from futures.

- - (Object) exception(*args)
-
- (Boolean) failed?(state = internal_state)
Has Future been failed?.
-
- (Object) flat(level = 1)
zips with the Future in the value.
- - (Boolean) fulfilled?
-
- (Object) on_failure(executor = nil) {|reason| ... }
Self.
-
- (Object) on_failure! {|reason| ... }
Self.
-
- (Object) on_success(executor = nil) {|value| ... }
Self.
-
- (Object) on_success! {|value| ... }
Self.
-
- (Exception?) reason(timeout = nil)
The reason of the Future's failure.
- - (Boolean) rejected?
- - (Future) rescue(executor = nil) {|reason| ... }
-
- (Array(Boolean, Object, Exception)?) result(timeout = nil)
Triplet of success, value, reason.
-
- (Future) schedule(intended_time)
Schedules rest of the chain for execution with specified time or on specified time.
- - (:pending, ...) state
-
- (Boolean) success?(state = internal_state)
Has Future been success?.
- - (Future) then(executor = nil) {|value| ... }
-
- (Future) then_ask(actor)
Asks the actor with its value.
- - (Object) then_put(channel)
-
- (Future) then_select(*channels)
Zips with selected value form the suplied channels.
-
- (Object?) value(timeout = nil)
The value of the Future when success, nil on timeout.
-
- (Object?) value!(timeout = nil)
Wait until Future is #complete?.
-
- (Event, ...) wait!(timeout = nil)
Wait until Future is #complete?.
-
- (Future) with_default_executor(executor)
Changes default executor for rest of the chain.
-
- (Future) zip(other)
(also: #&)
Zip with future producing new Future.
Constructor Details
This class inherits a constructor from Concurrent::Edge::Event
Instance Method Details
- (Future) any(*futures) Also known as: |
Returns which has first completed value from futures
662 663 664 |
# File 'lib/concurrent/edge/future.rb', line 662 def any(*futures) AnyPromise.new([self, *futures], @DefaultExecutor).future end |
- (Object) chain_completable(completable_future) Also known as: tangle
642 643 644 |
# File 'lib/concurrent/edge/future.rb', line 642 def chain_completable(completable_future) on_completion! { completable_future.complete_with internal_state } end |
- (Future) delay
Inserts delay into the chain of Futures making rest of it lazy evaluated.
668 669 670 |
# File 'lib/concurrent/edge/future.rb', line 668 def delay ZipFutureEventPromise.new(self, Delay.new(@DefaultExecutor).future, @DefaultExecutor).future end |
- (Object) exception(*args)
619 620 621 622 623 624 625 626 627 628 |
# File 'lib/concurrent/edge/future.rb', line 619 def exception(*args) raise 'obligation is not failed' unless failed? reason = internal_state.reason if reason.is_a?(::Array) reason.each { |e| log ERROR, 'Edge::Future', e } Concurrent::Error.new 'multiple exceptions, inspect log' else reason.exception(*args) end end |
- (Boolean) failed?(state = internal_state)
Has Future been failed?
560 561 562 |
# File 'lib/concurrent/edge/future.rb', line 560 def failed?(state = internal_state) state.completed? && !state.success? end |
- (Object) flat(level = 1)
zips with the Future in the value
657 658 659 |
# File 'lib/concurrent/edge/future.rb', line 657 def flat(level = 1) FlatPromise.new(self, level, @DefaultExecutor).future end |
- (Boolean) fulfilled?
553 554 555 556 |
# File 'lib/concurrent/edge/future.rb', line 553 def fulfilled? deprecated_method 'fulfilled?', 'success?' success? end |
- (Object) on_failure(executor = nil) {|reason| ... }
Returns self
722 723 724 |
# File 'lib/concurrent/edge/future.rb', line 722 def on_failure(executor = nil, &callback) add_callback :pr_async_callback_on_failure, executor || @DefaultExecutor, callback end |
- (Object) on_failure! {|reason| ... }
Returns self
734 735 736 |
# File 'lib/concurrent/edge/future.rb', line 734 def on_failure!(&callback) add_callback :pr_callback_on_failure, callback end |
- (Object) on_success(executor = nil) {|value| ... }
Returns self
716 717 718 |
# File 'lib/concurrent/edge/future.rb', line 716 def on_success(executor = nil, &callback) add_callback :pr_async_callback_on_success, executor || @DefaultExecutor, callback end |
- (Object) on_success! {|value| ... }
Returns self
728 729 730 |
# File 'lib/concurrent/edge/future.rb', line 728 def on_success!(&callback) add_callback :pr_callback_on_success, callback end |
- (Exception?) reason(timeout = nil)
If the Future can have value nil
then it cannot be distinquished from nil
returned on timeout.
In this case is better to use first wait
then value
(or similar).
a thread should wait only once! For repeated checking use faster completed?
check.
If thread waits periodically it will dangerously grow the waiters stack.
Returns the reason of the Future's failure
582 583 584 585 |
# File 'lib/concurrent/edge/future.rb', line 582 def reason(timeout = nil) touch internal_state.reason if wait_until_complete timeout end |
- (Boolean) rejected?
564 565 566 567 |
# File 'lib/concurrent/edge/future.rb', line 564 def rejected? deprecated_method 'rejected?', 'failed?' failed? end |
- (Future) rescue(executor = nil) {|reason| ... }
650 651 652 |
# File 'lib/concurrent/edge/future.rb', line 650 def rescue(executor = nil, &callback) RescuePromise.new(self, @DefaultExecutor, executor || @DefaultExecutor, &callback).future end |
- (Array(Boolean, Object, Exception)?) result(timeout = nil)
If the Future can have value nil
then it cannot be distinquished from nil
returned on timeout.
In this case is better to use first wait
then value
(or similar).
a thread should wait only once! For repeated checking use faster completed?
check.
If thread waits periodically it will dangerously grow the waiters stack.
Returns triplet of success, value, reason
590 591 592 593 |
# File 'lib/concurrent/edge/future.rb', line 590 def result(timeout = nil) touch internal_state.result if wait_until_complete timeout end |
- (Future) schedule(intended_time)
Schedules rest of the chain for execution with specified time or on specified time
674 675 676 677 678 679 680 |
# File 'lib/concurrent/edge/future.rb', line 674 def schedule(intended_time) chain do ZipFutureEventPromise.new(self, ScheduledPromise.new(@DefaultExecutor, intended_time).event, @DefaultExecutor).future end.flat end |
- (:pending, ...) state
|
|
# File 'lib/concurrent/edge/future.rb', line 544
|
- (Boolean) success?(state = internal_state)
Has Future been success?
549 550 551 |
# File 'lib/concurrent/edge/future.rb', line 549 def success?(state = internal_state) state.completed? && state.success? end |
- (Future) then(executor = nil) {|value| ... }
632 633 634 |
# File 'lib/concurrent/edge/future.rb', line 632 def then(executor = nil, &callback) ThenPromise.new(self, @DefaultExecutor, executor || @DefaultExecutor, &callback).future end |
- (Future) then_ask(actor)
Asks the actor with its value.
638 639 640 |
# File 'lib/concurrent/edge/future.rb', line 638 def then_ask(actor) self.then { |v| actor.ask(v) }.flat end |
- (Object) then_put(channel)
may block
only proof of concept
710 711 712 |
# File 'lib/concurrent/edge/future.rb', line 710 def then_put(channel) on_success(:io) { |value| channel.put value } end |
- (Future) then_select(*channels)
Zips with selected value form the suplied channels
684 685 686 |
# File 'lib/concurrent/edge/future.rb', line 684 def then_select(*channels) ZipFuturesPromise.new([self, Concurrent.select(*channels)], @DefaultExecutor).future end |
- (Object?) value(timeout = nil)
If the Future can have value nil
then it cannot be distinquished from nil
returned on timeout.
In this case is better to use first wait
then value
(or similar).
a thread should wait only once! For repeated checking use faster completed?
check.
If thread waits periodically it will dangerously grow the waiters stack.
Returns the value of the Future when success, nil on timeout
574 575 576 577 |
# File 'lib/concurrent/edge/future.rb', line 574 def value(timeout = nil) touch internal_state.value if wait_until_complete timeout end |
- (Object?) value!(timeout = nil)
If the Future can have value nil
then it cannot be distinquished from nil
returned on timeout.
In this case is better to use first wait
then value
(or similar).
a thread should wait only once! For repeated checking use faster completed?
check.
If thread waits periodically it will dangerously grow the waiters stack.
Wait until Future is #complete?
612 613 614 615 |
# File 'lib/concurrent/edge/future.rb', line 612 def value!(timeout = nil) touch internal_state.value if wait_until_complete! timeout end |
- (Event, ...) wait!(timeout = nil)
a thread should wait only once! For repeated checking use faster completed?
check.
If thread waits periodically it will dangerously grow the waiters stack.
Wait until Future is #complete?
600 601 602 603 604 |
# File 'lib/concurrent/edge/future.rb', line 600 def wait!(timeout = nil) touch result = wait_until_complete!(timeout) timeout ? result : self end |
- (Future) with_default_executor(executor)
Changes default executor for rest of the chain
690 691 692 |
# File 'lib/concurrent/edge/future.rb', line 690 def with_default_executor(executor) FutureWrapperPromise.new(self, executor).future end |
- (Future) zip(other) Also known as: &
Zip with future producing new Future
696 697 698 699 700 701 702 |
# File 'lib/concurrent/edge/future.rb', line 696 def zip(other) if other.is_a?(Future) ZipFutureFuturePromise.new(self, other, @DefaultExecutor).future else ZipFutureEventPromise.new(self, other, @DefaultExecutor).future end end |


## -*- coding: utf-8 -*- <% cu=helpers.get_current_user(controller) _=translate %>
COREBlog3 is based on Cloud CMS powered by Google App Engine © Webcore Corp.


We don't sell this. Sorry.
The new toaster in the block, fastest, toughest and nothing but awesome.
Water resistance to 50 meteres. A new lightning-fast toasting capability. Full of features that help you stay full and motivated.
Buy NowTrump boys' new Toastparent a life changing experience
Our engineers design the glass to withstand extream heat. WiFi capability also available for the base model. Download our App at Goolge Play store & Apple app store.
Built-in Wi-lan. fire resistance up to 500 degree celsius. A new lightning-fast toasting capability. And transparent. Full of features that help you stay full and motivated, Toastparent is designed for all the ways you move.
8 x 6.5 x 11 inches
404 gram
Thermal Protection Glass
Built-in
Minimum 500W; Maximum 2000W
Thermal Protection
WiFi; Any Apple and Android devices
Toastparent
1 year Warranty
Guide book


SAS Kernel for Jupyter
What is this?
A SAS Kernel for Jupyter Notebooks
Dependencies
- Python3.X
- Jupyter
- SAS 9.4 or higher -- This includes SAS Viya
- Linux OS
With the latest changes in saspy it is no longer a requirement that Jupyter and SAS be installed on the same machine. SAS and Jupyter can now communicate via passwordless ssh. This is in response to issue 11. The configuration details are located in sascfg.py
Install
To successfully use the SAS Kernel you must have each of the following:
- SAS version 9.4 or above
-
Jupyter
- Jupyter has a number of dependencies. See the subsections for steps on installing Jupyter on your system.
- Python 3
Install for Anaconda Python (assuming SAS already installed)
-
Download and install Anaconda Python (make sure you get Python3.X). If you install Anaconda without super user rights (root or sudo) then other users on the system will not be able to access the SAS kernel.
A couple notes that I've observed:
- The default install location is the users home directory. This is fine for a single user install I would put it in a common location (
/opt
) if you're doing a system wide install - One of the prompts is to add the path to your environment. I recommend you want to answer 'yes' to that question so that all the installing user has the executables in their path. If you're doing a system wide install (root or sudo) all the other users should add that path to their environmental variables
- The default install location is the users home directory. This is fine for a single user install I would put it in a common location (
-
Install sas_kernel. The sas_kernel has a dependency on saspy which is located here. In the command below I'm assuming that
pip
maps to python3 if that is not the case the you might need to usepip3
instead.pip install sas_kernel
-
Verify that the sas_kernel is installed
jupyter kernelspec list
If you installed as a superuser, your output should similar to this:
Available kernels: python3 /opt/Anaconda3-2.5.0/lib/python3.5/site-packages/ipykernel/resources sas /usr/local/share/jupyter/kernels/sas
If you installed as a regular user (sas in this case), your output should similar to this:
Available kernels: python3 /home/sas/anaconda3/lib/python3.5/site-packages/ipykernel/resources sas /home/sas/.local/share/jupyter/kernels/sas
- Verify SAS Executable is correct
- find the sascfg.py file -- it is currently located in the install location (see above)
[install location]/site-packages/saspy/sascfg.py
This command will search the OS for the file location:find / -name sascfg.py
- edit the file with the correct path the SAS executable and include any options you wish it include in the SAS invocation. See examples in the file
- find the sascfg.py file -- it is currently located in the install location (see above)
Install for Centos 6 (assuming SAS already installed)
These instructions assume you'll be installed system wide for all users using a superuser account (root or sudo)
-
yum packages
sudo yum install https://centos6.iuscommunity.org/ius-release.rpm sudo yum install python35u gcc-c++ python35u-devel python35u-pip python35u-tools
-
pip
wget https://bootstrap.pypa.io/get-pip.py python3.5 get-pip.py pip3 --version
-
jupyter and sas_kernel. The sas_kernel has a dependency on saspy which is located here.
pip3.5 install jupyter pip3.5 install sas_kernel
-
Verify that the sas_kernel is installed
jupyter kernelspec list
This should produce output similar to this:
Available kernels: python3 /usr/lib/python3.5/site-packages/ipykernel/resources sas /usr/local/share/jupyter/kernels/sas
-
Verify SAS Executable is correct
- find the sascfg.py file -- it is currently located in the site-packages area of python install
find / -name sascfg.py
- edit the file with the correct path the SAS executable and include any options you wish it include in the SAS invocation. See examples in the file
- find the sascfg.py file -- it is currently located in the site-packages area of python install
Improving Usability
There are a few NBExtensions that have been created to make working with Jupyter notebooks more productive. These are largely the result of pain points from my use of SAS Kernel for programming tasks. The extensions can be found here. The list includes:
- SAS Log -- which show the SAS log for the last executed cell or the entire log since the last (re)start of the notebook
- themes -- this allows you to change the color scheme for your code to match the traditional SAS color scheme
Installing the SAS Extensions
Details for installing the extensions for SAS can be found here The install experience was improved with version 1.2
Jupyter Magics for the sas_kernel
There are magics that have been written specifically for the sas_kernel to get more details see the README
Jupyterhub
The SAS kernel can be used with JupyterHub for more information look here
NBGrader
nbgrader is a system for assigning and grading notebooks and extends jupyter. I have a number of contributions that I'm currently working on in conjunction with teaching SAS programming in a classroom setting. You can see my forked repo here
FAQ
-
Is there a SAS Magic that I can access from a python kernel?
Yes! There are actually several cell magics available from SAS. They are
%%SAS
,%%IML
, and%%OPTMODEL
. To load these magics in your notebook, execute the following command%load_ext saspy.sas_magic
. You can check that the magics have are successfully activated by looking at the results of%lsmagic
and looking in the cell magic section. If you use multiple SAS Cell magics in the same notebook they will share a SAS session (have the same WORK libname and MACROS). There is currently no sharing of SAS Sessions between different notebooks. -
Do I need to buy SAS to use this kernel?
The SAS Kernel is simply a gateway for Jupyter notebooks to talk to SAS, as such, if SAS is not installed this kernel won't be that helpful. For information on purchasing SAS click here
-
How does Jupyter communicate with SAS?
Behind a Jupyter notebook is a python session, that python session submits code to SAS and receives responses through socket i/o (leveraging stdin , stdout, and stderr) which has been supported in SAS for a long time
-
If stdin, stdout, and stderr have been supported for so long why do I need to have SAS 9.4 or newer?
First, SAS 9.4 was released in July 2013 so it isn't exactly a bleeding edge requirement. The reason for a prerequisite for SAS 9.4 is because that was the first release that supported the creation of HTML5 documents and that is the returned output so that we can render attractive tables and graphs automagically
-
How can I see my SAS log, I only see the listing output?
SAS is different from many other programming languages in that it has two useful information streams, the log (which details the technical details of what happened and how long it took) and the lst (which includes the tables and graphics from the analysis). The SAS Kernel attempts to show you I think you want. Here are the rules:
LOG LST DISPLAYED NOTES Yes No LOG This happens when you run DATA Step or a PROC with the noprint
optionYes Yes LST --- Yes (with ERROR message(s)) Yes ERROR messages with context from the log, then the listing output --- Yes (with ERROR message(s)) No LOG --- If you want to see the log but it was not displayed you can use SASLog NBExtension which will show the log for the last executed cell or the entire log since the last (re)start of the notebook
-
Will this leave a bunch of SAS sessions hanging around?
A SAS session is started for each notebook you have open i.e. 5 notebooks open = 5 SAS sessions. Those sessions will remain active for the life of the notebook. If you shutdown your notebook, the SAS session will also terminate. In Jupyterhub, there are configuration options to shutdown inactive sessions and the SAS kernel complies with those directives.
-
I restarted my SAS Kernel and now my WORK library is now empty. What happened?
When you restart the kernel in a notebook you are terminating the current SAS session and starting a new one. All of the temporary artifacts, data sets in the WORK library, assigned libnames, filename, WORK macros, and so on are destroyed.


| 91 different keyphrases | Search | Percent |
| connor-davidson resilience scale | 27 | 14.8 % |
| connor davidson resilience scale | 17 | 9.3 % |
| www.cd-risc.com | 7 | 3.8 % |
| cd-risc | 7 | 3.8 % |
| connor davidson resilience | 6 | 3.2 % |
| connor-davidson resilience scale free download | 4 | 2.1 % |
| connor davidson full users guide | 4 | 2.1 % |
| cd-risc.com | 4 | 2.1 % |
| connordavidson-resiliencescale.com | 3 | 1.6 % |
| connor-davidson resilience scale scoring | 3 | 1.6 % |
| connor davidson resilience scale items | 3 | 1.6 % |
| connor resilience scale | 2 | 1 % |
| connor davidson user guide | 2 | 1 % |
| the connor davidson resilience scale | 2 | 1 % |
| connor–davidson resilience scale | 2 | 1 % |
| the connor-davidson resilience scale | 2 | 1 % |
| personal resilience scale | 2 | 1 % |
| user guide cd-risc | 2 | 1 % |
| connor davidson resiliencescale. | 2 | 1 % |
| connor davidson resilience scale download | 2 | 1 % |
| cd-risc 10 items | 2 | 1 % |
| connor-davidson resillience scale cd-risc | 2 | 1 % |
| 25 item cd-risc | 2 | 1 % |
| cdrisc | 2 | 1 % |
| connor davidson resilience scale users guide | 2 | 1 % |
| connor-davidson resilience scale questionnaire | 2 | 1 % |
| connor-davidson resilience scale 2003 | 2 | 1 % |
| singh k yu xn. psychometric evaluation of the connor - davidson resilience scale cd-risc in a sample of indian students | 2 | 1 % |
| cd-risc 10 scale | 1 | 0.5 % |
| french version resilience scale | 1 | 0.5 % |
| 25 item cd-risc scale | 1 | 0.5 % |
| where can i find connor davidson resilience scale | 1 | 0.5 % |
| corner-davidson resilience | 1 | 0.5 % |
| cd-risc resilience | 1 | 0.5 % |
| connor-davidson resilience scale where to get | 1 | 0.5 % |
| cd-risc in general population | 1 | 0.5 % |
| connor-davidson resilience scale copyright | 1 | 0.5 % |
| 25-item connor-davidson resilience scale cd-risc | 1 | 0.5 % |
| resilience scale validy for cd-risc | 1 | 0.5 % |
| cd risc rothbaum 2008 | 1 | 0.5 % |
| items on connor davidson resilience scale | 1 | 0.5 % |
| connor davidson | 1 | 0.5 % |
| cd risc 10 | 1 | 0.5 % |
| connor-davidson resilience scale 10 item scoring | 1 | 0.5 % |
| connor davidson scale of resilience | 1 | 0.5 % |
| full thesis adult resilience measurement gradworks pdf | 1 | 0.5 % |
| cd-risc languages | 1 | 0.5 % |
| resilience scale user s guide | 1 | 0.5 % |
| scoring of connor davidson | 1 | 0.5 % |
| obtain cd-risc | 1 | 0.5 % |
| dr davidson resilience scale | 1 | 0.5 % |
| premission to use the connor-davidson resilience scale cd-risc | 1 | 0.5 % |
| resilience full scales with their items | 1 | 0.5 % |
| what does the connor-davidson resilience scale measure? | 1 | 0.5 % |
| cd risc user guide | 1 | 0.5 % |
| connor davidson resilience scale online | 1 | 0.5 % |
| cd-risc scale dutch version | 1 | 0.5 % |
| cd-risc manual | 1 | 0.5 % |
| administering the cd-risc | 1 | 0.5 % |
| coonor- davidson resiliency scale | 1 | 0.5 % |
| connor-davidson resilience scales | 1 | 0.5 % |
| resiliance scales | 1 | 0.5 % |
| connor-davidson resilience scale cd-risc nederlands | 1 | 0.5 % |
| resilience scales | 1 | 0.5 % |
| connor davidson resilience scale questionnaire | 1 | 0.5 % |
| download the connor-davidson resilience scale cd-risc | 1 | 0.5 % |
| resilience cd risc | 1 | 0.5 % |
| connor davidson resileince scale in atheltes | 1 | 0.5 % |
| connor davidson resilience scale deutsch | 1 | 0.5 % |
| cd risc permission | 1 | 0.5 % |
| cd-rsic.com | 1 | 0.5 % |
| connor-davidson resilance scale | 1 | 0.5 % |
| connor davidson resilience scale buy | 1 | 0.5 % |
| item conor davidson | 1 | 0.5 % |
| risc table | 1 | 0.5 % |
| resilience scale | 1 | 0.5 % |
| davidson-connor resilience scoring | 1 | 0.5 % |
| jonathan davidson cd-risc | 1 | 0.5 % |
| • connor davidson resilience scale cd-risc 10 | 1 | 0.5 % |
| connor and davidson resilience scale | 1 | 0.5 % |
| connor-davidson resilience scale and french and translation | 1 | 0.5 % |
| connor davidson resilience scale questions | 1 | 0.5 % |
| connor-davidson resilience | 1 | 0.5 % |
| connor davidson resilience scale purchase | 1 | 0.5 % |
| cd risc 25 validity | 1 | 0.5 % |
| depression and anxiety connor & davidson 2003 | 1 | 0.5 % |
| conor davidson resilience scale 2003 | 1 | 0.5 % |
| connor davidson resillience scale | 1 | 0.5 % |
| cd risc scale 10 | 1 | 0.5 % |
| cd-risc2 questionnaire | 1 | 0.5 % |
| 10-item connor-davidson resilience scale cd-risc; connor & davidson 2003 | 1 | 0.5 % |


So, I was lucky enough to get to visit with my digital friend @brianturner. He’s no longer just my digital friend, but he’s my terrestrial buddy now as well. I used to be fit and a wrestler, but over the years, and especialy with parenthood I haven’t been as active. I’ve started swimming to lose some weight, but I think I want to get into some weights too. Especially as I’m trying to work out PAL-Studios (still in some legal and financial discussions) I figure it’s better to be thinner.
So, when I came out to San Diego and found out that Brian is nearby we connected. He took me to a gym. I took him out to lunch. He spoke athletics for my channel, and we took some footage of us talking crypto for his channel.
It feels like an equivalent exchange.
Here we are meeting up before the workout!
Here I film him doing a quick tour of the workout that we did.
Brian looked fit online. Dude is pretty jacked in person. Not only that, but he’s an excellent dude. If you’re looking for fitness advice, vegan living, acne treatment, intro to crypto, or just a good dude then I hope you choose to follow his channel on Steemit.com @brianturner or on youtube at https://www.youtube.com/channel/UC2ycqdFV0EmY5LmfM9mWkQg.
This page is synchronized from the post: ‘Working out with @brianturner in San Diego’


[§480B-1] General definitions. As used in this chapter:
"Media" means any printed publication of general distribution in the State issued once or more per year that is a party to the Mutual Publishing Plan Agreement as executed on May 31, 1962, and any subsequent amendments. [L 1995, c 243, pt of §2]


Search for nodes by {{searchOption}}
Search
Toggle Dropdown
Search by {{item}}
Search results
NodeID
Address
Name
Profile
{{item.NodeID}}
{{item.DeviceID}}
{{item.NodeName}}
Link


[]. OpenUrl vol. no. pp. intra-host SNVs CrossRef viral genomic genome Figure recombination SARS-CoV- Abstract FREE Science Text frequency RNA SRR >; coronavirus sample strain variants corresponding samples variations Web molecular respiratory using Intra-host diagnostics epidemic Writing alignment events gene human new observed probe NGS ORFa, View assays compared contigs genes host isolated novel novo outbreak polymorphic potential read red reference reported syndrome variability (-.)., Coronavirus Download ORF ORF, ORFab SRR, Table Virol., acute analysed assembled cases colocalized currently data depth diversity domain emerging evolution gene. higher infection located majority missense population primer quasispecies reaction region regions respect review v/kbgl), variant vs. &; (A) (orange -nCoV-N ./jvi.-. Apr. East HIV- Human Intra Jan. Microbiol., Middle N-terminal Res., SARS-CoV SNV Suppl. [[#x]] ]–[ affected allowing analysis assembly bases derived design editing. frequencies genome, genome. genomes green high hosts indicated infected lines) low low-frequency patients poly-A primers probes reads rearrangement rearrangements rearrangements, revealed secondary sensitivity sequencing severe spike study subunit supported targets triangles), vaccine viruses


| Class and Description |
|---|
| ExternalUserVO
A value object representing a User retrieved from an external repository like LDAP.
|
| Class and Description |
|---|
| UserDao |
| Class and Description |
|---|
| ExternalUserVO
A value object representing a User retrieved from an external repository like LDAP.
|
| Class and Description |
|---|
| UserProfileVO |
| Class and Description |
|---|
| ExternalUserVO
A value object representing a User retrieved from an external repository like LDAP.
|
| Class and Description |
|---|
| ExternalUserVO
A value object representing a User retrieved from an external repository like LDAP.
|
| Class and Description |
|---|
| UserDao |
| Class and Description |
|---|
| ExternalUserVO
A value object representing a User retrieved from an external repository like LDAP.
|
| Class and Description |
|---|
| ExternalUserVO
A value object representing a User retrieved from an external repository like LDAP.
|
| InvitationField
Abstraction for invitation fields.
|
| Class and Description |
|---|
| ExternalUserVO
A value object representing a User retrieved from an external repository like LDAP.
|
| InvitationField
Abstraction for invitation fields.
|
| Class and Description |
|---|
| InvitationField
Abstraction for invitation fields.
|
| Class and Description |
|---|
| ExternalUserVO
A value object representing a User retrieved from an external repository like LDAP.
|
| InvitationField
Abstraction for invitation fields.
|
| Class and Description |
|---|
| ContactDao |
| ExternalUserVO
A value object representing a User retrieved from an external repository like LDAP.
|
| NotificationConfigDao |
| UserDao |
| UserImageDao |
| UserProfileDao |
| UserProfileVO |
| Class and Description |
|---|
| UserDao |
| Class and Description |
|---|
| UserDao |
| Class and Description |
|---|
| CommunoteEntityDao |
| CommunoteEntityDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
com.communote.server.persistence.user.KenmeiEntity . |
| ContactDao |
| ContactDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
com.communote.server.persistence.user.Contact . |
| CountryDao |
| CountryDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
com.communote.server.persistence.user.Country . |
| ExternalUserAuthenticationDao |
| ExternalUserAuthenticationDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
com.communote.server.persistence.user.ExternalUserAuthentication . |
| InvitationField
Abstraction for invitation fields.
|
| InviteUserForm
Form for an user invitation
|
| LanguageDao |
| LanguageDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
com.communote.server.persistence.user.Language . |
| NavigationItemDao |
| NotificationConfigDao |
| NotificationConfigDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
com.communote.server.persistence.user.NotificationConfig . |
| UserAuthorityDao |
| UserAuthorityDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
UserAuthority . |
| UserDao |
| UserDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
com.communote.server.persistence.user.KenmeiUser . |
| UserImageDao |
| UserImageDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
com.communote.server.persistence.user.UserImage . |
| UserNotePropertyDao |
| UserNotePropertyDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
UserNoteProperty . |
| UserProfileDao |
| UserProfileDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
com.communote.server.persistence.user.KenmeiUserProfile . |
| UserProfileVO |
| UserPropertyDao |
| UserPropertyDaoBase
Base Spring DAO Class: is able to create, update, remove, load, and find objects of type
UserProperty . |
| Class and Description |
|---|
| InvitationField
Abstraction for invitation fields.
|
| InviteUserForm
Form for an user invitation
|
| Class and Description |
|---|
| InviteUserForm
Form for an user invitation
|
| Class and Description |
|---|
| InviteUserForm
Form for an user invitation
|
| Class and Description |
|---|
| InviteUserForm
Form for an user invitation
|
| Class and Description |
|---|
| UserProfileVO |
Copyright © 2019 Communote team. All rights reserved.


In the second example, which is a variation on the first, consider the idea of a school board. In the school board there are 5 schools, each having 10 classrooms with a capacity of 20 students. This school board can accommodate a maximum of 5*10*20 = 1,000 students.
In this case, we would like to work with student records based on three factors: the SCHOOL_ID, the CLASS_ID, and the STUDENT_NUM values. Each of these three columns will have unique values and will be used together to add, update, and delete student records.
Note: As with the previous example, other indices may be added separately and at some other time.


Oxygen is quickly dwindling. Need replenishing.
Oxygen in the ship is at a critical level. If oxygen is not replenished soon, cognitive function for the remaining crew members will significantly decline! Let’s take a look at the Oxygen panel:
The goal is to figure out the correct arrangement of oxygen atoms.
Rules
- The carbon atoms are represented in black and oxygen atoms in blue
- Oxygen atoms cannot be adjacent to each other, even diagonally.
- Numbers next to rows and columns tell how many oxygens should be in them.
- Each carbon atom needs 2 adjacent oxygens
- Utilize any number of oxygens as required
- Rotate the oxygen to attach
- Identify the location of oxygen atoms
If we look carefully enough, we may see the letters for two atomic symbols! Put them together to create the compound, and remember them as the keywords for this puzzle.


Brief
SoftBank Looking to Reduce $3 Billion WeWork Rescue Offer, Report Says
The plan is intended to limit the $1.7 billion bailout payment offered to former CEO Adam Neumann, Bloomberg reported Friday
by CTechJapanese holding company SoftBank is looking to reduce the $3 billion rescue offer it recently made for shares of struggling coworking company WeWork, Bloomberg reported Friday. Citing people familiar with the matter who spoke on condition of anonymity, Bloomberg said the move is intended to limit the $1.7 billion bailout payment offered to former CEO Adam Neumann.
On Thursday, Calcalist reported WeWork intends to fire several dozen employees at its research and development center in Israel, as part of a massive global streamlining process that would see thousands of people looking for new jobs.


Word Cloud-Twitter Data
This is a word cloud of the tweets collected using
gun violence
> as keyword(s)


Appraisal gives stakeholders an opportunity to review the project concept and design in detail, make sure project is commercially and technically feasible and it complies with government regulations. A critical assessment of interested projects would be executed by Queens Mount Consulting to ensure the project is legally and technically feasible as well as economically justifiable.
Queens Mount Consulting methodology covers a historical background of the business or project, such as a description of the product or service, accounting statements, details of operations and management, marketing research and policies, financial data, government & legal requirements, and tax obligations.
Our experts evaluate the project’s potential for success; therefore, perceived objectivity is an essential factor in the credibility of the study for potential investors and lending institutions. We conduct five types of feasibility study, separate areas that a feasibility study examines.
This assessment focuses on the technical resources available to the organization. It helps organizations determine whether the technical resources meet capacity and whether the technical team is capable of converting the ideas into working systems.
This assessment typically involves a cost/ benefits analysis of the project, helping organizations determine the viability, cost, and benefits associated with a project before financial resources are allocated.
This assessment investigates whether any aspect of the proposed project conflicts with regulatory & legal requirements like zoning laws, protection acts or social laws. Let’s say an organization wants to construct a new office building in a specific location. A feasibility study might reveal the ideal location according to the zone for that type of business.
This assessment involves undertaking a study to analyze and determine whether and how well the organization’s needs can be met by completing the project.
This assessment is the most important for project success. A project will fail if not completed on time. In scheduling feasibility, an organization estimates how much time the project will take to complete.


vue-headful Demo
You need to enable JavaScript.
Clone the repository
Run
npm run dev
Open
localhost:4000
in a browser
Open the source code (empty title, description, ...)
Open the developer console and inspect the source there (populated title, description, ...)


Articles
-
20 Feb 2020
Welcome to Jekyll!
You’ll find this post in your _posts directory. Go ahead and edit it and re-build the site to see your changes. You c...
-
15 Dec 2014
Example Post Formatting
This is a post description for meta purposes. This is also the excerpt of the article that shows up on the index/home...
-
14 Dec 2014
Featured Image
Lorem ipsum thor smash liege-bastogne-liege landbouwkrediet ombregt krabbe, rouleur derby is for lovers bonk giro gil...
-
13 Dec 2014
Post With A Code Snippet
You'll find this post in your `_posts` directory - edit this post and re-build (or run with the `-w` switch) to see y...
-
12 Dec 2014
Figure With A Caption
Lorem ipsum thor smash liege-bastogne-liege landbouwkrediet ombregt krabbe, rouleur derby is for lovers bonk giro gil...
-
11 Dec 2014
Image in Post
Lorem ipsum thor smash liege-bastogne-liege landbouwkrediet ombregt krabbe, rouleur derby is for lovers bonk giro gil...
-
10 Dec 2014
Test Post
Lorem ipsum thor smash liege-bastogne-liege landbouwkrediet ombregt krabbe, rouleur derby is for lovers bonk giro gil...


Incoming Summer Analyst
Software Engineer Intern
A delightful web app to track shuttle buses in National University of Singapore.
Bachelor of Engineering, Computer Engineering


{% extends "profiles/profile_base.html" %} {% block stats_selected %}current{% endblock %} {% block profile_content %}
{% blocktrans with since=user.date_joined|timesince %}You've been a FeedHQ user for {{ since }}.{% endblocktrans %}


{% endblock %}
{% block javascript %}
{% comment %}
Add two buttons (delete/add) to the inlineformset.
This allows to add occurence of a sanction
{% endcomment %}
{% comment %}
Show sanction form element if selector changed.
By default the selector is on "no sanction" and consequently sanction form elements are hidden
{% endcomment %}
{% comment %}
To style only selects with the selectpicker class
{% endcomment %}
{% endblock javascript %}


Note that some spoofing techniques may not be effective until clients reload their cache.
Also note that when exiting spoofing, ensure that clients will still have a route for traffic (otherwise there will be a DoS)
Always try to specifically target clients on a network by using MAC or IP address. The louder you are, the more likely you are to be detected. A computer is not necessarily faster than a dedicated routing/switching device.
It will almost always be usefil to log to a pcap or capture traffic another way in order to troubleshoot or examine if attacks were carried out correctly.


tl;dr: You are in control of your data. We will not share, sell or disseminate it in any way other than those available through Stat Tracker.
Stat Tracker is a service provided with NO WARRANTY OR GUARANTEE.
The data your submit to Stat Tracker is owned by you. You can have it removed at any time.
We are not responsible for any unauthorized access to the data stored in Stat Tracker, and will make all reasonable efforts to keep it from being accessed by unauthorized parties.
Contact: stats@BlueHeronsResistance.com


We examine platforms!
- evolve out-of-the-box communities
- recontextualize leading-edge networks
- engage visionary channels
- enable plug-and-play e-tailers
- optimize value-added web services
- revolutionize extensible e-markets
- engage scalable convergence
- redefine world-class deliverables
- evolve impactful partnerships


Survey Questions
About You
Name:
Link to Photo Image
Question 1
Your mind is always buzzing with unexplored ideas and plans.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Question 2
Generally speaking, you rely more on your experience than your imagination.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Question 3
QYou find it easy to stay relaxed and focused even when there is some pressure.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Question 4
You rarely do something just out of sheer curiosity.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Question 5
People can rarely upset you.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Question 6
It is often difficult for you to relate to other people’s feelings.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Question 7
In a discussion, truth should be more important than people’s sensitivities.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Question 8
You rarely get carried away by fantasies and ideas.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Question 9
You think that everyone’s views should be respected regardless of whether they are supported by facts or not.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Question 10
You feel more energetic after spending time with a group of people.
1 Strongly Disagree
2
3
4
5 Strongly Agree
Text
Best Match


JavaScript String Methods
If the separator is "", the returned array will be an array of single characters:


--- layout: post authors: ["John Blischak"] title: "Summary of March 2014 Meeting to Discuss Novice R Material" date: 2014-04-04 time: "17:00:00" tags: ["Community"] ---
Last week we had our first meeting to discuss the development of the novice R material. Our goal was to determine our plan for collaboratively creating the lessons.
We have already taught many R bootcamps. However, since there is no canoncial set of SWC lessons, SWC R instructors have been independently developing separate sets of lessons. Great material has been developed, but organizing and teaching a bootcamp is already a lot of work without also having to develop the curriculum. Furthermore, this approach divides our contributions leading to lots of duplicated effort. Ideally we would all contribute to the same lessons to create a better result than any of us could have acheived individually. However, this state of affairs was not surprising since collaborative lesson development is still immature.
Thus we had four main options to choose from:
Option #1 requires a lot of effort from the original creator of the materials since she or he is the most familiar with the state of the material (as an example, this is the option we chose for the intermediate R lessons, with Karthik Ram not only developing the materials but also updating them after others reviewed each lesson). Option #2 has the benefit of combining the best parts of multiple sets of bootcamp lessons, but the big drawback is that it would require volunteers becoming familiar with the content of the multiple sets of lessons. Option #3 aligns the Python and R materials, but also presents the challenge of introducing R-specific control flow and data structures within a lesson originally developed for Python. Option #4 is the most open-ended option, but also requires the most work.
We decided on Option #3, translating the novice Python lessons to R. This allows the SWC R community to benefit from the recent discussion around creating novice Python material (and of course hopefully allow us to contribute back our findings from teaching these lessons at bootcamps to improve both the R and Python lessons). Here is our plan:
Between each round of edits, everyone will be able to contribute comments/suggestions to the pull requests.
There are lots of ways you can get involved in the development of the novice R material, including:


Inline elements
SPAN (no margin, padding or border)
This is the element
Computed styles
SPAN (20px padding)
This is the element
Computed styles
SPAN (20px padding, 10px margin)
This is the element
Computed styles
SPAN (20px padding, 10px margin, 2px border)
This is the element
Computed styles
inline-block elements
SPAN (no margin, padding or border)
This is the element
Computed styles
SPAN (20px padding)
This is the element
Computed styles
SPAN (20px padding, 10px margin)
This is the element
Computed styles
SPAN (20px padding, 10px margin, 2px border)
This is the element
Computed styles