4 writes to ApartmentState
Microsoft.PowerShell.ConsoleHost (1)
host\msh\ConsoleHost.cs (1)
1736
runspace.
ApartmentState
= ApartmentState.STA;
System.Management.Automation (3)
engine\hostifaces\ConnectionBase.cs (2)
80
this.
ApartmentState
= initialSessionState.ApartmentState;
126
this.
ApartmentState
= initialSessionState.ApartmentState;
engine\hostifaces\RunspacePoolInternal.cs (1)
1258
result.
ApartmentState
= this.ApartmentState;
10 references to ApartmentState
System.Management.Automation (10)
engine\hostifaces\Connection.cs (1)
585
internal const ApartmentState DefaultApartmentState =
ApartmentState
.Unknown;
engine\hostifaces\ConnectionBase.cs (1)
918
if (runningPipelines.Length > 1 && Thread.CurrentThread.GetApartmentState() ==
ApartmentState
.STA)
engine\hostifaces\LocalConnection.cs (3)
172
return options == PSThreadOptions.ReuseThread && this.
ApartmentState
!=
ApartmentState
.STA;
773
_pipelineThread = new PipelineThread(this.
ApartmentState
);
engine\hostifaces\LocalPipeline.cs (1)
188
apartmentState = this.LocalRunspace.
ApartmentState
; // use the Runspace apartment state
engine\hostifaces\PowerShell.cs (2)
4578
VerifyThreadSettings(settings, rsToUse.
ApartmentState
, rsToUse.ThreadOptions, false);
4924
VerifyThreadSettings(settings, rs.
ApartmentState
, rs.ThreadOptions, false);
engine\remoting\client\remoterunspace.cs (1)
551
RunspacePool.ApartmentState = this.
ApartmentState
;
engine\remoting\server\ServerRunspacePoolDriver.cs (1)
536
args.Runspace.
ApartmentState
,


prefix=$(git rev-parse --show-prefix) cd "$(git rev-parse --show-toplevel)" eval "set -- $(git rev-parse --sq --prefix "$prefix" "$@")"
git-rev-parse(1) Manual Page
NAME
git-rev-parse - Pick out and massage parameters
SYNOPSIS
git rev-parse [ --option ] <args>...
DESCRIPTION
Many Git porcelainish commands take mixture of flags (i.e. parameters that begin with a dash -) and parameters meant for the underlying git rev-list command they use internally and flags and parameters for the other commands they use downstream of git rev-list. This command is used to distinguish between them.
OPTIONS
Operation Modes
Each of these options must appear first on the command line.
- --parseopt
Use git rev-parse in option parsing mode (see PARSEOPT section below).
- --sq-quote
Use git rev-parse in shell quoting mode (see SQ-QUOTE section below). In contrast to the --sq option below, this mode does only quoting. Nothing else is done to command input.
Options for --parseopt
- --keep-dashdash
Only meaningful in --parseopt mode. Tells the option parser to echo out the first -- met instead of skipping it.
- --stop-at-non-option
Only meaningful in --parseopt mode. Lets the option parser stop at the first non-option argument. This can be used to parse sub-commands that take options themselves.
Options for Filtering
- --revs-only
Do not output flags and parameters not meant for git rev-list command.
- --no-revs
Do not output flags and parameters meant for git rev-list command.
- --flags
Do not output non-flag parameters.
- --no-flags
Do not output flag parameters.
Options for Output
- --default <arg>
If there is no parameter given by the user, use <arg> instead.
- --prefix <arg>
Behave as if git rev-parse was invoked from the <arg> subdirectory of the working tree. Any relative filenames are resolved as if they are prefixed by <arg> and will be printed in that form.
This can be used to convert arguments to a command run in a subdirectory so that they can still be used after moving to the top-level of the repository. For example:
- --verify
Verify that exactly one parameter is provided, and that it can be turned into a raw 20-byte SHA-1 that can be used to access the object database. If so, emit it to the standard output; otherwise, error out.
If you want to make sure that the output actually names an object in your object database and/or can be used as a specific type of object you require, you can add "^{type}" peeling operator to the parameter. For example, git rev-parse "$VAR^{commit}" will make sure $VAR names an existing object that is a commit-ish (i.e. a commit, or an annotated tag that points at a commit). To make sure that $VAR names an existing object of any type, git rev-parse "$VAR^{object}" can be used.
- -q
- --quiet
Only meaningful in --verify mode. Do not output an error message if the first argument is not a valid object name; instead exit with non-zero status silently.
- --sq
Usually the output is made one line per flag and parameter. This option makes output a single line, properly quoted for consumption by shell. Useful when you expect your parameter to contain whitespaces and newlines (e.g. when using pickaxe -S with git diff-*). In contrast to the --sq-quote option, the command input is still interpreted as usual.
- --not
When showing object names, prefix them with ^ and strip ^ prefix from the object names that already have one.
- --abbrev-ref[=(strict|loose)]
A non-ambiguous short name of the objects name. The option core.warnAmbiguousRefs is used to select the strict abbreviation mode.
- --short
- --short=number
Instead of outputting the full SHA-1 values of object names try to abbreviate them to a shorter unique name. When no length is specified 7 is used. The minimum length is 4.
- --symbolic
Usually the object names are output in SHA-1 form (with possible ^ prefix); this option makes them output in a form as close to the original input as possible.
- --symbolic-full-name
This is similar to --symbolic, but it omits input that are not refs (i.e. branch or tag names; or more explicitly disambiguating "heads/master" form, when you want to name the "master" branch when there is an unfortunately named tag "master"), and show them as full refnames (e.g. "refs/heads/master").
Options for Objects
- --all
Show all refs found in refs/.
- --branches[=pattern]
- --tags[=pattern]
- --remotes[=pattern]
Show all branches, tags, or remote-tracking branches, respectively (i.e., refs found in refs/heads, refs/tags, or refs/remotes, respectively).
If a pattern is given, only refs matching the given shell glob are shown. If the pattern does not contain a globbing character (?, *, or [), it is turned into a prefix match by appending /*.
- --glob=pattern
Show all refs matching the shell glob pattern pattern. If the pattern does not start with refs/, this is automatically prepended. If the pattern does not contain a globbing character (?, *, or [), it is turned into a prefix match by appending /*.
- --disambiguate=<prefix>
Show every object whose name begins with the given prefix. The <prefix> must be at least 4 hexadecimal digits long to avoid listing each and every object in the repository by mistake.
Options for Files
- --local-env-vars
List the GIT_* environment variables that are local to the repository (e.g. GIT_DIR or GIT_WORK_TREE, but not GIT_EDITOR). Only the names of the variables are listed, not their value, even if they are set.
- --git-dir
Show $GIT_DIR if defined. Otherwise show the path to the .git directory. The path shown, when relative, is relative to the current working directory.
If $GIT_DIR is not defined and the current directory is not detected to lie in a Git repository or work tree print a message to stderr and exit with nonzero status.
- --is-inside-git-dir
When the current working directory is below the repository directory print "true", otherwise "false".
- --is-inside-work-tree
When the current working directory is inside the work tree of the repository print "true", otherwise "false".
- --is-bare-repository
When the repository is bare print "true", otherwise "false".
- --resolve-git-dir <path>
Check if <path> is a valid repository or a gitfile that points at a valid repository, and print the location of the repository. If <path> is a gitfile then the resolved path to the real repository is printed.
- --show-cdup
When the command is invoked from a subdirectory, show the path of the top-level directory relative to the current directory (typically a sequence of "../", or an empty string).
- --show-prefix
When the command is invoked from a subdirectory, show the path of the current directory relative to the top-level directory.
- --show-toplevel
Show the absolute path of the top-level directory.
Other Options
- --since=datestring
- --after=datestring
Parse the date string, and output the corresponding --max-age= parameter for git rev-list.
- --until=datestring
- --before=datestring
Parse the date string, and output the corresponding --min-age= parameter for git rev-list.
- <args>...
Flags and parameters to be parsed.
SPECIFYING REVISIONS
A revision parameter <rev> typically, but not necessarily, names a commit object. It uses what is called an extended SHA-1 syntax. Here are various ways to spell object names. The ones listed near the end of this list name trees and blobs contained in a commit.
- <sha1>, e.g. dae86e1950b1277e545cee180551750029cfe735, dae86e
The full SHA-1 object name (40-byte hexadecimal string), or a leading substring that is unique within the repository.  If you happen to have both heads/master and tags/master, you can explicitly say heads/master to tell Git which one you mean. When ambiguous, a <refname> is disambiguated by taking the first match in the following rules:
If $GIT_DIR/<refname> exists, that is what you mean (this is usually useful only for HEAD, FETCH_HEAD, ORIG_HEAD, MERGE_HEAD and CHERRY_PICK_HEAD);
otherwise, refs/<refname> if it exists;
otherwise, refs/tags/<refname> if it exists;
otherwise, refs/heads/<refname> if it exists;
otherwise, refs/remotes/<refname> if it exists;
otherwise, refs/remotes/<refname>/HEAD if it exists.
HEAD names the commit on which you based the changes in the working tree. FETCH_HEAD records the branch which you fetched from a remote repository with your last git fetch invocation. ORIG_HEAD is created by commands that move your HEAD in a drastic way, to record the position of the HEAD before their operation, so that you can easily change the tip of the branch back to the state before you ran them. MERGE_HEAD records the commit(s) which you are merging into your branch when you run git merge.
Note that any of the refs/* cases above may come either from the $GIT_DIR/refs directory or from the $GIT_DIR/packed-refs file. While the ref name encoding is unspecified, UTF-8 is preferred as some output processing may assume ref names in UTF-8.
- @
@ alone is a shortcut for HEAD.
- <refname>@{<date>}, e.g. master@{yesterday}, HEAD@{5 minutes ago}
A ref followed by the suffix @ with a date specification enclosed in a brace pair (e.g. {yesterday}, {1 month 2 weeks 3 days 1 hour 1 second ago} or {1979-02-26 18:30:00}) specifies the value of the ref at a prior point in time. This suffix may only be used immediately following a ref name and the ref must have an existing log ($GIT_DIR/logs/<ref>). Note that this looks up the state of your local ref at a given time; e.g., what was in your local master branch last week. If you want to look at commits made during certain times, see --since and --until.
- <refname>@{<n>}, e.g. master@{1}
A ref followed by the suffix @ with an ordinal specification enclosed in a brace pair (e.g. {1}, {15}) specifies the n-th prior value of that ref. For example master@{1} is the immediate prior value of master while master@{5} is the 5th prior value of master. This suffix may only be used immediately following a ref name and the ref must have an existing log ($GIT_DIR/logs/<refname>).
- @{<n>}, e.g. @{1}
You can use the @ construct with an empty ref part to get at a reflog entry of the current branch. For example, if you are on branch blabla then @{1} means the same as blabla@{1}.
- @{-<n>}, e.g. @{-1}
The construct @{-<n>} means the <n>th branch checked out before the current one.
- <branchname>@{upstream}, e.g. master@{upstream}, @{u}
The suffix @{upstream} to a branchname (short form <branchname>@{u}) refers to the branch that the branch specified by branchname is set to build on top of. A missing branchname defaults to the current one.
- <rev>^, e.g. HEAD^, v1.5.1^0
A suffix ^ to a revision parameter means the first parent of that commit object. ^<n> means the <n>th parent (i.e. <rev>^ is equivalent to <rev>^1). As a special rule, <rev>^0 means the commit itself and is used when <rev> is the object name of a tag object that refers to a commit object.
- <rev>~<n>, e.g. master~3
A suffix ~<n> to a revision parameter means the commit object that is the <n>th generation ancestor of the named commit object, following only the first parents. I.e. <rev>~3 is equivalent to <rev>^^^ which is equivalent to <rev>^1^1^1. See below for an illustration of the usage of this form.
- <rev>^{<type>}, e.g. v0.99.8^{commit}
A suffix ^ followed by an object type name enclosed in brace pair means dereference the object at <rev> recursively until an object of type <type> is found or the object cannot be dereferenced anymore (in which case, barf). For example, if <rev> is a commit-ish, <rev>^{commit} describes the corresponding commit object. Similarly, if <rev> is a tree-ish, <rev>^{tree} describes the corresponding tree object. <rev>^0 is a short-hand for <rev>^{commit}.
rev^{object} can be used to make sure rev names an object that exists, without requiring rev to be a tag, and without dereferencing rev; because a tag is already an object, it does not have to be dereferenced even once to get to an object.
rev^{tag} can be used to ensure that rev identifies an existing tag object.
- <rev>^{}, e.g. v0.99.8^{}
A suffix ^ followed by an empty brace pair means the object could be a tag, and dereference the tag recursively until a non-tag object is found.
- <rev>^{/<text>}, e.g. HEAD^{/fix nasty bug}
A suffix ^ to a revision parameter, followed by a brace pair that contains a text led by a slash, is the same as the :/fix nasty bug syntax below except that it returns the youngest matching commit which is reachable from the <rev> before ^.
- :/<text>, e.g. :/fix nasty bug
A colon, followed by a slash, followed by a text, names a commit whose commit message matches the specified regular expression. This name returns the youngest matching commit which is reachable from any ref. If the commit message starts with a ! you have to repeat that; the special sequence :/!, followed by something else than !, is reserved for now. The regular expression can match any part of the commit message. To match messages starting with a string, one can use e.g. :/^foo.
- <rev>:<path>, e.g. HEAD:README, :README, master:./README
A suffix : followed by a path names the blob or tree at the given path in the tree-ish object named by the part before the colon. :path (with an empty part before the colon) is a special case of the syntax described next: content recorded in the index at the given path. A path starting with ./ or ../ is relative to the current working directory. The given path will be converted to be relative to the working tree's root directory. This is most useful to address a blob or tree from a commit or tree that has the same tree structure as the working tree.
- :<n>:<path>, e.g. :0:README, :README
A colon, optionally followed by a stage number (0 to 3) and a colon, followed by a path, names a blob object in the index at the given path. A missing stage number (and the colon that follows it) names a stage 0 entry. During a merge, stage 1 is the common ancestor, stage 2 is the target branch's version (typically the current branch), and stage 3 is the version from the branch which is being merged.
Here is an illustration, by Jon Loeliger. Both commit nodes B and C are parents of commit node A. Parent commits are ordered left-to-right.
G H I J \ / \ / D E F \ | / \ \ | / | \|/ | B C \ / \ / A
A = = A^0 B = A^ = A^1 = A~1 C = A^2 = A^2 D = A^^ = A^1^1 = A~2 E = B^2 = A^^2 F = B^3 = A^^3 G = A^^^ = A^1^1^1 = A~3 H = D^2 = B^^2 = A^^^2 = A~2^2 I = F^ = B^3^ = A^^3^ J = F^2 = B^3^2 = A^^3^2
SPECIFYING RANGES
History traversing commands such as git log operate on a set of commits, not just a single commit. To these commands, specifying a single revision with the notation described in the previous section means the set of commits reachable from that commit, following the commit ancestry chain.
To exclude commits reachable from a commit, a prefix ^ notation is used. E.g. ^r1 r2 means commits reachable from r2 but exclude the ones reachable from r1.
This set operation appears so often that there is a shorthand for it. When you have two commits r1 and r2 (named according to the syntax explained in SPECIFYING REVISIONS above), you can ask for commits that are reachable from r2 excluding those that are reachable from r1 by ^r1 r2 and it can be written as r1..r2.
A similar notation r1\...r2 is called symmetric difference of r1 and r2 and is defined as r1 r2 --not $(git merge-base --all r1 r2). It is the set of commits that are reachable from either one of r1 or r2 but not from both.
In these two shorthands, you can omit one end and let it default to HEAD. For example, origin.. is a shorthand for origin..HEAD and asks "What did I do since I forked from the origin branch?" Similarly, ..origin is a shorthand for HEAD..origin and asks "What did the origin do since I forked from them?" Note that .. would mean HEAD..HEAD which is an empty range that is both reachable and unreachable from HEAD.
Two other shorthands for naming a set that is formed by a commit and its parent commits exist. The r1^@ notation means all parents of r1. r1^! includes commit r1 but excludes all of its parents.
To summarize:
- <rev>
Include commits that are reachable from (i.e. ancestors of) <rev>.
- ^<rev>
Exclude commits that are reachable from (i.e. ancestors of) <rev>.
- <rev1>..<rev2>
Include commits that are reachable from <rev2> but exclude those that are reachable from <rev1>. When either <rev1> or <rev2> is omitted, it defaults to HEAD.
- <rev1>\...<rev2>
Include commits that are reachable from either <rev1> or <rev2> but exclude those that are reachable from both. When either <rev1> or <rev2> is omitted, it defaults to HEAD.
- <rev>^@, e.g. HEAD^@
A suffix ^ followed by an at sign is the same as listing all parents of <rev> (meaning, include anything reachable from its parents, but not the commit itself).
- <rev>^!, e.g. HEAD^!
A suffix ^ followed by an exclamation mark is the same as giving commit <rev> and then all its parents prefixed with ^ to exclude them (and their ancestors).
Here are a handful of examples:
D G H D D F G H I J D F ^G D H D ^D B E I J F B B..C C B...C G H D E B C ^D B C E I J F B C C I J F C C^@ I J F C^! C F^! D G H D F
PARSEOPT
In --parseopt mode, git rev-parse helps massaging options to bring to shell scripts the same facilities C builtins have. It works as an option normalizer (e.g. splits single switches aggregate values), a bit like getopt(1) does.
It takes on the standard input the specification of the options to parse and understand, and echoes on the standard output a string suitable for sh(1) eval to replace the arguments with normalized ones. In case of error, it outputs usage on the standard error stream, and exits with code 129.
Note: Make sure you quote the result when passing it to eval. See below for an example.
Input Format
git rev-parse --parseopt input format is fully text based. It has two parts, separated by a line that contains only --. The lines before the separator (should be more than one) are used for the usage. The lines after the separator describe the options.
Each line of options has this format:
<opt_spec><flags>* SP+ help LF
- <opt_spec>
its format is the short option character, then the long option name separated by a comma. Both parts are not required, though at least one is necessary. h,help, dry-run and f are all three correct <opt_spec>.
- <flags>
<flags> are of *, =, ? or !. * Use = if the option takes an argument.
Use ? to mean that the option is optional (though its use is discouraged).
Use * to mean that this option should not be listed in the usage generated for the -h argument. It's shown for --help-all as documented in gitcli(7).
Use ! to not make the corresponding negated long option available.
The remainder of the line, after stripping the spaces, is used as the help associated to the option.
Blank lines are ignored, and lines that don't match this specification are used as option group headers (start the line with a space to create such lines on purpose).
Example
OPTS_SPEC="\ some-command [options] <args>... some-command does foo and bar! -- h,help show the help foo some nifty option --foo bar= some cool option --bar with an argument An option group Header C? option C with an optional argument" eval "$(echo "$OPTS_SPEC" | git rev-parse --parseopt -- "$@" || echo exit $?)"
SQ-QUOTE
In --sq-quote mode, git rev-parse echoes on the standard output a single line suitable for sh(1) eval. This line is made by normalizing the arguments following --sq-quote. Nothing other than quoting the arguments is done.
If you want command input to still be interpreted as usual by git rev-parse before the output is shell quoted, see the --sq option.
Example
$ cat >your-git-script.sh <<\EOF #!/bin/sh args=$(git rev-parse --sq-quote "$@") # quote user-supplied arguments command="git frotz -n24 $args" # and use it inside a handcrafted # command line eval "$command" EOF $ sh your-git-script.sh "a b'c"
EXAMPLES
Print the object name of the current commit:
$ git rev-parse --verify HEAD
Print the commit object name from the revision in the $REV shell variable:
$ git rev-parse --verify $REV^{commit}
This will error out if $REV is empty or not a valid revision.
Similar to above:
$ git rev-parse --default master --verify $REV
but if $REV is empty, the commit object name from master will be printed.
GIT
Part of the git(1) suite


Good morning,
Pew
TODAY'S PLAN OF ACTION
Gym
Meditation
Read book
Link site for later
Enter your name
×


Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx > Class Template Reference
[Integer propagators]
Domain consistent layered graph (regular) propagator. More...
#include <extensional.hh>
Classes | |
| class | Edge |
| Edge defined by in-state and out-state More... | |
| class | Index |
| Advisors for views (by position in array) More... | |
| class | IndexRange |
| Range approximation of which positions have changed. More... | |
| class | Layer |
| Layer for a view in the layered graph More... | |
| class | LayerValues |
| Iterator for telling variable domains by scanning support. More... | |
| class | State |
| States are described by number of incoming and outgoing edges. More... | |
| class | Support |
| Support information for a value More... | |
Public Member Functions | |
| template<class Var > | |
| LayeredGraph (Home home, const VarArgArray< Var > &x, const DFA &dfa) | |
| Constructor for posting. | |
| virtual Actor * | copy (Space &home, bool share) |
| Copy propagator during cloning. | |
| virtual PropCost | cost (const Space &home, const ModEventDelta &med) const |
| Cost function (defined as high linear). | |
| virtual ExecStatus | advise (Space &home, Advisor &a, const Delta &d) |
| Give advice to propagator. | |
| virtual ExecStatus | propagate (Space &home, const ModEventDelta &med) |
| Perform propagation. | |
| virtual size_t | dispose (Space &home) |
| Delete propagator and return its size. | |
Static Public Member Functions | |
| template<class Var > | |
| static ExecStatus | post (Home home, const VarArgArray< Var > &x, const DFA &dfa) |
| Post propagator on views x and DFA dfa. | |
Protected Types | |
| typedef Gecode::Support::IntTypeTraits < Val >::utype | ValSize |
| Type for support size. | |
Protected Member Functions | |
| State & | i_state (int i, StateIdx is) |
| Return in state for layer i and state index is. | |
| State & | i_state (int i, const Edge &e) |
| Return in state for layer i and in state of edge e. | |
| bool | i_dec (int i, const Edge &e) |
| Decrement out degree for in state of edge e for layer i. | |
| State & | o_state (int i, StateIdx os) |
| Return out state for layer i and state index os. | |
| State & | o_state (int i, const Edge &e) |
| Return state for layer i and out state of edge e. | |
| bool | o_dec (int i, const Edge &e) |
| Decrement in degree for out state of edge e for layer i. | |
| void | audit (void) |
| Perform consistency check on data structures. | |
| template<class Var > | |
| ExecStatus | initialize (Space &home, const VarArgArray< Var > &x, const DFA &dfa) |
| Initialize layered graph. | |
| LayeredGraph (Space &home, bool share, LayeredGraph< View, Val, Degree, StateIdx > &p) | |
| Constructor for cloning p. | |
Protected Attributes | |
| Council< Index > | c |
| The advisor council. | |
| int | n |
| Number of layers (and views). | |
| Layer * | layers |
| The layers of the graph. | |
| StateIdx | max_states |
| Maximal number of states per layer. | |
| unsigned int | n_states |
| Total number of states. | |
| unsigned int | n_edges |
| Total number of edges. | |
| IndexRange | i_ch |
| Index range with in-degree modifications. | |
| IndexRange | o_ch |
| Index range with out-degree modifications. | |
| IndexRange | a_ch |
| Index range for any change (for compression). |
Detailed Description
template<class View, class Val, class Degree, class StateIdx>
class Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >
Domain consistent layered graph (regular) propagator.
The algorithm for the regular propagator is based on: Gilles Pesant, A Regular Language Membership Constraint for Finite Sequences of Variables, CP 2004. Pages 482-495, LNCS 3258, Springer-Verlag, 2004.
The propagator is not capable of dealing with multiple occurences of the same view.
Requires
#include <gecode/int/extensional.hh>
Definition at line 69 of file extensional.hh.
Member Typedef Documentation
typedef Gecode::Support::IntTypeTraits<Val>::utype Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::ValSize [protected] |
Type for support size.
Definition at line 93 of file extensional.hh.
Constructor & Destructor Documentation
| Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::LayeredGraph | ( | Space & | home, | |
| bool | share, | |||
| LayeredGraph< View, Val, Degree, StateIdx > & | p | |||
| ) | [inline, protected] |
Constructor for cloning p.
Definition at line 704 of file layered-graph.hpp.
| Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::LayeredGraph | ( | Home | home, | |
| const VarArgArray< Var > & | x, | |||
| const DFA & | dfa | |||
| ) | [inline] |
Constructor for posting.
Definition at line 237 of file layered-graph.hpp.
Member Function Documentation
| LayeredGraph< View, Val, Degree, StateIdx >::State & Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::i_state | ( | int | i, | |
| StateIdx | is | |||
| ) | [inline, protected] |
Return in state for layer i and state index is.
Definition at line 89 of file layered-graph.hpp.
| State& Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::i_state | ( | int | i, | |
| const Edge & | e | |||
| ) | [protected] |
Return in state for layer i and in state of edge e.
| bool Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::i_dec | ( | int | i, | |
| const Edge & | e | |||
| ) | [protected] |
Decrement out degree for in state of edge e for layer i.
| LayeredGraph< View, Val, Degree, StateIdx >::State & Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::o_state | ( | int | i, | |
| StateIdx | os | |||
| ) | [inline, protected] |
Return out state for layer i and state index os.
Definition at line 106 of file layered-graph.hpp.
| State& Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::o_state | ( | int | i, | |
| const Edge & | e | |||
| ) | [protected] |
Return state for layer i and out state of edge e.
| bool Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::o_dec | ( | int | i, | |
| const Edge & | e | |||
| ) | [protected] |
Decrement in degree for out state of edge e for layer i.
| void Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::audit | ( | void | ) | [inline, protected] |
Perform consistency check on data structures.
Definition at line 247 of file layered-graph.hpp.
| ExecStatus Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::initialize | ( | Space & | home, | |
| const VarArgArray< Var > & | x, | |||
| const DFA & | dfa | |||
| ) | [inline, protected] |
Initialize layered graph.
Definition at line 270 of file layered-graph.hpp.
| Actor * Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::copy | ( | Space & | home, | |
| bool | share | |||
| ) | [inline, virtual] |
Copy propagator during cloning.
Implements Gecode::Actor.
Definition at line 745 of file layered-graph.hpp.
| PropCost Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::cost | ( | const Space & | home, | |
| const ModEventDelta & | med | |||
| ) | const [inline, virtual] |
Cost function (defined as high linear).
Implements Gecode::Propagator.
Definition at line 738 of file layered-graph.hpp.
| ExecStatus Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::advise | ( | Space & | home, | |
| Advisor & | a, | |||
| const Delta & | d | |||
| ) | [inline, virtual] |
Give advice to propagator.
Reimplemented from Gecode::Propagator.
Definition at line 442 of file layered-graph.hpp.
| ExecStatus Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::propagate | ( | Space & | home, | |
| const ModEventDelta & | med | |||
| ) | [inline, virtual] |
Perform propagation.
Implements Gecode::Propagator.
Definition at line 596 of file layered-graph.hpp.
| size_t Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::dispose | ( | Space & | home | ) | [inline, virtual] |
Delete propagator and return its size.
Reimplemented from Gecode::Actor.
Definition at line 588 of file layered-graph.hpp.
| ExecStatus Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::post | ( | Home | home, | |
| const VarArgArray< Var > & | x, | |||
| const DFA & | dfa | |||
| ) | [inline, static] |
Post propagator on views x and DFA dfa.
Definition at line 681 of file layered-graph.hpp.
Member Data Documentation
Council<Index> Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::c [protected] |
The advisor council.
Definition at line 156 of file extensional.hh.
int Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::n [protected] |
Number of layers (and views).
Definition at line 158 of file extensional.hh.
Layer* Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::layers [protected] |
The layers of the graph.
Definition at line 160 of file extensional.hh.
StateIdx Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::max_states [protected] |
Maximal number of states per layer.
Definition at line 162 of file extensional.hh.
unsigned int Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::n_states [protected] |
Total number of states.
Definition at line 164 of file extensional.hh.
unsigned int Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::n_edges [protected] |
Total number of edges.
Definition at line 166 of file extensional.hh.
IndexRange Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::i_ch [protected] |
Index range with in-degree modifications.
Definition at line 168 of file extensional.hh.
IndexRange Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::o_ch [protected] |
Index range with out-degree modifications.
Definition at line 170 of file extensional.hh.
IndexRange Gecode::Int::Extensional::LayeredGraph< View, Val, Degree, StateIdx >::a_ch [protected] |
Index range for any change (for compression).
Definition at line 172 of file extensional.hh.
The documentation for this class was generated from the following files:
- gecode/int/extensional.hh (Revision: 12963)
- gecode/int/extensional/layered-graph.hpp (Revision: 13068)


---
layout: page
title: "Members"
description: "Faculty & Students working on projects"
header-img: "img/team_bg_gray1.jpg"
---
Admin Team
{% for member in site.data.adm_members %} {% if member.visible == true %}
{{ member.name }}
{{ member.role }}
{% endif %}{% endfor %}
Team ARLE
{% for team in site.data.arle_teams %}
Team : {{ team.team_name }}
{% for member in site.data.arle_members %} {% if member.visible == true %}
{% for team_id in member.team %}
{% if team.team_id == team_id %}
{{ member.name }}
{{ member.role }}
{{ team.team_name }}
{% endif %} {% endfor %}
{% endif %}{% endfor %}
{% endfor %}
Team Hexacopter
{% for member in site.data.hexacopter_members %} {% if member.visible == true %}
{{ member.name }}
{{ member.role }}
{% endif %}{% endfor %}
Team Raman
{% for member in site.data.raman_members %} {% if member.visible == true %}
{{ member.name }}
{{ member.role }}
{% endif %}{% endfor %}
Team Antahsagari
{% for member in site.data.antahsagari_members %} {% if member.visible == true %}
{{ member.name }}
{{ member.role }}
{% endif %}{% endfor %}


My Website
Toggle Navigation
Home
Profile
Services
Products
Who we are
Bootstrap Sample
Game Design and Development: What brings people to websites more than anything? ok, besides that.
Learn More
Registration


Code Collaboration
Frontend Guild Workshop March 2021
Goffert van Gool
Git
Collaboration
Access Control
Pull Requests
Forks
Licenses
- MIT
Do whatever you want with my stuff, just don't sue me
- GPL
If you change or distribute my code, you must provide the source under this license
Issues
Workflow
- Check CONTRIBUTING.md
- Check issues
- Communicate with the maintainer
- Fork the repository
- Make a merge request
Good Luck


Sqoop UI
The Sqoop UI enables transfering data from a relational database
to Hadoop and vice versa. The UI lives uses Apache Sqoop to do this.
See the Sqoop Documentation for more details on Sqoop.
Installation and Configuration
The Sqoop UI is one of the applications installed as part of
Hue. For information about installing and configuring Hue, see the Hue Installation
manual.
Starting
Click the Sqoop icon
() in the navigation bar at the top of
the Hue browser page.
Sqoop Jobs
Sqoop UI is oriented around jobs in Apache Sqoop.
Creating a New Job
- Click the New job button at the top right.
- In the Name field, enter a name.
- Choose the type of job: import or export.
The proceeding form fields will change depending on which type is chosen.
- Select a connection, or create one if it does not exist.
- Fill in the rest of the fields for the job.
For importing, the "Table name", "Storage type", "Output format", and "Output directory" are necessary at a minimum.
For exporting, the "Table name" and "Input directory" are necessary at a minimum.
- Click save to finish.
Editing a Job
- In the list of jobs, click on the name of the job.
- Edit the desired form fields in the job.
Copying a Job
- In the list of jobs, click on the name of the job.
- On the left hand side of the job editor, there should be a panel containing actions.
Click Copy.
Removing a Job
- In the list of jobs, click on the name of the job.
- On the left hand side of the job editor, there should be a panel containing actions.
Click Delete.
Running a Job
There's a status on each of the items in the job list indicating
the last time a job was ran. The progress of the job should dynamically
update. There's a progress bar at the bottom of each item on the job list
as well.
- In the list of jobs, click on the name of the job.
- On the left hand side of the job editor, there should be a panel containing actions.
Click Run.
Creating a New Connection
- Click the New job button at the top right.
- At the connection field, click the link titled Add a new connection.
- Fill in the displayed fields.
- Click save to finish.
Editing a Connection
- Click the New job button at the top right.
- At the connection field, select the connection by name that should be edited.
- Click Edit.
- Edit the any of the fields.
- Click save to finish.
Removing a Connection
- Click the New job button at the top right.
- At the connection field, select the connection by name that should be deleted.
- Click Delete.
NOTE: If this does not work, it's like because a job is using that connection.
Make sure not jobs are using the connection that will be deleted.
Filtering Sqoop Jobs
The text field in the top, left corner of the Sqoop Jobs page enables fast filtering
of sqoop jobs by name.


Non Linear Schild Informational Page
Click a plot to learn more about it!
You can also jump to the detailed descriptions here!
1. Competitive Antagonist
2. Competitive antagonist is a substrate of saturable uptake system
3. Agonist is a substrate of a saturable uptake system
4. Competitive antagonist is toxic
5. Irreversible antagonist
6. Allosteric antagonist
7.


These instructions will get you a copy of the project up and running on your local machine for development and testing purposes
This module can only be used in a React Native app. To use it, you will need a React Native app with it's dependencies installed. The following modules need to be added as a dev dependency as well.
create-react-class
react-native-vector-icons
To install first-born run the following command in the terminal;
npm install --save @99x/first-born
You will additionally require to install the following modules as well.
npm install --save create-react-class react-native-vector-icons
Follow this guide to
configure react-native-vector-icons
for your project.
No other steps are required to configure first-born
separately for each platform (Android/iOS).
To test the repo, first clone it;
git clone https://github.com/99x/first-born.git
Move into the folder;
cd first-born
Install dependencies;
npm install
And run the test script;
npm run test


First Name
Last Name
Email
Password
Confirm Password
info Password Will be sent to your email
Common site privileges such as Home, Channels, Knowledge Board, Playlists
{{role.about | titlecase}}


{% extends 'layout.html' %} {% block pageTitle %} Find an NHS psychological therapies service {% endblock %} {% block beforeContent %} {% endblock %} {% block content %}
Please note: If your GP is in London, please select the service in the borough where your GP is based.
You may not be eligible for the other services being shown.
We are working to fix this as soon as possible.
Telephone: 020 8301 8980
Email<EMAIL_ADDRESS>Telephone: 020 3260 1100


{% extends "base.html" %} {% block ogtitle %}{% block title %}Coders{% endblock %}{% endblock %} {% block description %}Check out our list of registered and virtual coders, consolidating multiple accounts into one. Gain a comprehensive view of their collective achievements across different platforms.{% endblock %} {% block end-head %} {% endblock %} {% block content %}


Presenter(s): {{sub.presenterInfo.first}} {{sub.presenterInfo.last}}{{sub.copresenterOneInfo.first | isntEmpty:", ":""}} {{sub.copresenterOneInfo.last | isntEmpty:"":""}}{{sub.copresenterTwoInfo.first | isntEmpty:",":""}} {{sub.copresenterTwoInfo.last | isntEmpty:"":""}}
Project Adviser: {{sub.adviserInfo.first}} {{sub.adviserInfo.last}}{{sub.coadviserOneInfo.first | isntEmpty:",":""}}{{sub.coadviserOneInfo.last | isntEmpty:"":""}}{{sub.coadviserTwoInfo.first | isntEmpty:",":""}} {{sub.coadviserTwoInfo.last | isntEmpty:"":""}}
Title: {{sub.title}}
Type of Presentation: {{sub.presentationType}}


WebGL
Constructor Summary
| Public Constructor | ||
| public |
constructor(config: Object) References: LiteGL |
Member Summary
| Public Members | ||
| public |
|
|
| public |
debug: * |
|
| public |
gl: * |
|
| public |
glMatrix: * |
|
| public |
|
|
| public |
util: * |
Method Summary
| Public Methods | ||
| public |
addVertexBufferSupport(gl: WebGLRenderingContext) Add vertex buffer support to WebGL 1.0 |
|
| public |
bindAttributeLocations(program: WebGLProgram, attribLocationmap: Object) Bind attribute locations. |
|
| public |
checkBufferObjects(bo: *): * Check if our VBO, IBO are ok. |
|
| public |
checkShaders(vs: *, fs: *, program: *): boolean check to see if we're ready to run, after supplying shaders. |
|
| public |
clear() Clear the screen prior to redraw. |
|
| public |
Clear textures from the videocard before starting. |
|
| public |
createContext(canvas: Canvas, canvas: HTMLCanvasElement): WebGLRenderingContext get HTML5 canvas, and a WebGL context. |
|
| public |
createFragmentShader(source: *): * |
|
| public |
createProgram(vShader: gl.VERTEX_SHADER, fShader: gl.FRAGMENT_SHADER): * Create WebGL program with shaders. |
|
| public |
createShader(type: VERTEX_SHADER | FRAGMENT_SHADER, source: String): WebGLShader create a WeGL shader object. |
|
| public |
createShaderFromTag(tag: String | DOMElement): * create shader form script element |
|
| public |
createVarList(sourceArr: Array): Object Read shader code, and organize the variables in the shader into an object. |
|
| public |
createVertexShader(source: *): * |
|
| public |
fetchFragmentShader(sourceURL: *): * |
|
| public |
fetchShader(type: *, sourceURL: *): * Use the Fetch API to get a shader file |
|
| public |
fetchVertexShader(sourceURL: *): * |
|
| public |
getAttributes(program: WebGLProgram): Object Create associative array with shader attributes. |
|
| public |
getCanvas(): HTMLCanvasElement Get WebGL canvas only if we've created a gl context. |
|
| public |
getContext(): WebGLRenderingContext Return the current context. |
|
| public |
getUniforms(program: WebGLProgram): Object Create associative array with shader uniforms. |
|
| public |
getVarying(program: *) Create associative array with shader varying variables. |
|
| public |
init(canvas: HTMLCanvasElement | String | undefined, lostContext: Function, restoredContext: Function): WebGLContext initialize with a canvas context |
|
| public |
Kill the current context (complete reset will be needed). |
|
| public |
ready(): * check if we have a contex and are ready to render. |
|
| public |
Resize the canvas if the window changes size. |
|
| public |
setAttributeArrays(shaderProgram: *, attributes: *): * assign the attribute arrays. |
|
| public |
setUniformLocations(shaderProgram: *, uniforms: *): * |
|
| public |
stats() |
Public Constructors
Public Members
public debug: * source
public gl: * source
public glMatrix: * source
public util: * source
Public Methods
public addVertexBufferSupport(gl: WebGLRenderingContext) source
Add vertex buffer support to WebGL 1.0
Params:
| Name | Type | Attribute | Description |
| gl | WebGLRenderingContext | a WebGL rendering context (should be 1.x only)l |
public bindAttributeLocations(program: WebGLProgram, attribLocationmap: Object) source
Bind attribute locations.
Params:
| Name | Type | Attribute | Description |
| program | WebGLProgram | a compiled WebGL program. |
|
| attribLocationmap | Object | the attributes. |
public checkBufferObjects(bo: *): * source
Check if our VBO, IBO are ok.
Params:
| Name | Type | Attribute | Description |
| bo | * |
Return:
| * |
public checkShaders(vs: *, fs: *, program: *): boolean source
check to see if we're ready to run, after supplying shaders.
Params:
| Name | Type | Attribute | Description |
| vs | * | ||
| fs | * | ||
| program | * |
public createContext(canvas: Canvas, canvas: HTMLCanvasElement): WebGLRenderingContext source
get HTML5 canvas, and a WebGL context. We also scan for multiple contexts being created ( > 1 ) and delete if one is already present.
Params:
| Name | Type | Attribute | Description |
| canvas | Canvas | the HTML5 <canvas> DOM element. TODO: PROBLEM IF THERE ARE MULTIPLE CONTEXES ON THE PAGE??????? |
|
| canvas | HTMLCanvasElement | the rendering <canvas>. |
Return:
| WebGLRenderingContext | gl a WebGLRenderingContext. |
public createFragmentShader(source: *): * source
Params:
| Name | Type | Attribute | Description |
| source | * |
Return:
| * |
public createProgram(vShader: gl.VERTEX_SHADER, fShader: gl.FRAGMENT_SHADER): * source
Create WebGL program with shaders. Program not used until we apply gl.useProgram(program).
Params:
| Name | Type | Attribute | Description |
| vShader | gl.VERTEX_SHADER | the vertex shader. |
|
| fShader | gl.FRAGMENT_SHADER | the fragment shader. |
Return:
| * |
public createShader(type: VERTEX_SHADER | FRAGMENT_SHADER, source: String): WebGLShader source
create a WeGL shader object.
Params:
| Name | Type | Attribute | Description |
| type | VERTEX_SHADER | FRAGMENT_SHADER | type WebGL shader type. |
|
| source | String | the shader source, as plain text. |
Return:
| WebGLShader | a compiled WebGL shader object. |
public createShaderFromTag(tag: String | DOMElement): * source
create shader form script element
Params:
| Name | Type | Attribute | Description |
| tag | String | DOMElement | the script element, or its id |
Return:
| * |
public createVarList(sourceArr: Array): Object source
Read shader code, and organize the variables in the shader into an object. Abstracts some of the tedious work in setting up shader variables.
Params:
| Name | Type | Attribute | Description |
| sourceArr | Array | array of lines in the shader. |
public createVertexShader(source: *): * source
Params:
| Name | Type | Attribute | Description |
| source | * |
Return:
| * |
public fetchFragmentShader(sourceURL: *): * source
Params:
| Name | Type | Attribute | Description |
| sourceURL | * |
Return:
| * |
public fetchShader(type: *, sourceURL: *): * source
Use the Fetch API to get a shader file
Params:
| Name | Type | Attribute | Description |
| type | * | ||
| sourceURL | * |
Return:
| * |
public fetchVertexShader(sourceURL: *): * source
Params:
| Name | Type | Attribute | Description |
| sourceURL | * |
Return:
| * |
public getAttributes(program: WebGLProgram): Object source
Create associative array with shader attributes. NOTE: Only attributes actually used in the shader show.
Params:
| Name | Type | Attribute | Description |
| program | WebGLProgram | a compiled WebGL program. |
public getCanvas(): HTMLCanvasElement source
Get WebGL canvas only if we've created a gl context.
Return:
| HTMLCanvasElement | canvas the rendering <canvas>. |
public getContext(): WebGLRenderingContext source
Return the current context. Note that we don't store a separate reference to the canvas.
Return:
| WebGLRenderingContext | gl a WebGLRenderingContext. |
public getUniforms(program: WebGLProgram): Object source
Create associative array with shader uniforms. NOTE: Only attributes actually used in the shader show.
Params:
| Name | Type | Attribute | Description |
| program | WebGLProgram | a compiled WebGL program. |
public getVarying(program: *) source
Create associative array with shader varying variables.
Params:
| Name | Type | Attribute | Description |
| program | * |
public init(canvas: HTMLCanvasElement | String | undefined, lostContext: Function, restoredContext: Function): WebGLContext source
initialize with a canvas context
Params:
| Name | Type | Attribute | Description |
| canvas | HTMLCanvasElement | String | undefined | a HTML5 <canvas>, id for canvas, or undefined, in which case a <canvas> object is created and added to document.body, an ID value for a tag, or a CanvasDOMobject. |
|
| lostContext | Function | callback when WebGL context is lost. |
|
| restoredContext | Function | callback when WebGL context is restored. |
Return:
| WebGLContext | the WebGL context of the <canvas> object. |
public killContext() source
Kill the current context (complete reset will be needed). Also use to debug when context is lost, and has to be rebuilt.
public resizeCanvas(): boolean source
Resize the canvas if the window changes size. NOTE: affected by CSS styles. TODO: check current CSS style. (TWGL)
public setAttributeArrays(shaderProgram: *, attributes: *): * source
assign the attribute arrays.
Params:
| Name | Type | Attribute | Description |
| shaderProgram | * | ||
| attributes | * |
Return:
| * |
public setUniformLocations(shaderProgram: *, uniforms: *): * source
Params:
| Name | Type | Attribute | Description |
| shaderProgram | * | ||
| uniforms | * |
Return:
| * |


I'm a full stack web developer who specializes in Javascript and Ruby. I build websites from the ground up with attention on both aesthetics and functionality. Check out my work in the projects section, or contact me to talk about web development, music, motorcycle maintenance, or mycology
You can view and download my resume as a PDF here
This full-stack web application uses Rails and SQL on the server with JavaScript, jQuery and AJAX on the front-end. The site helps guitarists keep track of the configurations of their guitars. Bootstrap modals are used for forms, and Handlebars are used to dynamically render content on the page. When a user adds, deletes, or updates a guitar, their catalog immediately reflects the changes they made.
In order to enhance user experience, this website utilizes handlebars so users immeidately see changes they've made. Aiming for good UX is also why I added a delete confirmation so users wouldn't accidentally delete a guitar, which ended up being a challenge because of the way handlebars was interacting with the bootstrap modals. Although I could have spent my time making the site more aesthetically pleasing, I'm glad I went for these challenges that required me to learn new technologies and techniques. The site does not check for valid emails - you may explore the site using dummy credentials.
MechanicMate is an app built for my capstone project for General Assembly. The API is built with Ruby on Rails, using PostgreSQL to interact with the SQL database. The front-end is built with Ember.js, a framework that allows single-page applications to route to numerous URLs.
Over the short 1 week development cycle I used a front end framework for the first time. The efficient completion of MechanicMate shows my ability to learn the fundamentals of a framework as well as additional technical challenges, given limited time frames.
As an extra challenge I worked with a graphic designer to create a more aesthetic site. They designed the splash page which I recreated precisely with HTML and CSS. This design informed aesthetic decisions for the rest of the site, which gave me expereince working with a designer and bringing designs created in design software onto the web. The site does not check for valid emails - you may explore the site using dummy credentials.
A simple take on the classic game with some fun jQuery added in. It communicates with a Rails API to record game status and history. I built the client with JavaScript, jQuery and AJAX. I used Bootstrap to increase responsiveness of the page, and modals for forms. Players can see previous games they played, and interact with them as well.
This is an in-progress, improved version of Guitar Tracker using React on the front-end. The SQL database and Rails API have been changed to allow for guitar histories: when users update their information (such as when they changed their strings) the old value isn't overwritten - it's saved in the guitar's history. This required a complete restructuring of the database from version 1. As development is in its early stages, the site isn't live, but the github repos are public.
Another in-progress app, I've focused development thus far on connecting to 3rd-party APIs. I built a proxy server in Express so that the client could make calls to the Dark Sky API for weather information. This project allows me to diversify my portfolio, expanded beyong Rails only environments to utilize Express functions, middleware, and error handling. This site will fully integrate authentication into the Express server.
A co-developer and I are now working on displaying tide information on a chart with Highcharts. Integrating the Highcharts API into our React frontend is a complex task, but one we've nearly completed. Currently, the chart renders our data on the page - our intent is to clean up the look for a sleeker, more simplified view. The repo is private but I can share code upon request.
I'm currently looking for work in the greater Boston area


OPEN SOURCE SOFTWARE NOTICE
Please note we provide an open source software notice along with this product and/or this product firmware (in the following just “this product”). The open source software licenses are granted by the respective right holders. And the open source licenses prevail all other license information with regard to the respective open source software contained in the product, including but not limited to End User Software Licensing Agreement. This notice is provided on behalf of Huawei Technologies Co. Ltd. and any of its local subsidiaries which may have provided this product to you in your local country.
 SEE THE APPLICABLE LICENSES FOR MORE DETAILS.
Copyright Notice and License Texts
Copyright notice:
Copyright (c) 2018 Miguel Ruivo
License: The MIT License (MIT)
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
Written Offer
This product contains software whose rights holders license it on the terms of the GNU General Public License, version 2 (GPLv2) and/or other open source software licenses. We will provide you and any third party with the source code of the software licensed under an open source software license if you send us a written request by mail or email to the following addresses:
detailing the name of the product and the firmware version for which you need the source code and indicating how we can contact you.
Please note you need to make a payment before you obtain the complete Corresponding Source Code from us. For how much you will pay and how we will deliver the complete Corresponding Source Code to you, we will further discuss it by mail or email.
This offer is valid to anyone in receipt of this information.
THIS OFFER IS VALID FOR THREE YEARS FROM THE MOMENT WE DISTRIBUTED THE PRODUCT OR FIRMWARE .