public abstract class LocalPattern extends Pattern
| Modifier and Type | Field and Description |
|---|---|
protected float |
acceleration |
protected java.awt.Color |
color |
protected long |
currentTime |
protected float |
currentX |
protected float |
currentY |
protected float |
direction |
protected float |
directionChange |
protected float |
glow
The relative amount of brightness a spot should have, after the pattern leaves its position.
|
protected long |
lifespan |
protected float |
maxAcceleration |
protected float |
maxVelocity |
protected long |
newTime |
protected java.util.Random |
rand |
protected int |
size |
protected long |
startTime |
protected int |
thickness
Not necessarily applicable to all LocalPatterns
|
protected float |
velocity |
black, picture, pictureSizeX, pictureSizeY
| Constructor and Description |
|---|
LocalPattern(int pictureSizeX,
int pictureSizeY)
This constructor initializes all the attributes to default values which are configured for DotPattern,
but could be used for any other LocalPattern as well.
|
LocalPattern(int pictureSizeX,
int pictureSizeY,
int maxLifetimeInMs,
java.lang.Integer maxSize,
java.lang.Float maxVelocity,
java.lang.Float maxAcceleration,
java.lang.Float averageGlow)
This constructor allows the passed parameters to set most of the object's attributes.
|
| Modifier and Type | Method and Description |
|---|---|
protected void |
advancePatternCoordinates()
Calculates and sets the pattern's new position,
depending on the time passed between the last calculation and the pattern's velocity.
|
protected abstract void |
drawPattern()
Defines how to draw the pattern, i.e.
|
protected void |
drawPixel(int x,
int y)
Sets exactly one pixel of the picture, based on the objects color-attribute.
|
protected void |
fadeInPicture()
Gradually fades in the last calculated picture, depending on the time that passed since the creation of the pattern.
|
protected void |
fadeOutPicture()
Fades out the last calculated picture.
|
java.util.ArrayList<java.util.ArrayList<java.awt.Color>> |
getNextPicture()
Calculates and returns the next picture.
|
private void |
initialize()
Initializes the coordinates with random values inside the picture.
|
protected void |
setBackgroundPatternColor()
Sets the Pattern's color to a very low, pseudo-random value with a heavy blue tone,
so it can be used in a BackgroundPattern.
|
private void |
setColor()
Sets the Pattern's color to a pseudo-random value.
|
protected void |
updateAcceleration()
Pseudo-randomly generates an acceleration value.
|
protected void |
updateDirectionChange()
Randomly sets the value of the directionChange-attribute to a value between -0.3 and 0.3 PI
|
initializePicture
protected java.util.Random rand
protected float currentX
protected float currentY
protected long lifespan
protected long startTime
protected long currentTime
protected long newTime
protected int size
protected int thickness
protected float glow
protected float velocity
protected float maxVelocity
protected float acceleration
protected float maxAcceleration
protected float direction
protected float directionChange
protected java.awt.Color color
public LocalPattern(int pictureSizeX, int pictureSizeY)
pictureSizeX
- the length in the x-axis of the led-matrixpictureSizeY
- the length in the y-axis of the led-matrixpublic LocalPattern(int pictureSizeX, int pictureSizeY, int maxLifetimeInMs, java.lang.Integer maxSize, java.lang.Float maxVelocity, java.lang.Float maxAcceleration, java.lang.Float averageGlow)
pictureSizeX
- the length in the x-axis of the led-matrixpictureSizeY
- the length in the y-axis of the led-matrixmaxLifetimeInMs
- the maximum lifetime the instance of this class should havemaxSize
- the maximum size this pattern should havemaxVelocity
- the the maximum velocity this pattern should havemaxAcceleration
- the the maximum acceleration this pattern should haveaverageGlow
- a rough value of the amount of glow this pattern should haveprivate void initialize()
private void setColor()
protected void setBackgroundPatternColor()
protected abstract void drawPattern()
public java.util.ArrayList<java.util.ArrayList<java.awt.Color>> getNextPicture()
getNextPicture
in class Pattern
protected void updateDirectionChange()
protected void fadeInPicture()
protected void fadeOutPicture()
protected void drawPixel(int x, int y)
x
- the x-coordinate of the pixely
- the y-coordinate of the pixelprotected void updateAcceleration()
protected void advancePatternCoordinates()


Join Game
Try again
Reconnect
Latency:
N/A
Latency (avg):
N/A
This is a live JavaScript multiplayer game


TrackIT
Username
Password
Don't have an account?
Sign Up
Username
Email
Password
Confirm Password
Already have an account?


7.2. Schema Commands¶
These commands are used to create, describe and delete schemas (SimpleFeatureType
s). Required
parameters are indicated with a *
.
7.2.1. create-schema
¶
Used to create a new SimpleFeatureType
.
| Argument | Description |
|---|---|
-c, --catalog * |
The catalog table used to hold the schema metadata |
-s, --spec * |
The SimpleFeatureType specification to create |
-f, --feature-name |
The name of the schema to create |
--dtg |
The attribute to use for the default date field |
The --spec
argument may be any of the following:
- A string of attributes, for example
name:String,dtg:Date,*geom:Point:srid=4326
- The name of a
SimpleFeatureType
already available on the classpath - A string of attributes, defined as a TypeSafe configuration
- The name of a file containing one of the above
See Defining Simple Feature Types for more details on specifying the SimpleFeatureType
.
The --feature-name
attribute is required if it is not implied by the specification string.
It may also be used to override the implied feature name.
7.2.2. delete-catalog
¶
Deletes all SimpleFeatureType
s in a given catalog, and all features associated with them.
| Argument | Description |
|---|---|
-c, --catalog * |
The catalog table used to hold the schema metadata |
7.2.3. describe-schema
¶
Describes the attributes of an existing SimpleFeatureType
.
| Argument | Description |
|---|---|
-c, --catalog * |
The catalog table containing the schema metadata |
-f, --feature-name * |
The name of the schema to describe |
7.2.4. gen-avro-schema
¶
Generate an Avro schema based on a SimpleFeatureType
.
| Argument | Description |
|---|---|
-s, --spec * |
The SimpleFeatureType specification to create |
-f, --feature-name |
The name of the schema to create |
See create-schema for details on specifying a SimpleFeatureType
.
7.2.5. get-sft-config
¶
Exports the SimpleFeatureType
metadata.
| Argument | Description |
|---|---|
-c, --catalog * |
The catalog table used to hold the schema metadata |
-f, --feature-name * |
The name of the schema to export |
--format |
The format to output - either spec or config |
--concise |
Export the metadata with minimal whitespace |
--exclude-user-data |
Exclude user data from the output |
The metadata can either be exported as a specification string, or as a TypeSafe
configuration file. See Defining Simple Feature Types for more details on SimpleFeatureType
formats.
7.2.6. get-type-names
¶
Displays the names of SimpleFeatureType
s stored in a given catalog table.
| Argument | Description |
|---|---|
-c, --catalog * |
The catalog table containing schema metadata |
7.2.7. keywords
¶
View, add, or remove keywords associated with a SimpleFeatureType
. Keywords are stored as user data,
and will automatically populate GeoServer layers when the layer is created.
| Argument | Description |
|---|---|
-c, --catalog * |
The catalog table used to hold the schema metadata |
-f, --feature-name * |
The name of the schema to operate on |
-l, --list |
List existing keywords |
-a, --add |
Add a new keyword by name |
-r, --remove |
Delete an existing keyword by name |
--removeAll |
Delete all existing keywords |
7.2.8. remove-schema
¶
Deletes a SimpleFeatureType
, and all features associated with it.
| Argument | Description |
|---|---|
-c, --catalog * |
The catalog table used to hold the schema metadata |
-f, --feature-name |
The name of the schema to delete |
--pattern |
A regular expression matching the schemas to delete |
--force |
Delete any matching schemas without prompting for confirmation |
The schema can either be specified by name, or a regular expression can be used to delete multiple schemas at once.


Watch Tesla's 'Cybertruck' unveiling at 11 PM ET
Elon Musk has promised it will look like something out of a sci-fi movie.
by Richard LawlerTesla CEO Elon Musk has put the F-150 squarely in his company's sights, and tonight we'll find out how close it can get with a new "Cybertruck." In a tweet earlier today the exec referenced his 2012 goal of "a Tesla supertruck with crazy torque, dynamic air suspension and corners like its on rails."
At a shareholder's meeting earlier this year Musk said the truck will "look like it came out of a sci-fi movie" and the run up to its unveiling has been heavy on Blade Runner references. What does that all add up to? We'll find out shortly -- check out the livestream below.
Update: The $39,900 Cybertruck is official!


Goal: Our goal is to help groups reach educates decisions, based on verified knowledge, and the wisdom of all members of the group. In the future we hope to enable cross-groups wisdom. Such decisions should help elevate group-intelligence, help the group reach better decisions, and let every member contribute her unique knowledge, thus, elevating the satisfaction and happiness of most if not all of the members.
Theory: We use a deliberative theory as model for how decsions works. You can find it here.
Utilities:
Documetations: Our documentations are found here.
Code: Our github code is here, and our open source license is found here.
Communication: we are avileble at delib-org google group or you can email us at<EMAIL_ADDRESS>Back


|
IAIK PKCS#11 Wrapper version 1.3 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object | +--iaik.pkcs.pkcs11.wrapper.Functions
This class contains onyl static methods. It is the place for all functions that are used by several classes in this package.
| Field Summary | |
protected static java.util.Hashtable |
digestMechanisms_
This table contains the mechanisms that are digest mechanisms. |
protected static java.util.Hashtable |
fullEncryptDecryptMechanisms_
This table contains the mechanisms that are full encrypt/decrypt mechanisms; i.e. |
protected static java.util.Hashtable |
fullSignVerifyMechanisms_
This table contains the mechanisms that are full sign/verify mechanisms; i.e. |
protected static char[] |
HEX_DIGITS
For converting numbers to their hex presentation. |
protected static java.util.Hashtable |
keyDerivationMechanisms_
This table contains the mechanisms that are key derivation mechanisms. |
protected static java.util.Hashtable |
keyGenerationMechanisms_
This table contains the mechanisms that key generation mechanisms; i.e. |
protected static java.util.Hashtable |
keyPairGenerationMechanisms_
This table contains the mechanisms that key-pair generation mechanisms; i.e. |
protected static java.util.Hashtable |
mechansimNames_
Maps mechanism codes as Long to their names as Strings. |
protected static java.util.Hashtable |
signVerifyRecoverMechanisms_
This table contains the mechanisms that are sign/verify mechanisms with message recovery. |
protected static java.util.Hashtable |
singleOperationEncryptDecryptMechanisms_
This table contains the mechanisms that are single-operation encrypt/decrypt mechanisms; i.e. |
protected static java.util.Hashtable |
singleOperationSignVerifyMechanisms_
This table contains the mechanisms that are single-operation sign/verify mechanisms; i.e. |
protected static java.util.Hashtable |
wrapUnwrapMechanisms_
This table contains the mechanisms that are wrap/unwrap mechanisms. |
| Constructor Summary | |
Functions()
|
| Method Summary | |
static java.lang.String |
classTypeToString(long classType)
Converts the long value classType to a string representation of it. |
static boolean |
equals(byte[] array1,
byte[] array2)
Check the given arrays for equalitiy. |
static boolean |
equals(char[] array1,
char[] array2)
Check the given arrays for equalitiy. |
static boolean |
equals(CK_DATE date1,
CK_DATE date2)
Check the given dates for equalitiy. |
static boolean |
equals(long[] array1,
long[] array2)
Check the given arrays for equality. |
static int |
hashCode(byte[] array)
Calculate a hash code for the given byte array. |
static int |
hashCode(char[] array)
Calculate a hash code for the given char array. |
static int |
hashCode(CK_DATE date)
Calculate a hash code for the given date object. |
static int |
hashCode(long[] array)
Calculate a hash code for the given long array. |
static boolean |
isDigestMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a digest mechanism. |
static boolean |
isFullEncryptDecryptMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a full encrypt/decrypt mechanism; i.e. |
static boolean |
isFullSignVerifyMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a full sign/verify mechanism; i.e. |
static boolean |
isKeyDerivationMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a key derivation mechanism. |
static boolean |
isKeyGenerationMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a key generation mechanism for generating symmetric keys. |
static boolean |
isKeyPairGenerationMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a key-pair generation mechanism for generating key-pairs. |
static boolean |
isSignVerifyRecoverMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a sign/verify mechanism with message recovery. |
static boolean |
isSingleOperationEncryptDecryptMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a single-operation encrypt/decrypt mechanism; i.e. |
static boolean |
isSingleOperationSignVerifyMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a single-operation sign/verify mechanism; i.e. |
static boolean |
isWrapUnwrapMechanism(long mechanismCode)
This method checks, if the mechanism with the given code is a wrap/unwrap mechanism; i.e. |
static java.lang.String |
mechanismCodeToString(long mechansimCode)
Converts the long value code of a mechanism to a name. |
static java.lang.String |
mechanismInfoFlagsToString(long flags)
Converts the long value flags to a MechanismInfoFlag string. |
static java.lang.String |
sessionInfoFlagsToString(long flags)
Converts the long value flags to a SessionInfoFlag string. |
static java.lang.String |
sessionStateToString(long state)
Converts the long value state to a SessionState string. |
static java.lang.String |
slotInfoFlagsToString(long flags)
Converts the long value flags to a SlotInfoFlag string. |
static java.lang.String |
toBinaryString(byte[] value)
Converts a byte array to a binary String. |
static java.lang.String |
toBinaryString(long value)
Converts a long value to a binary String. |
static java.lang.String |
toFullHexString(int value)
Converts a int value to a hexadecimal String of length 8. |
static java.lang.String |
toFullHexString(long value)
Converts a long value to a hexadecimal String of length 16. |
static java.lang.String |
toHexString(byte[] value)
Converts a byte array to a hexadecimal String. |
static java.lang.String |
toHexString(long value)
Converts a long value to a hexadecimal String. |
static java.lang.String |
tokenInfoFlagsToString(long flags)
Converts long value flags to a TokenInfoFlag string. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
protected static java.util.Hashtable mechansimNames_
protected static java.util.Hashtable fullEncryptDecryptMechanisms_
protected static java.util.Hashtable singleOperationEncryptDecryptMechanisms_
protected static java.util.Hashtable fullSignVerifyMechanisms_
protected static java.util.Hashtable singleOperationSignVerifyMechanisms_
protected static java.util.Hashtable signVerifyRecoverMechanisms_
protected static java.util.Hashtable digestMechanisms_
protected static java.util.Hashtable keyGenerationMechanisms_
protected static java.util.Hashtable keyPairGenerationMechanisms_
protected static java.util.Hashtable wrapUnwrapMechanisms_
protected static java.util.Hashtable keyDerivationMechanisms_
protected static final char[] HEX_DIGITS
| Constructor Detail |
public Functions()
| Method Detail |
public static java.lang.String toFullHexString(long value)
value
- The long value to be converted.public static java.lang.String toFullHexString(int value)
value
- The int value to be converted.public static java.lang.String toHexString(long value)
value
- The long value to be converted.public static java.lang.String toHexString(byte[] value)
value
- the byte array to be convertedpublic static java.lang.String toBinaryString(long value)
value
- the long value to be converted.public static java.lang.String toBinaryString(byte[] value)
value
- The byte array to be converted.public static java.lang.String slotInfoFlagsToString(long flags)
flags
- The flags to be converted.public static java.lang.String tokenInfoFlagsToString(long flags)
flags
- The flags to be converted.public static java.lang.String sessionInfoFlagsToString(long flags)
flags
- The flags to be converted.public static java.lang.String sessionStateToString(long state)
state
- The state to be converted.public static java.lang.String mechanismInfoFlagsToString(long flags)
flags
- The flags to be converted to a string representation.public static java.lang.String mechanismCodeToString(long mechansimCode)
mechansimCode
- The code of the mechanism to be converted to a string.public static java.lang.String classTypeToString(long classType)
classType
- The classType to be converted.public static boolean equals(byte[] array1, byte[] array2)
null
or both have the same length and
contain exactly the same byte values.array1
- The first array.array2
- The second array.null
or both have the same
length and contain exactly the same byte values. False, otherwise.public static boolean equals(char[] array1, char[] array2)
null
or both have the same length and
contain exactly the same char values.array1
- The first array.array2
- The second array.null
or both have the same
length and contain exactly the same char values. False, otherwise.public static boolean equals(long[] array1, long[] array2)
null
or both have the same length and
contain exactly the same byte values.array1
- The first array.array2
- The second array.null
or both have the same
length and contain exactly the same byte values. False, otherwise.public static boolean equals(CK_DATE date1, CK_DATE date2)
null
or both contain exactly the same char
values.date1
- The first date.date2
- The second date.null
or both contain the same
char values. False, otherwise.public static int hashCode(byte[] array)
array
- The byte array.public static int hashCode(char[] array)
array
- The char array.public static int hashCode(long[] array)
array
- The long array.public static int hashCode(CK_DATE date)
date
- The date object.public static boolean isFullEncryptDecryptMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.public static boolean isSingleOperationEncryptDecryptMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.public static boolean isFullSignVerifyMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.public static boolean isSingleOperationSignVerifyMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.public static boolean isSignVerifyRecoverMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.public static boolean isDigestMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.public static boolean isKeyGenerationMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.public static boolean isKeyPairGenerationMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.public static boolean isWrapUnwrapMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.public static boolean isKeyDerivationMechanism(long mechanismCode)
mechanismCode
- The code of the mechanism to check.
|
IAIK PKCS#11 Wrapper version 1.3 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


The JSONStreamPrinter
structure provides an imperative
printer for producing JSON output.
Synopsis
structure JSONStreamPrinter
Interface
type printer
val new : TextIO.outstream -> printer
val new' : {strm : TextIO.outstream, pretty : bool} -> printer
val close : printer -> unit
val null : printer -> unit
val boolean : printer * bool -> unit
val integer : printer * IntInf.int -> unit
val float : printer * real -> unit
val string : printer * string -> unit
val beginObject : printer -> unit
val objectKey : printer * string -> unit
val endObject : printer -> unit
val beginArray : printer -> unit
val endArray : printer -> unit
Description
type printer
-
The abstract type of the pretty-printer state.
val new : TextIO.outstream -> printer
-
new outS
creates a new printer from the outputstreamoutS
. The printer produces a condensed format without newlines or indentation; use thenew'
function to create a pretty-printer for JSON output. val new' : {strm : TextIO.outstream, pretty : bool} -> printer
-
new' {strm, pretty}
creates a new pretty-printing stream from the output streamstrm
, where the value of thepretty
field controls whether the output is condensed (whenpretty
isfalse
) or printed with new lines and indentation to improve readability (whenpretty
istrue
). val close : printer -> unit
-
close pr
closes the printer, but not the underlying output stream. Closing the printer while there is an open object or array results in theFail
exception being raised. Also, calling any of the below printing functions on a closed printer will result in theFail
exception being raised. val null : printer -> unit
-
null pr
prints the JSON null value. Raises theFail
exception if the printer is closed. val boolean : printer * bool -> unit
-
boolean (pr, b)
prints the JSON boolean valueb
. Raises theFail
exception if the printer is closed. val integer : printer * IntInf.int -> unit
-
integer (pr, n)
prints the JSON numbern
. Raises theFail
exception if the printer is closed. val float : printer * real -> unit
-
float (pr, r)
prints the JSON floating-point numberr
. Raises theFail
exception if the printer is closed. val string : printer * string -> unit
-
string (pr, s)
prints the JSON strings
. Raises theFail
exception if the printer is closed. val beginObject : printer -> unit
-
beginArray pr
prints the opening “{” for a JSON object. Note that each call tobeginObject
should be matched by a call toendObject
. Raises theFail
exception if the printer is closed. val objectKey : printer * string -> unit
-
objectKey (pr, key)
prints the JSON key-valuekey
followed by a “:”. This function should be inside matchedbeginObject
/endObject
calls and should be followed by the printing of a JSON value. Raises theFail
exception if the printer is closed. val endObject : printer -> unit
-
endObject pr
prints the closing}
for the currently open object. TheFail
exception is raised if the current context is not an open object, if a key has been printed without an associated value, or if the printer is closed. val beginArray : printer -> unit
-
beginArray pr
prints the opening “[” for a JSON array. Note that each call tobeginArray
should be matched by a call toendArray
. Raises theFail
exception if the printer is closed. val endArray : printer -> unit
-
endArray pr
prints the closing]
for the currently open array. TheFail
exception is raised if the current context is not an open array or if the printer is closed.


XML serialization and parsing support
Juneau supports converting arbitrary POJOs to and from XML using ultra-efficient serializers and parsers.
The XML serializer converts POJOs directly to XML without the need for intermediate DOM objects.
Likewise, the XML parser uses a STaX parser and creates POJOs directly without intermediate DOM objects.
Unlike frameworks such as JAXB, Juneau does not require POJO classes to be annotated to produce
and consume XML.
For example, it can serialize and parse instances of any of the following POJO types:
String
, Integer
, Boolean
, Float
).
HashSet
, TreeMap
) containing anything on this list.
Strings
(e.g. classes containing toString()
, fromString()
, valueOf()
, constructor(String)
).
In addition to the types shown above, Juneau includes the ability to define transforms to transform non-standard object and
property types to serializable forms (e.g. to transform Calendars
to and from ISO8601
strings,
or byte[]
arrays to and from base-64 encoded strings).
These transforms can be associated with serializers/parsers, or can be associated with classes or bean properties through type and method annotations.
Refer to POJO Categories for a complete definition of supported POJOs.
While annotations are not required to produce or consume XML, several XML annotations are provided for handling namespaces and fine-tuning the format of the XML produced.
The Juneau XML serialization and parsing support does not require any external prerequisites. It only requires Java 1.6 or above.
The example shown here is from the Address Book resource located in the org.apache.juneau.sample.war
application.
The POJO model consists of a List
of Person
beans, with each Person
containing
zero or more Address
beans.
When you point a browser at /sample/addressBook
, the POJO is rendered as HTML:
By appending ?Accept=mediaType&plainText=true
to the URL, you can view the data in the various supported XML formats:
In addition to serializing POJOs to XML, Juneau includes support for serializing the POJO metamodel to XML Schema, with support for multiple namespaces.
{@link org.apache.juneau.xml.XmlSerializer} is the class used to convert POJOs to XML.
{@link org.apache.juneau.xml.XmlDocSerializer} is a subclass that adds an XML declaration element to the output before the POJO is serialized.
The XML serializer includes many configurable settings.
Static reusable instances of XML serializers are provided with commonly-used settings:
In addition, DTO beans are provided that use the XML serializer and parser for the following languages:
Refer to the package-level Javadocs for more information about those formats.
The examples shown in this document will use single-quote, readable settings.
For brevity, the examples will use public fields instead of getters/setters to reduce the size of the examples.
In the real world, you'll typically want to use standard bean getters and setters.
To start off simple, we'll begin with the following simplified bean and build upon it.
The following code shows how to convert this to simple XML (no namespaces):
Side note: Serializers can also be created by cloning existing serializers:
The code above produces the following output:
The first thing you may notice is how the bean instance is represented by the element
When objects have no name associated with them, Juneau provides a default generalized name that maps to the equivalent JSON data type.
Some cases when objects do not have names:
The generalized name reflects the JSON-equivalent data type.
The full list of generalized element names are:
Map
element.
Collection
element.
Juneau produces JSON-equivalent XML, meaning any valid JSON document can be losslessly converted into an XML equivalent.
In fact, all of the Juneau serializers and parsers are built upon this JSON-equivalency.
Just because Juneau allows you to serialize ordinary POJOs to XML doesn't mean you are limited to just JSON-equivalent XML.
Several annotations are provided in the {@link org.apache.juneau.xml.annotation} package for customizing the output.
The {@link org.apache.juneau.annotation.Bean#typeName()} annotation can be used to override the Juneau default name on unnamed objects.
The {@link org.apache.juneau.xml.annotation.Xml#childName()} annotation can be used to specify the name of XML child elements for bean properties of type collection or array.
The {@link org.apache.juneau.xml.annotation.Xml#format()} annotation can be used to tweak the XML format of a POJO.
The value is set to an enum value of type {@link org.apache.juneau.xml.annotation.XmlFormat}.
This annotation can be applied to both classes and bean properties.
String
, Number
).
Collection
.
The {@link org.apache.juneau.xml.annotation.XmlFormat#CONTENT} annotation can be used to serialize a bean straight to text without any child elements.
There are some restrictions when using the
The class type on the property can be anything that serializes to a simple value, like a String
or Number
.
Note that transforms can usually be used to convert more complex class types to simple types.
The {@link org.apache.juneau.xml.annotation.Xml#contentHandler()} annotation is an advanced feature that allows you to define your own code for serializing and parsing the contents of a serialized bean.
For example, the ATOM specification allows for the media type of Text
elements to be specified via a
To accomplish this, the {@link org.apache.juneau.dto.atom.Text} class uses a content handler that serializes and parses the value by inspecting the
Refer to {@link org.apache.juneau.xml.XmlContentHandler} for more information.
Let's go back to the example of our original Person
bean class:
However, this time we'll leave namespaces enabled on the serializer:
Now when we run this code, we'll see namespaces added to our output:
This isn't too exciting yet since we haven't specified any namespaces yet.
Therefore, everything is defined under the default Juneau
namespace.
The xsi
namespace is always present and is used to mark null property values with
.
Namespaces can be defined at the following levels:
It's typically best to specify the namespaces used at the package level.
We'll do that here for the package containing our test code.
We're defining four namespaces in this package and designating
Take special note that the
Other XML annotations are also modelled after JAXB.
However, since many of the features of JAXB are already implemented for all serializers and parsers
at a higher level through various general annotations such as {@link org.apache.juneau.annotation.Bean} and {@link org.apache.juneau.annotation.BeanProperty}
it was decided to maintain separate Juneau XML annotations instead of reusing JAXB annotations.
This may change in some future implementation, but for now it was decided that having separate Juneau XML annotations was less confusing.
On our bean class, we'll specify to use the
Now when we serialize the bean, we get the following:
We can simplify the output by setting the default namespace on the serializer so that all the elements do not need to be prefixed:
This produces the following equivalent where the elements don't need prefixes since they're already in the default document namespace:
One important property on the XML serializer class is {@link org.apache.juneau.xml.XmlSerializerContext#XML_autoDetectNamespaces XML_autoDetectNamespaces}.
This property tells the serializer to make a first-pass over the data structure to look for namespaces defined on classes and bean properties.
In high-performance environments, you may want to consider disabling auto-detection and providing your own explicit list of namespaces to the serializer
to avoid this scanning step.
The following code will produce the same output as before, but will perform slightly better since it avoids this prescan step.
The {@link org.apache.juneau.annotation.Bean @Bean} and {@link org.apache.juneau.annotation.BeanProperty @BeanProperty} annotations
are used to customize the behavior of beans across the entire framework.
In addition to using them to identify the resource URI for the bean shown above, they have various other uses:
For example, we now add a birthDate
property, and associate a transform with it to transform
it to an ISO8601 date-time string in GMT time.
By default, Calendars
are treated as beans by the framework, which is usually not how you want them serialized.
Using transforms, we can convert them to standardized string forms.
Next, we alter our code to pass in the birthdate:
Now when we rerun the sample code, we'll get the following:
Another useful feature is the {@link org.apache.juneau.annotation.Bean#propertyNamer()} annotation that allows you to plug in your own
logic for determining bean property names.
The {@link org.apache.juneau.PropertyNamerDashedLC} is an example of an alternate property namer.
It converts bean property names to lowercase-dashed format.
In our example, let's add a list-of-beans property to our sample class:
The Address
class has the following properties defined:
Next, add some quick-and-dirty code to add an address to our person bean:
Now when we run the sample code, we get the following:
Juneau provides the {@link org.apache.juneau.xml.XmlSchemaSerializer} class for generating XML-Schema documents
that describe the output generated by the {@link org.apache.juneau.xml.XmlSerializer} class.
This class shares the same properties as XmlSerializer
.
Since the XML output differs based on settings on the XML serializer class, the XML-Schema serializer
class must have the same property values as the XML serializer class it's describing.
To help facilitate creating an XML Schema serializer with the same properties as the corresponding
XML serializer, the {@link org.apache.juneau.xml.XmlSerializer#getSchemaSerializer()} method
has been added.
XML-Schema requires a separate file for each namespace.
Unfortunately, does not mesh well with the Juneau serializer architecture which serializes to single writers.
To get around this limitation, the schema serializer will produce a single output, but with multiple
schema documents separated by the null character (
Lets start with an example where everything is in the same namespace.
We'll use the classes from before, but remove the references to namespaces.
Since we have not defined a default namespace, everything is defined under the default Juneau namespace.
The code for creating our POJO model and generating XML Schema is shown below:
Now if we add in some namespaces, we'll see how multiple namespaces are handled.
The schema consists of 4 documents separated by a
For convenience, the {@link org.apache.juneau.xml.XmlSchemaSerializer#getValidator(SerializerSession,Object)} method is provided to create a {@link javax.xml.validation.Validator} using the input from the serialize method.
The XML serializer is designed to be used against POJO tree structures.
It expects that there not be loops in the POJO model (e.g. children with references to parents, etc...).
If you try to serialize models with loops, you will usually cause a StackOverflowError
to
be thrown (if {@link org.apache.juneau.serializer.SerializerContext#SERIALIZER_maxDepth} is not reached first).
If you still want to use the XML serializer on such models, Juneau provides the
{@link org.apache.juneau.serializer.SerializerContext#SERIALIZER_detectRecursions} setting.
It tells the serializer to look for instances of an object in the current branch of the tree and
skip serialization when a duplicate is encountered.
For example, let's make a POJO model out of the following classes:
Now we create a model with a loop and serialize the results.
What we end up with is the following, which does not serialize the contents of the c
field:
Without recursion detection enabled, this would cause a stack-overflow error.
Recursion detection introduces a performance penalty of around 20%.
For this reason the setting is disabled by default.
See the following classes for all configurable properties that can be used on this serializer:
The {@link org.apache.juneau.xml.XmlParser} class is the class used to parse Juneau-generated XML back into POJOs.
A static reusable instance of XmlParser
is also provided for convenience:
Let's build upon the previous example and parse the generated XML back into the original bean.
We start with the XML that was generated.
This code produced the following:
The code to convert this back into a bean is:
We print it out to JSON to show that all the data has been preserved:
{
id: 1,
name:
The XML parser is not limited to parsing back into the original bean classes.
If the bean classes are not available on the parsing side, the parser can also be used to
parse into a generic model consisting of Maps
, Collections
, and primitive
objects.
You can parse into any Map
type (e.g. HashMap
, TreeMap
), but
using {@link org.apache.juneau.ObjectMap} is recommended since it has many convenience methods
for converting values to various types.
The same is true when parsing collections. You can use any Collection (e.g. HashSet
, LinkedList
)
or array (e.g. Object[]
, String[]
, String[][]
), but using
{@link org.apache.juneau.ObjectList} is recommended.
When the map or list type is not specified, or is the abstract Map
, Collection
, or List
types,
the parser will use ObjectMap
and ObjectList
by default.
In some circumstances, the XML parser needs additional information to recreate the original data structure when various annotations (e.g. {@link org.apache.juneau.xml.annotation.Xml#childName()}, {@link org.apache.juneau.xml.annotation.Xml#format()}) are used.
For example, starting with this XML:
Let's try to parse this into an ObjectMap
.
What we end up with is the following:
{
uri:
Note that the addresses field does not parse correctly as an array of addresses.
Without the beans providing meta-information about the data structure, the XML
parser has no way of determining that it's an array.
To preserve this information, the {@link org.apache.juneau.xml.XmlSerializerContext#XML_addJsonTypeAttrs XML_addJsonTypeAttrs} property
is provided that will insert
Notice the various
Now when we parse this into an ObjectMap
and serialize it to JSON, we get the following:
{
uri:
Once parsed into a generic model, various convenience methods are provided on the ObjectMap
and ObjectList
classes to retrieve values:
As a general rule, parsing into beans is often more efficient than parsing into generic models.
And working with beans is often less error prone than working with generic models.
See the following classes for all configurable properties that can be used on this parser:
Juneau provides fully-integrated support for XML serialization/parsing in the REST server and client APIs.
The next two sections describe these in detail.
There are four general ways of defining REST interfaces with support for XML. Two using the built-in Juneau Server API, and two using the JAX-RS integration component.
In general, the Juneau REST server API is much more configurable and easier to use than JAX-RS, but beware that the author may be slightly biased in this statement.
The quickest way to implement a REST resource with XML support is to create a subclass of {@link org.apache.juneau.server.RestServletDefault}.
This class provides support for JSON, XML, HTML, URL-Encoding, and others.
The AddressBookResource
example shown in the first chapter uses the RestServletJenaDefault
class
which is a subclass of RestServletDefault
with additional support for RDF languages.
The start of the class definition is shown below:
Notice how serializer and parser properties can be specified using the @RestResource.properties()
annotation.
The
The remaining properties are specific to the HTML serializer.
The $L{...}
variable represent localized strings pulled from the resource bundle identified by the messages
annotation.
These variables are replaced at runtime based on the HTTP request locale.
Several built-in runtime variable types are defined, and the API can be extended to include user-defined variables.
See {@link org.apache.juneau.server.RestServlet#getVarResolver()} for more information.
This document won't go into all the details of the Juneau RestServlet
class.
Refer to the {@link org.apache.juneau.server} documentation for more information on the REST servlet class in general.
The rest of the code in the resource class consists of REST methods that simply accept and return POJOs.
The framework takes care of all content negotiation, serialization/parsing, and error handling.
Below are 3 of those methods to give you a general idea of the concept:
The resource class can be registered with the web application like any other servlet, or can be defined as a child of another resource through the {@link org.apache.juneau.server.annotation.RestResource#children()} annotation.
For fine-tuned control of media types, the {@link org.apache.juneau.server.RestServlet} class
can be subclassed directly.
The serializers/parsers can be specified through annotations at the class and/or method levels.
An equivalent AddressBookResource
class could be defined to only support XML using
the following definition:
Likewise, serializers and parsers can be specified/augmented/overridden at the method level like so:
The {@link org.apache.juneau.server.annotation.RestMethod#serializersInherit()} and
{@link org.apache.juneau.server.annotation.RestMethod#parsersInherit()} control how various artifacts
are inherited from the parent class.
Refer to {@link org.apache.juneau.server} for additional information on using these annotations.
XML media type support in JAX-RS can be achieved by using the {@link org.apache.juneau.server.jaxrs.DefaultProvider} class.
It implements the JAX-RS MessageBodyReader
and MessageBodyWriter
interfaces for all Juneau supported media types.
The DefaultProvider
class definition is shown below:
That's the entire class. It consists of only annotations to hook up media types to Juneau serializers and parsers.
The
To enable the provider, you need to make the JAX-RS environment aware of it. In Wink, this is accomplished by adding an entry to a config file.
Simply include a reference to the provider in the configuration file.
org.apache.juneau.server.jaxrs.DefaultProvider
Properties can be specified on providers through the {@link org.apache.juneau.server.jaxrs.JuneauProvider#properties()} annotation.
Properties can also be specified at the method level by using the {@link org.apache.juneau.server.annotation.RestMethod#properties} annotation, like so:
In general, the Juneau REST API is considerably more flexible than the JAX-RS API, since you can specify and override
serializers, parsers, properties, transforms, converters, guards, etc... at both the class and method levels.
Therefore, the JAX-RS API has the following limitations that the Juneau Server API does not:
XmlSerializer
with one set of properties on
one class, and another instance with different properties on another class.To provide support for only XML media types, you can define your own provider class, like so:
Then register it with Wink the same way as DefaultProvider
.
The {@link org.apache.juneau.client.RestClient} class provides an easy-to-use REST client interface with
pluggable media type handling using any of the Juneau serializers and parsers.
Defining a client to support XML media types on HTTP requests and responses can be done in one line of code:
The client handles all content negotiation based on the registered serializers and parsers.
The following code is pulled from the main method of the ClientTest
class in the sample web application, and
is run against the AddressBookResource
class running within the sample app.
It shows how the client can be used to interact with the REST API while completely hiding the negotiated content type and working with nothing more than beans.
String root =
Number of entries = 2 Deleted person Barack Obama, response = DELETE successful Deleted person George Walker Bush, response = DELETE successful Number of entries = 0 Created person Barack Obama, uri = http://localhost:9080/sample/addressBook/people/3 Created person George Walker Bush, uri = http://localhost:9080/sample/addressBook/people/4 Created address http://localhost:9080/sample/addressBook/addresses/7 Created address http://localhost:9080/sample/addressBook/addresses/8 Changed name, response = PUT successful New name = Barack Hussein Obama
*** fín ***


public interface Cache extends Mutex
This Cache is a low level cache and does not maintain its Object on and of itself. It is meant, to be controlled via
the generic CacheObserver
.
If it is not clear, you cannot declare time-periods for objects to maintain those. It keeps all Objects indefinitely!
| Modifier and Type | Method and Description |
|---|---|
void |
addAndOverride(Object object)
Sets an new instance into the Cache, ignoring previously set instances.
|
<T> void |
addCacheObserver(CacheObserver<T> cacheObserver)
Adds a
CacheObserver to this Cache. |
void |
addGeneralObserver(GeneralCacheObserver observer)
Adds an
GeneralCacheObserver to this Cache. |
void |
addNew(Object object)
Sets an new instance into the Cache.
|
void |
clearObservers()
Deletes all Observers.
|
int |
countObservers()
Returns the amount of Observers, that are saved within this Cache
|
static Cache |
create()
Instantiates a new Cache.
|
<T> Optional<T> |
get(Class<T> clazz)
Returns the internally maintained instance for the provided class.
|
boolean |
isSet(Class<?> clazz)
Returns, whether an instance exists for the provided class or not.
|
void |
remove(Class clazz)
Removes whatever instance is associated with the provided Class.
|
<T> void |
removeCacheObserver(CacheObserver<T> cacheObserver)
Removes a
CacheObserver from this Cache |
void |
removeGeneralObserver(GeneralCacheObserver observer)
Removes a
GeneralCacheObserver from this Cache |
void |
reset()
Clears the internally saved Observers as well as all internally saved Objects.
|
void |
update(Object object)
Updates an saved instance within the Cache.
|
static Cache create()
This instance is hidden. Do not cast, nor try to instantiate the implementation by yourself.
The implementation is an easy target to be object to change.
void update(Object object)
If the Object-type (Class) of your provided Object is set inside the Cache, this will update the previously saved instance with the new provided one.
If it is not set, nothing (apart from logging an warning) will happen.
object
- the Object that should be updatedvoid addNew(Object object)
If the Object-type (Class) of your provided Object is not yet set inside the Cache, this will set the provided instance.
If it is already set, nothing (apart from logging an warning) will happen.
object
- the Object that should be updatedvoid addAndOverride(Object object)
If the Object-type (Class) of your provided Object is not yet set inside the Cache, this will set the provided instance.
If the Object-type (Class) of your provided Object is set inside the Cache, this will update the previously saved instance with the new provided one.
object
- the Object that should be updatedvoid remove(Class clazz)
clazz
- the class of the Object you want to remove from this Cache<T> Optional<T> get(Class<T> clazz)
T
- the type, defined by the classclazz
- the class you want want to get the instance forboolean isSet(Class<?> clazz)
clazz
- the class you want to check for<T> void addCacheObserver(CacheObserver<T> cacheObserver)
CacheObserver
to this Cache.
Any set CacheObserver will be notified whenever the call of update(Object)
, addNew(Object)
,
addAndOverride(Object)
or remove(Class)
successfully passed for the Object you want to listen to.
Those callbacks are a great way (and in fact needed for the Registration mechanism) of getting notified.
T
- the Type of that CacheObservercacheObserver
- the CacheObserver, that should listen to this cache<T> void removeCacheObserver(CacheObserver<T> cacheObserver)
CacheObserver
from this CacheT
- the Type of that CacheObservercacheObserver
- the CacheObserver, that should be removedvoid addGeneralObserver(GeneralCacheObserver observer)
GeneralCacheObserver
to this Cache.
GeneralCacheObserver will be notified whenever any object changes within this Cache.
It is recommended to use addCacheObserver(CacheObserver)
, instead of this method.
observer
- the Observer, that should listen to this Cachevoid removeGeneralObserver(GeneralCacheObserver observer)
GeneralCacheObserver
from this Cacheobserver
- the Observer, that should be removedvoid clearObservers()
int countObservers()
void reset()
Copyright © 2018. All rights reserved.


Let's play!
Select your parameters:
The page will count up to your number from 1, with exceptions that you set:
- Every (First Divisor) number will become (First Divisor Name).
- Every (Second Divisor) number will become (Second Divisor Name).
- Numbers divisible by both divisors will become a combo of the names you've chosen!


{% with name = "college", items = colleges %}{% include "_filter.html" %}{% endwith %}
{% with name = "year", items = years, default = "Other" %}{% include "_filter.html" %}{% endwith %}
{% with name = "leave", items = leave, header = "On leave?" %}{% include "_filter.html" %}{% endwith %}
{% with name = "eli_whitney", items = eli_whitney, header = "Eli Whitney?" %}{% include "_filter.html" %}{% endwith %}
{% with name = "major", items = majors %}{% include "_filter.html" %}{% endwith %}
{#
Building
{% for building_code, building in building_codes.items() %}
{% endfor %}
{% with name = "entryway", items = entryways %}{% include "_filter.html" %}{% endwith %}
{% with name = "floor", items = floors %}{% include "_filter.html" %}{% endwith %}
{% with name = "suite", items = suites %}{% include "_filter.html" %}{% endwith %}
{% with name = "room", items = rooms %}{% include "_filter.html" %}{% endwith %}
#}


message_utils¶
-
namespace
EPD
A collection of use-case filters, namely for parsing usecase_config.txt, Counting and Color-Matching usecaseMode.
-
class
EPDObjectDetection
¶ - #include <message_utils.hpp>
An Easy Perception Deployment (EPD) ObjectDetection class object. This object functions as a transient container of inference results to transport them for processing in by Processor class object.
Public Functions
-
EPDObjectDetection
(size_t input_size)¶ A Constructor function. This object can only be called a known size to minimize memory use for storage.
Public Members
-
std::vector<std::array<float, 4>>
bboxes
¶ A vector of bounding boxes with xmin, ymin, xmax, ymax.
-
std::vector<uint64_t>
classIndices
¶ A vector of indices that indicate the numerical identities of corresponding bounding boxes of the same index.
-
std::vector<float>
scores
¶ A vector of indices that indicate the float confidence scores of corresponding bounding boxes of the same index.
-
std::vector<cv::Mat>
masks
¶ A vector of image-encoded 32FC1 greyscale masks for P3 results only.
-
size_t
data_size
¶ A set size for all vectors in class.
-
-
class
EPDObjectLocalization
¶ Public Functions
-
EPDObjectLocalization
(size_t input_size)¶ A Constructor function. This object can only be called a known size to minimize memory use for storage.
Public Members
-
std::vector<LocalizedObject>
objects
¶
-
size_t
data_size
¶ A set size for all vectors in class.
-
struct
LocalizedObject
¶
-
-
class


Oklahoma Hall of Fame inducts 8
by Staff ReportsThe Oklahoma Hall of Fame inducted its 2019 class Thursday night. Induction into the Hall is Oklahoma's highest honor, according to the Hall with 698 individuals who have been recognized since the first class in 1928.
The 2019 honorees were:
• James Day, an oilman from Pond Creek.
• Tricia Everest, a philanthropist and community leader from Oklahoma City.
• Gray Frederickson, an Oscar- and Emmy-winning producer from Oklahoma City.
• John Herrington, Native American astronaut from Wetumka.
• John Nickel, a businessman and philanthropist from Muskogee.
• J.C. Watts Jr., a former University of Oklahoma and CFL football player and a U.S. Congressman from Eufaula.
• Steve Largent, a former University of Tulsa and NFL football player and a U.S. Representative from Tulsa.
• Allen Wright (Kiliahote), Choctaw chief known for suggesting the name Oklahoma in 1866 (posthumous induction).
Correction: We erroneously referred to Allen Wright as Allen White in a photo cutline. We apologize for the error.


Algorithms Library in JavaScript
Class for finding Tangent between circles
Implementation from https://en.wikibooks.org/wiki/Algorithm_Implementation/Geometry/Tangents_between_two_circles
Void
The extended Euclidean algorithm is an algorithm to compute integers x and y such that given a and b. ax + by = gcd(a, b)
| Name | Type | Description | |
|---|---|---|---|
| a |
Number
|
Coefficient of x |
|
| b |
Number
|
Coefficient of y |
Object
Object containing value of x, y and gcd
Raises base to a power keeping mod in check
| Name | Type | Description | |
|---|---|---|---|
| a |
Number
|
Base |
|
| e |
Number
|
Power |
|
| mod |
Number
|
Mod Value |
Number
Base to a power keeping mod in check
Calculates GCD of two numbers
| Name | Type | Description | |
|---|---|---|---|
| a |
Number
|
First number |
|
| b |
Number
|
Second number |
Number
HCF or GCD of two numbers References: https://math.stackexchange.com/questions/927050/can-we-find-the-gcd-of-a-positive-and-negative-number
Calculates LCM of two numbers
| Name | Type | Description | |
|---|---|---|---|
| a |
Number
|
First number |
|
| b |
Number
|
Second number |
Number
LCM of two numbers
Calculates modular inverse of a number using Fermet's theorem
| Name | Type | Description | |
|---|---|---|---|
| a |
Number
|
Number for which inverse needs to be found |
|
| m |
Number
|
Mod val |
Number
Modular Inverse
Calculates modular inverse of a number
| Name | Type | Description | |
|---|---|---|---|
| a |
Number
|
Number for which inverse needs to be found |
|
| m |
Number
|
Mod val |
Number
Modular Inverse
Binary Search Algorithm
| Name | Type | Description | |
|---|---|---|---|
| sortedArray |
Array
|
Sorted Array to be searched |
|
| element |
Number
|
Element to be searched |
Number
Index of the element, if found
Exponential Search Algorithm
| Name | Type | Description | |
|---|---|---|---|
| sortedArray |
Array
|
Sorted Array to be searched |
|
| element |
Number
|
Element to be searched |
Number
Index of the element, if found
Interpolation Search Algorithm
| Name | Type | Description | |
|---|---|---|---|
| sortedArray |
Array
|
Sorted Array to be searched |
|
| element |
Number
|
Element to be searched |
Number
Index of the element, if found
Jump Search Algorithm
| Name | Type | Description | |
|---|---|---|---|
| sortedArray |
Array
|
Sorted Array to be searched |
|
| element |
Number
|
Element to be searched |
Number
Index of the element, if found
Linear Search Algorithm
| Name | Type | Description | |
|---|---|---|---|
| array |
Array
|
Array to be searched |
|
| element |
Number
|
Element to be searched |
Number
Index of the element, if found
Ternary Search Algorithm
| Name | Type | Description | |
|---|---|---|---|
| sortedArray |
Array
|
Sorted Array to be searched |
|
| element |
Number
|
Element to be searched |
Number
Index of the element, if found
Bubble Sorts the array
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
Array to be sorted |
Array
Sorted array
Count Sorts the array
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
Array to be sorted |
Array
Sorted array
Heap Sorts the array
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
Array to be sorted |
Array
Sorted array
Insertion Sorts the array
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
Array to be sorted |
Array
Sorted array
Merges the two array in sorted order
| Name | Type | Description | |
|---|---|---|---|
| leftList |
Array
|
Left array |
|
| rightList |
Array
|
Right array |
Array
Merged array
Recursive function to divide array into two halves and merge the sorted array
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
Array to be sorted |
Array
Sorted Array
Merge Sorts the array
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
Array to be sorted |
Array
Sorted array
Create a partition and sort the individual parts
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
List to be sorted |
|
| low |
Number
|
Left index |
|
| high |
Number
|
Right index |
List
List containing sorted list and partition index
Recursive function to create partition and sort the halves
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
List to be sorted |
|
| low |
Number
|
Left index |
|
| high |
Number
|
Right index |
List
Sorted list
Quick sorts the array
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
Unsorted List |
|
| low |
Number
|
Left index |
|
| high |
Number
|
Right index |
Array
Sorted list
Selection Sorts the array
| Name | Type | Description | |
|---|---|---|---|
| list |
Array
|
Array to be sorted |
Array
Sorted array
Check if Doubly Linked List is empty or not
Boolean
true
if empty else false
Pushes node to the head of Doubly Linked List
| Name | Type | Description | |
|---|---|---|---|
| data | Data or value contained in Node |
None
Inserts node after a given node
| Name | Type | Description | |
|---|---|---|---|
| prevNode |
Node
|
Node after which insertion needs to take place |
|
| data | Data or value contained in Node |
None
Inserts node before a given node
| Name | Type | Description | |
|---|---|---|---|
| node |
Node
|
Node before which insertion needs to take place |
|
| data | Data or value contained in Node |
Node
Delete node from the list
| Name | Type | Description | |
|---|---|---|---|
| node |
Node
|
Node to be deleted |
None
Returns node at given index
| Name | Type | Description | |
|---|---|---|---|
| index |
Number
|
Index of required node |
Node
Required node
Returns string representing the Doubly Linked List
String
String representation of Doubly Linked List
Builds Fenwick Tree
| Name | Type | Description | |
|---|---|---|---|
| array |
Array
|
Array elements to be used to build the tree |
None
Gets prefix sum of the array using the tree
| Name | Type | Description | |
|---|---|---|---|
| index |
Number
|
Index till which sum needs to be calculated |
Number
Prefix sum
Updates the tree with adding element to given index
| Name | Type | Description | |
|---|---|---|---|
| index |
Number
|
Index of element to be updated |
|
| element |
Number
|
Element to be added |
None
Calculates range sum from given index to given index
| Name | Type | Description | |
|---|---|---|---|
| left |
Number
|
Left index |
|
| right |
Number
|
Right index |
Number
Range sum
Adds vertex to the Graph
| Name | Type | Description | |
|---|---|---|---|
| vertex |
Number
|
Vertex label |
Void
Adds edge between two vertices
| Name | Type | Description | |
|---|---|---|---|
| vertexA |
Number
|
Starting vertex label |
|
| vertexB |
Number
|
Ending vertex label |
|
| weight |
Number
|
Weight to be added for edge |
Void
Removes vertex from the Graph
| Name | Type | Description | |
|---|---|---|---|
| vertex |
Number
|
Vertex label |
Void
Removes edge between two vertices
| Name | Type | Description | |
|---|---|---|---|
| vertexA |
Number
|
Starting vertex label |
|
| vertexB |
Number
|
Ending vertex label |
Void
Check whether one vertex is neighbour to another
| Name | Type | Description | |
|---|---|---|---|
| vertexA |
Number
|
Origin vertex |
|
| vertexB |
Number
|
Vertex to be checked for |
Boolean
True if neighbour else False
Returns neighbours of a given vertex
| Name | Type | Description | |
|---|---|---|---|
| vertex |
Number
|
Vertex whose neighbours are required |
Array
List of neighbouring vertices
Returns edge weight of edge between two vertices
| Name | Type | Description | |
|---|---|---|---|
| vertexA |
Number
|
Starting Vertex label |
|
| vertexB |
Number
|
Ending Vertex label |
Number
Edge weight
Depth First Search
| Name | Type | Description | |
|---|---|---|---|
| root |
Number
|
Root vertex |
|
| callback |
Function
|
Function to be called on each vertex |
Void
Breadth First Search
| Name | Type | Description | |
|---|---|---|---|
| root |
Number
|
Root vertex |
|
| callback |
Function
|
Function to be called on each vertex |
Void
Build Heap
| Name | Type | Description | |
|---|---|---|---|
| data | Single element or array of data to be used for Heap |
None
Get parent of index
| Name | Type | Description | |
|---|---|---|---|
| index |
Number
|
Index for which parent is required |
Number
Parent of index
Get index of left node
| Name | Type | Description | |
|---|---|---|---|
| index |
Number
|
Index for which left node index is needed |
Number
Index of left node
Get index of right node
| Name | Type | Description | |
|---|---|---|---|
| index |
Number
|
Index for which right node index is needed |
Number
Index of right node
Swap nodes
| Name | Type | Description | |
|---|---|---|---|
| x |
Number
|
Index of node one |
|
| y |
Number
|
Index of node two |
None
Heapifies the array
| Name | Type | Description | |
|---|---|---|---|
| index |
Number
|
Index of root |
None
Pushes node to the Heap
| Name | Type | Description | |
|---|---|---|---|
| element | Value to be inserted |
None
Pushes node to the end of Linked List
| Name | Type | Description | |
|---|---|---|---|
| data | Data or value contained in Node |
LinkedList
this
Pops node from particular place in Linked List
| Name | Type | Description | |
|---|---|---|---|
| index |
Number
|
Index of node from end of the list |
LinkedList
this
Returns node at particular index else throws error if index out of range
| Name | Type | Description | |
|---|---|---|---|
| index |
Number
|
Index of node from end |
Node
Required node
Returns first occurance of node with given value
| Name | Type | Description | |
|---|---|---|---|
| value | Value to be searched |
Node
First occurance of node with given value else -1
Returns Linked List as Array
Array
Array containing values of Linked List
Iterates over all nodes of linked list and runs function on the node value
| Name | Type | Description | |
|---|---|---|---|
| func |
func
|
Function containing logic to be applied to node value |
None
Returns string representing the linked list
string
String representation of linked list
Pushes node in Queue
| Name | Type | Description | |
|---|---|---|---|
| data | Data or value to be pushed |
None
Pushes node in Stack
| Name | Type | Description | |
|---|---|---|---|
| data | Data or value to be pushed |
None
Inserts data into trie
| Name | Type | Description | |
|---|---|---|---|
| data |
String
|
String to be inserted |
|
| val | Leaf node value |
Node
Inserted node in trie
Searches and returns whether word exists in trie
| Name | Type | Description | |
|---|---|---|---|
| data |
String
|
Data to be searched |
val of leaf node, if exist else false
Recursively deletes word from the trie
| Name | Type | Description | |
|---|---|---|---|
| node |
Node
|
Current node being explored |
|
| data |
String
|
Word to be deleted |
|
| level |
Integer
|
Depth looked in trie |
|
| length |
Integer
|
Length of word |
Boolean
true if deleted else false
Word to be deleted
| Name | Type | Description | |
|---|---|---|---|
| data |
String
|
Word to be deleted |
Boolean
true if deleted else false


This is a contact management app developed for EuroCommercial.
It comprises a front-end mobile app (for iPhone and Android) along with this, the back-end administration app.
The app is implemented using Apache Isis™ for the
back-end, with Ionic Framework for the front-end.
The software is open source (Apache v2.0) with the
source code hosted at github.
The software was developed by incode.


6.2-Magnitude Earthquake Strikes Off Chiapas in Mexico - EMSC
A strong 6.2-magnitude earthquake has struck 120 kilometres west of the Mexican state's Suchiate region, the US Geological Survey (USGS) reported.
According to the USGS, the quake occurred at a depth of 26.1 kilometres.
There were no immediate reports of casualties or damage cased by the quake.
The European-Mediterranean Seismological Centre (EMSC) has estimated the quake as being 6.2 in magnitude and occurring at a depth of 60 kilometres, 87 kilometres southwest of Puerto Madero.
No tsunami warning has been issued.


{@link com.jme.network.kernel.Kernel} defines the core of a server-side message broker that abstracts away the specific transport and underlying threading model used. For example, it might use NIO selectors in a single threaded model or straight multithreaded socket model. Or it might implement SSL connections. Once created, {@link com.jme.network.kernel.Kernel} users don't need to care about the details.
{@link com.jme.network.kernel.Endpoint} is a managed connection within a {@link com.jme.network.kernel.Kernel} providing kernel to client connectivity.
{@link com.jme.network.kernel.Connector} defines the basic client-side message sender and these objects are typically used to connect to a {@link com.jme.network.kernel.Kernel} though they can connect to any network port that supports the implementation's protocol. Implementations are provided for straight TCP and UDP communication and could be extended to support SSL or different threading models.


Toggle navigation
Account
Sign in
Register
A game by Anko&Hars
NinjaVsNazi.io
PSEUDO
Next
GAMEMODES
FFA
Free For All, respawn enabeld. Work on your streaks and defeat your opponents.
King of the Hill
Respawn disabeld, the gaz is spreading. Everyone is an ennemy, be the last man standing.
Ground War
Respawn enabled, team game. Play with your allies and take territoires across the map.
Next
SKINS
Congolese Ninja
Angry German
Next
PLAY
Play
Continue


I'm A Celebrity odds revealed and there's a clear favourite to win already
The new series of I'm A Celebrity hasn't even started yet but bookies have already named their favourite to win
by Simon DukeThere are now just days to go until the return of I'm A Celebrity Get Me Out of Here, bit before the new series has even started, bookies have named their favourite to win.
It's hard to believe that it's been 17 years since I'm A Celebrity first hit our screens, with Tony Blackburn the ITV show's first ever winner.
Since then the likes of Kerry Katona, Dougie Poynter, Christopher Biggins, Vicky Pattison and Scarlett Moffatt have all triumphed in the jungle and before long, we now know who'll be following in their footsteps this year.
The I'm A Celebrity line-up for this year includes Girls Aloud singer Nadine Coyle, GMB host Kate Garraway and Radio DJ Adele Roberts who has a reality TV past.
But none of them are the bookies hot tip to win. As things stand, they are tipping football legend Ian Wright to take the jungle crown this year, with the former Arsenal and England striker's odds as short as 5/2.
The current I'm A Celebrity winner odds in full, according to William Hill are:
5/2 Ian Wright
9/2 James Haskell
5/1 Roman Kemp,
7/1 Jacqueline Jossa
9/1 Caitlyn Jenner
11/1 Kate Garraway
12/1 Myles Stephenson
14/1 Nadine Coyle
18/1 Andrew Maxwell
25/1 Adele Roberts


You've ended up somewhere you probably shouldn't have.
If this is in error, it should be resolved soon enough
Here are your details if you were wondering:
user: {{ kitty.user }}
ip: {{ kitty.user_ip }}
requested_url: {{ kitty.requested_uri }}
timestamp: {{ kitty.timestamp }}


Welcome to Moz - Connect
Join the Army of Awesomeness with Mozilla MozPacers now, and start contributing to Open Source
Please fill in the form below to get updates on latest events and happenings by MozPacers
{{ message }}
Please fill in the form below to get updates on latest events and happenings by MozPacers


--- layout: post title: A note on TFSConfig OfflineDetach date: '2017-02-14T16:16:00.001Z' author: Matteo Emili tags: modified_time: '2017-02-14T16:16:56.581Z' blogger_id: tag:blogger.com,1999:blog-9050180307874313601.post-5884670655510889967 blogger_orig_url: https://mattvsts.blogspot.com/2017/02/a-note-on-tfsconfig-offlinedetach.html ---
I already mentioned the very useful TFSConfig OfflineDetach in the past. Today I used it once again, and I realised a very important information is missing.
What you need to remember is that the Configuration Database you need to use is the one which has the Collection you want to detach in it. And it must be offline as well.
So in today’s situation (moving a collection across domains in a new instance) I had to restore the configuration database as well as the collection’s.


Disconnecting entities¶
To disconnect a user from other data, perform a DELETE operation against the same endpoint at which you posted to create the connection.
Request syntax¶
Disconnect by UUID
curl -X DELETE https://api.tbaas.co/<org>/<app>/<connecting_collection>/<connecting_entity>/<relationship>/<connected_entity>
Disconnect by ‘name’ property
curl -X DELETE https://api.tbaas.co/<org>/<app>/<connecting_collection>/<connecting_entity>/<relationship>/<connected_collection>/<connected_entity>
Parameters
| Parameter | Description |
|---|---|
| org | Organization UUID or organization name |
| app | Application UUID or application name |
| connecting_collection | Name or UUID of the collection of the connecting entity. |
| connecting_entity | Name or UUID of the connecting entity. |
| relationship | Type of connection being created (e.g., likes) |
| connected_collection | Name or UUID of the collection of the entity being connected to. |
| connected_entity | Name or UUID of the entity being connected to. |
If the connecting entity is a ‘user’ entity, the ‘username’ should be used rather than the ‘name’.
‘connected_collection’ is not required if the entity being connected to is specified by its UUID.Parameter
Example request
curl -X DELETE https://api.tbaas.co/your-org/your-app/users/Arthur/likes/users/Ford
Example response
{
"action" : "delete",
"application" : "k88dh4f-a166-11e2-a7f7-02e81adcf3d0",
"params" : { },
"path" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes",
"uri" : "https://api.tbaas.co/your-org/your-app/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes",
"entities" : [ {
"uuid" : "5bcc47ca-cfed-11e3-8bde-a7e008061e10",
"type" : "user",
"created" :<PHONE_NUMBER>556,
"modified" :<PHONE_NUMBER>556,
"username" : "Ford",
"activated" : true,
"metadata" : {
"connecting" : {
"likes" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/connecting/likes"
},
"path" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10",
"sets" : {
"rolenames" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/roles",
"permissions" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/permissions"
},
"connections" : {
"friends" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/friends",
"likes" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/likes"
},
"collections" : {
"activities" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/activities",
"devices" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/devices",
"feed" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/feed",
"groups" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/groups",
"roles" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/roles",
"following" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/following",
"followers" : "/users/58606d0a-cfed-11e3-a694-dbf5228024a7/likes/5bcc47ca-cfed-11e3-8bde-a7e008061e10/followers"
}
}
} ],
"timestamp" :<PHONE_NUMBER>195,
"duration" : 85,
"organization" : "your-org",
"applicationName" : "your-app"
}


HTTPRequestMethod
public enum HTTPRequestMethod
Represents the HTTP method used to issue a request.
-
Represents the HTTP
GET
method.Declaration
Swift
case get
-
Represents the HTTP
HEAD
method.Declaration
Swift
case head
-
Represents the HTTP
POST
method.Declaration
Swift
case post
-
Represents the HTTP
PUT
method.Declaration
Swift
case put
-
Represents the HTTP
PATCH
method.Declaration
Swift
case patch
-
Represents the HTTP
DELETE
method.Declaration
Swift
case delete
-
Represents the HTTP
OPTIONS
method.Declaration
Swift
case options
-
Represents the HTTP
TRACE
method.Declaration
Swift
case trace
-
Represents the HTTP
CONNECT
method.Declaration
Swift
case connect
-
Represents any HTTP method not covered by the other
case
s.Declaration
Swift
case unknown(String)
-
Returns a string representation of the
HTTPRequestMethod
. This is always the fully-uppercased version of its name.Declaration
Swift
public var asString: String


{% extends 'base.html' %} {% block title %}Dedupe sessions{% endblock %} {% block content %}
Let's get started on your first dedupe session.
Let's get started »
Start a new session »
We need a few moments to process your data. When we're done, you will be able to proceed to the next step.


Hello, and welcome to my "About Me" page! Thank you for playing my guessing game - I hope it was informative. On the left-side navigation bar of this site, please see additional categories with other information about me that you might be interested in. Thanks again for the visit!
The point of this "About Me" page is to showcase a few of the skills that I have been learning during my time at Code Fellows. I am currently in the 201 course, learning the basics of web development. I look forward to graduating and starting the 301 course next.
Below you'll find a sample of my graphics design work.


public final class DisplayConfig
extends java.lang.Object
Describes the characteristics of a particular logical display.
Robolectric internal (for now), do not use.
| Modifier and Type | Field and Description |
|---|---|
java.lang.String |
address
Display address, or null if none.
|
int |
appHeight
The height of the portion of the display that is available to applications, in pixels.
|
long |
appVsyncOffsetNanos
This is a positive value indicating the phase offset of the VSYNC events provided by Choreographer relative to the display refresh.
|
int |
appWidth
The width of the portion of the display that is available to applications, in pixels.
|
int |
colorMode
The active color mode.
|
int |
defaultModeId
The default display mode.
|
int |
flags
Display flags.
|
android.view.Display.HdrCapabilities |
hdrCapabilities
The display’s HDR capabilities
|
int |
largestNominalAppHeight
The largest value of
appHeight that an application is likely to encounter, in pixels, excepting cases where the height may be even larger due to system decorations such as the status bar being hidden, for example. |
int |
largestNominalAppWidth
The largest value of
appWidth that an application is likely to encounter, in pixels, excepting cases where the width may be even larger due to system decorations such as the status bar being hidden, for example. |
int |
layerStack
The surface flinger layer stack associated with this logical display.
|
int |
logicalDensityDpi
The logical display density which is the basis for density-independent pixels.
|
int |
logicalHeight
The logical height of the display, in pixels.
|
int |
logicalWidth
The logical width of the display, in pixels.
|
int |
modeId
The active display mode.
|
java.lang.String |
name
The human-readable name of the display.
|
int |
overscanBottom |
int |
overscanLeft |
int |
overscanRight |
int |
overscanTop |
java.lang.String |
ownerPackageName
The package name of the application that owns this display, or null if it is owned by the system.
|
int |
ownerUid
The UID of the application that owns this display, or zero if it is owned by the system.
|
float |
physicalXDpi
The exact physical pixels per inch of the screen in the X dimension.
|
float |
physicalYDpi
The exact physical pixels per inch of the screen in the Y dimension.
|
long |
presentationDeadlineNanos
This is how far in advance a buffer must be queued for presentation at a given time.
|
int |
removeMode |
int |
rotation
The rotation of the display relative to its natural orientation.
|
int |
smallestNominalAppHeight
The smallest value of
appHeight that an application is likely to encounter, in pixels, excepting cases where the height may be even smaller due to the presence of a soft keyboard, for example. |
int |
smallestNominalAppWidth
The smallest value of
appWidth that an application is likely to encounter, in pixels, excepting cases where the width may be even smaller due to the presence of a soft keyboard, for example. |
int |
state
The state of the display, such as
Display.STATE_ON . |
int[] |
supportedColorModes
The list of supported color modes
|
android.view.Display.Mode[] |
supportedModes
The supported modes of this display.
|
int |
type
Display type.
|
java.lang.String |
uniqueId
Unique identifier for the display.
|
| Constructor and Description |
|---|
DisplayConfig() |
DisplayConfig(DisplayConfig other) |
DisplayConfig(android.view.DisplayInfo other) |
| Modifier and Type | Method and Description |
|---|---|
void |
copyFrom(DisplayConfig other) |
void |
copyTo(android.view.DisplayInfo other) |
boolean |
equals(DisplayConfig other) |
boolean |
equals(java.lang.Object o) |
int |
hashCode() |
java.lang.String |
toString() |
public int layerStack
The surface flinger layer stack associated with this logical display.
public int flags
Display flags.
public int type
Display type.
public java.lang.String address
Display address, or null if none. Interpretation varies by display type.
public java.lang.String name
The human-readable name of the display.
public java.lang.String uniqueId
Unique identifier for the display. Shouldn’t be displayed to the user.
public int appWidth
The width of the portion of the display that is available to applications, in pixels. Represents the size of the display minus any system decorations.
public int appHeight
The height of the portion of the display that is available to applications, in pixels. Represents the size of the display minus any system decorations.
public int smallestNominalAppWidth
The smallest value of appWidth
that an application is likely to encounter, in pixels, excepting cases where the width may be even smaller due to the presence of a soft keyboard, for example.
public int smallestNominalAppHeight
The smallest value of appHeight
that an application is likely to encounter, in pixels, excepting cases where the height may be even smaller due to the presence of a soft keyboard, for example.
public int largestNominalAppWidth
The largest value of appWidth
that an application is likely to encounter, in pixels, excepting cases where the width may be even larger due to system decorations such as the status bar being hidden, for example.
public int largestNominalAppHeight
The largest value of appHeight
that an application is likely to encounter, in pixels, excepting cases where the height may be even larger due to system decorations such as the status bar being hidden, for example.
public int logicalWidth
The logical width of the display, in pixels. Represents the usable size of the display which may be smaller than the physical size when the system is emulating a smaller display.
public int logicalHeight
The logical height of the display, in pixels. Represents the usable size of the display which may be smaller than the physical size when the system is emulating a smaller display.
public int overscanLeft
public int overscanTop
public int overscanRight
public int overscanBottom
public int rotation
The rotation of the display relative to its natural orientation. May be one of Surface.ROTATION_0
, Surface.ROTATION_90
, Surface.ROTATION_180
, Surface.ROTATION_270
.
The value of this field is indeterminate if the logical display is presented on more than one physical display.
public int modeId
The active display mode.
public int defaultModeId
The default display mode.
public android.view.Display.Mode[] supportedModes
The supported modes of this display.
public int colorMode
The active color mode.
public int[] supportedColorModes
The list of supported color modes
public android.view.Display.HdrCapabilities hdrCapabilities
The display’s HDR capabilities
public int logicalDensityDpi
The logical display density which is the basis for density-independent pixels.
public float physicalXDpi
The exact physical pixels per inch of the screen in the X dimension.
The value of this field is indeterminate if the logical display is presented on more than one physical display.
public float physicalYDpi
The exact physical pixels per inch of the screen in the Y dimension.
The value of this field is indeterminate if the logical display is presented on more than one physical display.
public long appVsyncOffsetNanos
This is a positive value indicating the phase offset of the VSYNC events provided by Choreographer relative to the display refresh. For example, if Choreographer reports that the refresh occurred at time N, it actually occurred at (N - appVsyncOffsetNanos).
public long presentationDeadlineNanos
This is how far in advance a buffer must be queued for presentation at a given time. If you want a buffer to appear on the screen at time N, you must submit the buffer before (N - bufferDeadlineNanos).
public int state
The state of the display, such as Display.STATE_ON
.
public int ownerUid
The UID of the application that owns this display, or zero if it is owned by the system.
If the display is private, then only the owner can use it.
public java.lang.String ownerPackageName
The package name of the application that owns this display, or null if it is owned by the system.
If the display is private, then only the owner can use it.
public int removeMode
Display.getRemoveMode()
public DisplayConfig()
public DisplayConfig(DisplayConfig other)
public DisplayConfig(android.view.DisplayInfo other)
public boolean equals(java.lang.Object o)
equals
in class java.lang.Object
public boolean equals(DisplayConfig other)
public int hashCode()
hashCode
in class java.lang.Object
public void copyFrom(DisplayConfig other)
public void copyTo(android.view.DisplayInfo other)
public java.lang.String toString()
toString
in class java.lang.Object


soma: General-Purpose Optimisation With the Self-Organising Migrating
Algorithm
This package provides an R implementation of the Self-Organising Migrating Algorithm, a general-purpose, stochastic optimisation algorithm. The approach is similar to that of genetic algorithms, although it is based on the idea of a series of “migrations” by a fixed set of individuals, rather than the development of successive generations. It can be applied to any cost-minimisation problem with a bounded parameter space, and is robust to local minima.
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=soma
to link to this page.


I love researching how to make things work, and with my recent completion of Seattle University's Front End Web Development Program, I am strapped with a new set of technical skills to help me do just that! Focusing on CSS3, HTML5, and JavaScript, I have created some exciting apps and projects to share online with the community.
Most recently I am working as a Business Analyst and Product Manager for clinical SaaS products. I have 10 years of collective experience in business development focusing on client retention, clinical product management and operational process improvement. I enjoy implementing solutions that encourage people work smarter, faster, and more effectively. Let's connect today!


Start Bootstrap can help you build better websites using the Bootstrap CSS framework! Just download your template and start going, no strings attached!
Find Out MoreErnie Trakas has tried cases for the better part of four decades. In that time, his practice has included civil and criminal litigation. For most of the past twenty years Ernie's practice has been focused on civil and disability rights, defending public school districts, colleges and universities, and businesses in federal discrimination cases under federal Civil Rights Act(s), American with Disabilities Act, Section 504 of the Rehabilitation Act of 1973, the Individuals with Disabilities Education Act, the Age Discrimination in Employment Act, and the Missouri Human Rights Act. Ernie has tried in the United States District Courts in Washington, D.C. and Missouri. He has also successfully argued cases before the United States Court of Appeals for the Eighth and District of Columbia Circuits. In 2017, tired of law firm politics, need to handle matters unrelated to civil rights, and the ever present pressure of hourly billing, Ernie decided to start his own firm so he could dedicate his practice exclusively to civil and disability rights cases. The Trakas Group was formed for that purpose. The Trakas Group, LLC is committed to continuing to do what its founder has done for two decades - providing unparalleled, quality representation in defending businesses, public school districts and institutions of higher education against claims of discrimination based on race, gender, disability, sexual orientation, or age.
Our templates are updated regularly so they don't break.
You can use this theme as is, or you can make changes!
We update dependencies to keep things fresh.
You have to make your websites with love these days!
Phone:<PHONE_NUMBER>
Cell:<PHONE_NUMBER>


Geometry
-
group
harp_geometry
The HARP Geometry module contains public functions for dealing with polygons and points on a spherical surface.
Functions
-
int
harp_geometry_get_point_distance
(double latitude_a, double longitude_a, double latitude_b, double longitude_b, double *distance) Calculate the distance between two points on the surface of the Earth in meters
This function assumes a spherical earth
- Return
0
, Success.-1
, Error occurred (check harp_errno).
- Parameters
latitude_a
: Latitude of first pointlongitude_a
: Longitude of first pointlatitude_b
: Latitude of second pointlongitude_b
: Longitude of second pointdistance
: Pointer to the C variable where the surface distance in [m] between the two points will be stored.
-
int
harp_geometry_has_point_in_area
(double latitude_point, double longitude_point, int num_vertices, double *latitude_bounds, double *longitude_bounds, int *in_area) Determine whether a point is in an area on the surface of the Earth
This function assumes a spherical earth.
The latitude/longitude bounds can be either vertices of a polygon (num_vertices>=3) or represent corner points that define a bounding rect (num_vertices==2).
- Return
0
, Success.-1
, Error occurred (check harp_errno).
- Parameters
latitude_point
: Latitude of the pointlongitude_point
: Longitude of the pointnum_vertices
: The number of vertices of the bounding polygon/rect of the arealatitude_bounds
: Latitude values of the bounds of the area polygon/rectlongitude_bounds
: Longitude values of the bounds of the area polygon/rectin_area
: Pointer to the C variable where the result will be stored (1 if point is in the area, 0 otherwise).
-
int
harp_geometry_has_area_overlap
(int num_vertices_a, double *latitude_bounds_a, double *longitude_bounds_a, int num_vertices_b, double *latitude_bounds_b, double *longitude_bounds_b, int *has_overlap, double *fraction) Determine the amount of overlap of two areas on the surface of the Earth
This function assumes a spherical earth. The overlap fraction is calculated as area(intersection)/min(area(A),area(B)).
The latitude/longitude bounds for A and B can be either vertices of a polygon (num_vertices>=3), or represent corner points that define a bounding rect (num_vertices==2).
- Return
0
, Success.-1
, Error occurred (check harp_errno).
- Parameters
num_vertices_a
: The number of vertices of the bounding polygon/rect of the first arealatitude_bounds_a
: Latitude values of the bounds of the area of the first polygon/rectlongitude_bounds_a
: Longitude values of the bounds of the area of the first polygon/rectnum_vertices_b
: The number of vertices of the bounding polygon/rect of the second arealatitude_bounds_b
: Latitude values of the bounds of the area of the second polygon/rectlongitude_bounds_b
: Longitude values of the bounds of the area of the second polygon/recthas_overlap
: Pointer to the C variable where the result will be stored (1 if there is overlap, 0 otherwise).fraction
: Pointer to the C variable where the overlap fraction will be stored (use NULL if not needed).
-
int
harp_geometry_get_area
(int num_vertices, double *latitude_bounds, double *longitude_bounds, double *area) Calculate the area size for a polygon on the surface of the Earth
This function assumes a spherical earth.
The latitude/longitude bounds for A and B can be either vertices of a polygon (num_vertices>=3), or represent corner points that define a bounding rect (num_vertices==2).
- Return
0
, Success.-1
, Error occurred (check harp_errno).
- Parameters
num_vertices
: The number of vertices of the bounding polygon/rectlatitude_bounds
: Latitude values of the bounds of the polygon/rectlongitude_bounds
: Longitude values of the bounds of the polygon/rectarea
: Pointer to the C variable where the area size will be stored (in [m2]).
-
int


Welcome to the Interactive Physics section. Here you will find interactive tutorials to guide you through some basic physics concepts leading to the physics of plasmas and fusion
In this module, you will explore two basic properties of matter: all matter has mass and it ocupies space. These two properties are combined to form an intrinsic characteristic, that of density.
Having learned about mass and volume in the previous module, perform a virtual experiment exploring the behaviour of different materials in a variety of liquids.
Electric and magnetic forces are dominant factors in many physical systems, particularly in plasma and fusion. This module will introduce these two concepts and explain the connection between the two.
In this module you'll explore the states of matter, particularly the fourth state of matter: plasma. More than 99% of the visible universe is plasma, including all of the stars.
Energy is not only an important physical concept, but it is of utmost importance for humanity and civilization. In this module we will explore the concept on energy from a physics perspective as well as discuss different energy sources on earth and the struggle to find viable alternative energy sources.
Having discussed the importance of green energies, we explain fusion, the energy in the sun and stars. In this final section we discuss the energy production in the center of stars and how we are working on reproducing this process here on earth.


Intro & Set Up
In continuation of last week’s AB testing setup , I now have a week’s worth of data to analyze and interpret. To briefly review, I wanted to test how many conversions, or clicks on a certain link on the home page, that the original and variants can gather. I hypothesized that the variant would outperform the original by a large margin. Setting up this AB testing was simple and involved setting up a goal in Google Analytics and importing it into Optimize. From there, I needed to define the length of time the testing would take, create a variant page with changes (in my case, simple changes to text and color).
Analysis
By implementing this AB testing I hoped to prove that a simple stylistic change can make all the difference in driving or funneling traffic. After a week of running this test the results showed that:
As you can see from the above, variant 1 has double the conversion percentage compared to the original. What is curious is that even though I set up the weight for each version of the page at 50/50, variant 1 had 40 sessions compared to the original’s 9. This is something I would have to investigate for future testing but as it stands, the proposed changes make all the difference.
I would point out that my overall conversion rate is lower than the initial conversion rate of 75% back in week 7 when the goal was initially set up but that is mostly unreliable data as the people I sent links to were tipped off on what to do. In my eyes, particularly for this page which isn’t set up for user interaction, anything close to 50% is a success.
Conclusion
If this were any other type of site that involved some type of commerce or marketing, I would absolutely implement this proposed change. I would also investigate how to improve that conversion rate to surpass 50% from the index.
It might also be in my best interest to make that link/goal a constant amongst all the pages. For this goal, there really is no need for a funnel as it links to several resources. If anything, my next Analytics’ goal should gather information on how many times a user ends up on the resource page no matter where on the page they are (the link is incorporated into the menu). A/B testing should test to see what changes could improve conversions from the menu.