@Strob two lines have been added in m_notary_testnet to add the new chain to notarizations
curl --url "http://<IP_ADDRESS>:7776" --data "{\"conf\":\"TXSCLCC.conf\",\"path\":\"${HOME#"/"}/.komodo/TXSCLCC\",\"unitval\":\"20\",\"zcash\":1,\"RELAY\":-1,\"VALIDATE\":0,\"prefetchlag\":........
curl --url "http://<IP_ADDRESS>:7776" --data "{\"timeout\":60000,\"agent\":\"iguana\",\"method\":\"dpow\",\"symbol\":\"TXSCLCC\",\"pubkey\":\"$pubkey\"}"
first "adds" the coin to iguana (iguana is able to talk with daemon and to receive curl commands like used for the split)
second launches the dpow (and should normally wait the split has been confirmed, but not a big deal)
(edited)


Jove is a pup. Hope is his mom. Jove sits on Hope's lap. Jove likes Hope a lot! Hope takes a long nap. Jove pokes Hope with his big nose. Hope gets up and gives Jove a big hug! A New Time Zone Jan's home is in Rome. He will take a jet to America. He will be in a later time zone. He thinks he will like it. Jan will ride a bike to a big lake. He will take a cap, mitt, and bat. w-HillJan will play games like other kids. "I will like it!" says Jan. "It will not be a bore. I will have fun."
in-context


--- layout: post title: 'Next Meeting: 17th of August' categories: - Meetings tags: [] status: publish type: post published: true meta: _edit_last: '2' --- We are still looking for presentations, so feel free to get in contact with us or send us a message on the mailing list.


--- title: Sticky Fix Example 2 layout: examples base: "../" ---
Scroll down... the right column is sticky
Keep scrolling down... the right column scrolls now too..


Using Connectors¶
Glad you have made it this far in the tutorials! By now, you have learned how to create Pools and Devices, send images via the command line and construct a simple anonymizer. Here we are going to demonstrate a simple use case using a Connectors. This scenario is useful for multiple researchers to share a common Connection to a PACS, allowing each to create custom anonymization rules and keep images isolated from other Pools.
Configure a Connector¶
A Connector defines a three party connection. The role of each party is:
PACS
An institutional PACS holding clinicial data. Must be configured to allow queries from the Query Pool, and send to the Destination Pool.Query Pool
A Notion pool with permission to query the PACS.Receiving Pool
A Notion pool configured as a PACS destination.
Using a Connector involves several steps.
- Enter a Query (can be an Excel spreadsheet, or an individual MRN (Medical Record Number))
Query Pool
sends a C-FIND request toPACS
- Query results are displayed and Studies to be retrieved are chosen
Receiving Pool
issues a C-MOVE toPACS
Receiving Pool
retrieves the images fromPACS
Receiving Pool
moves images into the local Pool for storage and anonymization.Receiving Pool
deletes received images.
Connectors are a complicated topic involving many moving parts, but from a study coordinator’s perspective, they are simple.
To add a Connector, click on the Connectors
link on the menu bar and then the plus icon next to Connectors:
Click Save to save the Connector and enable it for use. A Connector is accessible from any Pool.
NB: The Device used in a connector must not use a regular expression. The query and retieve require a correct Application Entity Title, full hostname and valid port. See DICOM Configuration for details.
Performing a Query¶
Clicking on Pools in the menu bar returns to the Pools view. Beside each Pool listed on the left side is a query link. Two modes of query are available. Both require the appropriate connector to be selected.
An individual query takes a MRN (Medical Record Number), typically a PaitentID and queries using the Connector. The interface is:
Multiple MRN’s may be specified using the spreadsheet query. A template spreadsheet is available through the Excel template link. The only required entry in each row is PatientID
, the other columns can be used to limit the query by Modality, Date, AccessionNumber, etc. Once the spreadsheet is filled out, it can be uploaded to Notion to start the query.
When the DICOM query is completed, a list of possible Studies is returned. Any checked Study will be retrieved and transferred to this pool.


Questions
Set Question:
Correct Answer:
Possible Answer 1:
Possible Answer 2:
Possible Answer 3:
Possible Answer 4:
Click to Capture another question
finished


Debugging SctpDrv
SctpDrv has lots of debugging output that can be enabled to track down problems. The first step is to build a checked version of the driver, sctp.sys. You can do this by setting the
DEBUG
environment
variable to 1 and then doing a build:> set DEBUG=1
> dobuild.cmd
Doing that will build debug symbols and enable you to step through the code using WinDBG. To enable debug output for the Windows specific SCTP code, edit drv\sctp.c and add flags from sys\systm.h to the
debug_on
variable around line 189. To obtain debug
output for the protocol code (incl. routing etc.) you need to build SctpDrv with -DSCTP_DEBUG (add it in sources.inc in the root of the source hierarchy) and add flags from
netinet\sctp_constants.h to the debug
sysctl via netsh.For example, to see which driver functions are called, use
DEBUG_GENERIC_VERBOSE
.See the sources for the meaning of the other flags.
Time: 17:55:00 GMT, November 5, 2010


Birds to interact with augmented reality in any type of environment with just a card and your camera
Un pequeño paseo virtual por Neuquén Capital
A nisi ullam ... cupiditate?


{% extends '../layouts/template.html' %} {% block title %}Check your State Pension - {{mvpversion}}{% endblock %} {% block serviceName %}Check your State Pension{% endblock %} {% block main %}
We need to speak to you before you can access your State Pension.
Telephone lines are open 8am to 8pm Monday to Friday and 8am to 4pm on Saturday.
Closed Sundays and bank holidays.
Telephone lines are less busy before 10am Monday to Friday.
Find out about call charges (opens in new window)


If you're here, you probably love the game of scrabble or are looking to start exploring this weird and wonderful world. In either case, accumulating resources to study and practice is particularly difficult since all available resources are scattered around the internet. We aim to solve this problem by providing you a one-stop destination for all your scrabble needs. We hope that this tool helps you find all that you're looking for and strive ahead on your way to becoming a scrabble champion!
Reach out to us on social media or write to us via mail.


Before Change
def setup_loss(self, loss_functions, output_target_map):
self.output_target_map = output_target_map
self.loss_dictionary = {
target: (loss_functions[fn.upper()].value(), float(weight))
for (fn, target, weight)
in self.options["loss_function"]
}
self.loss_keys = sorted(list(self.loss_dictionary))
After Change
self.loss_dictionary = {}
for (_fn, target, weights) in self.options["loss_function"]:
if "PIT" in _fn.upper():
loss_fn = _fn.split(":")[1]
loss_fn = loss_functions[loss_fn.upper()].value()
fn = loss_functions["PIT"].value(loss_fn)
else:
fn = loss_functions[_fn.upper()].value()


Summer Feelz: Very excited, a little overwhelmed, and so ready!!
Aspirational Hobby: If I had all the money in the world, I would run a non-profit farm sanctuary for animals rescued from slaughterhouses and egg/dairy farms as well as run an animal shelter for companion animals!
Ask me About: Veganism, music, and activism!
Rachel Ware
Summer Feelz: Excited, warm, improving
Aspirational Hobby: Sustainable clothing production, maybe other kinds of items too.
Ask me About: Education
Nicole Reinking
Summer Feelz: Motivated, slightly stressed, and super excited
Aspirational Hobby: Learn how to ride a horse. I have always wanted to since I was little, but just never had time or money for it.


By default all child elements of a grid have a default value of flex: 1 0 auto;
. This means that by default all cells will only be as wide as their content. If you would like a cell or all the cells to fill the remaining space, apply the .fl1
to the cell, or .grid__fl1
to the parent to apply to all children.
You can either fix the width of an individual element or fix the width of all child elements within a parent container by setting the width on the parent. The cell widths are based on a 12-column grid system.
{% header h3 | Fixed classes %}| Individual Width | Uniform Width | Output |
|---|---|---|
{{ item.class }} |
{{ item.all }} |
{{ item.output }} |
Grids can be nested within each other. This allows you to create unique, custom layouts without needing to create new, custom code or override existing styles.
.grid--cell
wrapper first. This allows the parent and child grid gutter spacing to act correctly without interfering with each other.


|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object saito.objloader.OBJModel
public class OBJModel
| Field Summary | |
|---|---|
static java.lang.String |
ABSOLUTE
|
Debug |
debug
|
static java.lang.String |
RELATIVE
|
| Constructor Summary | |
|---|---|
OBJModel(PApplet _parent)
Class Constructor to setup an empty obj model |
|
OBJModel(PApplet _parent,
java.lang.String _filename)
Class Constructor, loads the file from the data directory |
|
OBJModel(PApplet _parent,
java.lang.String _fileName,
int _shapeMode)
Class Constructor, loads the string as an obj from the data directory. |
|
OBJModel(PApplet _parent,
java.lang.String _fileName,
java.lang.String _texturePathMode)
Class Constructor, loads the file from the data directory. use String "relative" to search the data folder for the mtl and textures use "absolute" to load the files from the specific path |
|
OBJModel(PApplet _parent,
java.lang.String _fileName,
java.lang.String _texturePathMode,
int _shapeMode)
Class Constructor, loads the string as an obj from the data directory. |
| Method Summary | |
|---|---|
void |
clampUV()
Helper function to clamp the UV's so they sit within 0-1. |
void |
disableDebug()
|
void |
disableMaterial()
Disables the material completely. With this on you can set the appearance of the model in processing before calling model.draw(); background(32); stroke(255); noFill(); model.draw(); |
void |
disableTexture()
Turns off the use of the textures in mtl file. |
void |
draw()
The draw method of the OBJModel. This method used the standard Processing system of beginShape, endShape to draw the model. |
void |
drawGL()
Draws the obj model using the Vertex Buffers that were made in the setupOPENGL method NOTE: this method is on the way out. |
void |
enableDebug()
Enables the debug mode. Prints version and contact information to the console. |
void |
enableMaterial()
Turns on the use of the material that came from the mtl file |
void |
enableTexture()
Turns on the use of textures that are listed in the mtl file |
int |
getDrawMode()
Gets the drawmode |
int |
getFaceCount()
Gets the total number of faces in the model. This is the total of the index count across all segments This is mostly used when you need raw verts for physics simulation |
Face |
getFaceInSegment(int _segmentIndex,
int _faceIndex)
|
PVector[] |
getFaceVertices(int faceNumber)
Gets an array of PVectors that make up the position co-ordinates of the face. This method needs one int that must be between 0 and the getTotalFaceCount() This is mostly used when you need raw verts for physics simulation Personally I wouldn't do this during draw. |
Group |
getGroup(java.lang.String groupName)
Returns the group via name Until I find a practical use for Groups this feature isn't going anywhere. |
int |
getGroupCount()
Gets the size of the Groups from the obj Model. |
int |
getIndexCountInSegment(int i)
Gets the number of Indexes in the Segment. |
PVector |
getNormal(int i)
Returns a reference to a numbered Normal. |
int |
getNormalCount()
Get's the total number of Normals in the model. |
int[] |
getNormalIndicesInSegment(int i,
int num)
Returns an array of ints. |
Segment |
getSegment(int _index)
|
int |
getSegmentCount()
Gets the number of segments in the model. A segment is a unique material and an array of indexes into the vert, norm and uv Vectors |
int[] |
getTextureIndicesInSegment(int i,
int num)
Returns an array of ints. |
java.lang.String |
getTexturePathMode()
Should return "relative" or "absolute" |
PVector |
getUV(int i)
Returns a reference to a numbered Textured Coordinate. |
int |
getUVCount()
Get's the total number of UVs in the model. |
PVector |
getVertex(int i)
Returns a reference to a numbered Vertex. |
int |
getVertexCount()
Get's the total number of Verts in the model. |
int[] |
getVertexIndicesInSegment(int i,
int num)
Returns an array of ints. |
void |
load(java.lang.String filename)
The manual load method for obj files. |
void |
mapUVToZeroOne()
Helper function to scale the UV's so they sit within 0-1. |
void |
originalTexture()
Sets the override texture back to null. |
void |
printModelInfo()
A Debug method that prints information about the loaded model This method only prints information if the debugMode is true. V Size = The number of vertex positions Vt Size = The number of UV positions Vn Size = The number of normals G Size = the number of Groups in the model S Size = the number of segments in the model, this should directly equate to the number of unique materials in the mtl file |
void |
reset()
Clears all Vectors ready for loading in a new model. Doing something like this OBJModel model = new OBJModel(this, "myobj.obj"); // do something with model model.clear(); model.load("myobj.obj"); is vastly better for memory use than doing something like this OBJModel model = new OBJModel(this, "myobj.obj"); // do something with model model = new OBJModel(this, "myOtherObj.obj"); The second example is really bad because the original model is still in memory but nothing is pointing to it. We would have to wait for the Garbage Collector to do the clean up before freeing the memory. |
void |
scale(float scale)
Scales the vertex positions of the model. |
void |
scale(float scaleX,
float scaleY,
float scaleZ)
Scales the vertex positions of the model. |
void |
setDrawMode(int _drawMode)
Sets the draw mode of the shape drawing |
void |
setNormal(int i,
PVector normal)
Sets the Normal at index i to the PVector supplied |
void |
setTexture(PImage textureName)
Sets an override texture for the drawing of the model. Any PImage supplied will be used over all model segments NOTE: This method is identical to texture(), It has the better syntax. |
void |
setTexturePathMode(java.lang.String _texturePathMode)
Use "relative" or "absolute" to set the texture load method |
void |
setupGL()
Called after loading the obj model. |
void |
setUV(int i,
PVector uv)
Sets the UV at index i to the PVector supplied |
void |
setVertex(int i,
float x,
float y,
float z)
Sets the vert at index i to the x,y,z values supplied |
void |
setVertex(int i,
PVector vertex)
Sets the vert at index i to the PVector supplied |
void |
shapeMode(int mode)
Set's the beginShape mode for drawing the model. |
void |
texture(PImage tex)
Sets an override texture for the drawing of the model. Any PImage supplied will be used over all model segments |
void |
translate(PVector p)
Translates all the verts by the PVector amount |
void |
translateToCenter()
Helper function to move the origin point of the model to the center of the objects BoundingBox |
| Methods inherited from class java.lang.Object |
|---|
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
public static java.lang.String RELATIVE
public static java.lang.String ABSOLUTE
public Debug debug
| Constructor Detail |
|---|
public OBJModel(PApplet _parent)
public OBJModel(PApplet _parent, java.lang.String _filename)
public OBJModel(PApplet _parent, java.lang.String _fileName, int _shapeMode)
public OBJModel(PApplet _parent, java.lang.String _fileName, java.lang.String _texturePathMode)
public OBJModel(PApplet _parent, java.lang.String _fileName, java.lang.String _texturePathMode, int _shapeMode)
| Method Detail |
|---|
public void setupGL()
public void drawGL()
public void printModelInfo()
public void enableDebug()
public void disableDebug()
public void reset()
public void disableTexture()
public void enableTexture()
public void disableMaterial()
public void enableMaterial()
public void shapeMode(int mode)
int
- public void draw()
public void load(java.lang.String filename)
public void scale(float scale)
scale
- public void scale(float scaleX, float scaleY, float scaleZ)
scaleX
- scaleY
- scaleZ
- public void translate(PVector p)
p
- public void translateToCenter()
public void mapUVToZeroOne()
public void clampUV()
public void setDrawMode(int _drawMode)
_drawMode
- public int getDrawMode()
public void setTexturePathMode(java.lang.String _texturePathMode)
_texturePathMode
- public java.lang.String getTexturePathMode()
public int getGroupCount()
public Group getGroup(java.lang.String groupName)
String
-
public Segment getSegment(int _index)
public Face getFaceInSegment(int _segmentIndex, int _faceIndex)
public int getSegmentCount()
public int getFaceCount()
public PVector[] getFaceVertices(int faceNumber)
public int getIndexCountInSegment(int i)
int
-
public int[] getVertexIndicesInSegment(int i, int num)
int
- int
-
public int[] getNormalIndicesInSegment(int i, int num)
int
- int
-
public int[] getTextureIndicesInSegment(int i, int num)
int
- int
-
public int getVertexCount()
public int getNormalCount()
public int getUVCount()
public PVector getVertex(int i)
int
-
public PVector getNormal(int i)
int
-
public PVector getUV(int i)
int
-
public void setVertex(int i, PVector vertex)
int
- PVector
- public void setVertex(int i, float x, float y, float z)
i
- x
- y
- z
- public void setNormal(int i, PVector normal)
int
- PVector
- public void setUV(int i, PVector uv)
int
- PVector
- public void setTexture(PImage textureName)
PImage
- public void texture(PImage tex)
PImage
- public void originalTexture()
|
||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


{% extends "base.html" %} {% block content %}
When the web asks, "Who are you?", Whuru helps you answer.
Okay, so this service doesn't really exist yet, but I'd like it to. Consider this a concept car.
Coming soon Whuru lets you build a custom page to help humans discover things about you.
Coming soon Whuru uses the WebFinger protocol to help machines discover things about you.
Works in dev Whuru lets you log into sites and apps using Mozilla Persona.
(Right now, this site uses a self-signed SSL cert, because I'm cheap. Try logging in at dev.123done.org or login.dev.anosrep.org.)
Maybe someday Whuru IDs look like email addresses. Forward messages to your choice of inbox.
Maybe someday If you own a domain name, you can control your identity and delegate services to Whuru.
Available now Whuru is open source. Fork it, contribute code, install it on your own servers.


"ı am from Turkey . I am 22 years old. I am student Eskişehir Technical University's Computer Engineering and I am second years Student.
<EMAIL_ADDRESS>"She graduated Oxford University' Veterinary Medicine in 2003.
<EMAIL_ADDRESS>"He graduated Eskişehir Technical University's Veterinary Medicine in 2004.
<EMAIL_ADDRESS>We treat injured stray and wild animals who are brought to us by members of the public or our field staff, such as inspectors and animal welfare officers (AWOs).
From budgies to badgers, our dedicated veterinary staff help as many animals in need as possible.
There is a high demand for basic vet care, so we focus our resources right there - doing the basics well, and allowing us to treat more animals.
There is a high demand for basic vet care, so we focus our resources right there - doing the basics well, and allowing us to treat more animals.


{# The standard package navigation menu * `title` A possibly-null string. If it is null, `metadata.name metadata.version` will be used as the title * `metadata` A non-null instance of the MetaData struct * `active_tab` A string with one of the following values: * `crate` * `source` * `builds` * `features` Note: `false` here is acting as a pseudo-null value since you can't directly construct null values and tera requires all parameters without defaults to be filled #} {% macro package_navigation(title=false, metadata, active_tab) %}


Hi,
We've just had someone submit a contact form on the website. Their details (including which form they submitted) are listed below.


About¶
Eugene J. Ragasa¶
Education¶
PhD, Materials Science and Engineering, University of Florida
MSES, Mechanical Engineering, University of the Pacific
MA, Mathematical Finance, Columbia University
BS, Mathematics, United States Military Academy
Publications¶
Has not been done yet.
Presentations¶
Raman Spectra Simulation (Unpublished work)¶
The effect of anion intrinsic defects of Raman spectra on fluorite-structure materials with a particular focus on CaF2, CeO2, and UO2. Since CeO2 and UO2 require DFT+U corrections perturbational methods aren’t available to calculate Raman signatures. Instead the derivatives of the polarization tensor is calculated through the application of finite electric fields. DFT+U has the problem of creating metastable states which need to be resolved to find the ground state energy requiring the use of techniques such as occupation matrix control, +U ramping, and annealing. The value of this research for experimental researchers to resolve changes in Raman signatures to particular point defects. For computational scientists, this research will also explore techniques for resolving metastable states to the ground state, particuarly with the application of an electric field to the calculations.


$0275/629: Char to interpret ROM-Reference: CMP $0275 : $C16D $C273 STA $0275 : $C165 $C268 Previous Page / Next Page


This is a tool to instantly generate mock code for a given interface. This can be used to mock dependancies while writing unit tests. To no more about how to mock dependancies and write good unit tests, refer this.
Contribute to this project on github


| Interface | Description |
|---|---|
| ArchivedFileSet |
A file set, which consists of the files and directories in
an archive.
|
| ArchiveFile |
Interface of a zip, or tar file.
|
| ArchiveFileFilter | Deprecated
Use
FileSelector |
| ArchiveFinalizer |
An archive finalizer is just before archive creation (after user has added all files),
allowing the finalizer to do stuff like create manifests etc.
|
| Archiver | |
| BaseFileSet |
A file set is a set of files, which may be added to an
archive.
|
| FileSet |
A file set, which consists of the files and directories in
a common base directory.
|
| FinalizerEnabled | |
| ResourceIterator | |
| UnArchiver | |
| UnixStat |
Constants from stat.h on Unix systems.
|
| Class | Description |
|---|---|
| AbstractArchiveFinalizer | |
| AbstractArchiver | |
| AbstractUnArchiver | |
| ArchiveEntry | |
| DotDirectiveArchiveFinalizer |
An
ArchiveFinalizer that process dot files with archiver directives
contained within. |
| Exception | Description |
|---|---|
| ArchiveFilterException | |
| ArchiverException |
Copyright © 2001–2018 Codehaus Plexus. All rights reserved.


Members
(constant) AuthContext :context
Type:
- context
- Source:
(constant) initialState
initial state for reducer
- Source:
(constant) StateContext :context
Type:
- context
- Source:
(constant) StateProvider
state provider for global state to provide state wrap component with it.
- Source:
(constant) useStateValue
decorating useContext for easier understanding.
- Source:
Methods
App()
Properties:
| Name | Type | Description |
|---|---|---|
App |
function | the root method of the application containing routes and header |
- Source:
AuthProvider(children)
Auth provider method
Parameters:
| Name | Type | Description |
|---|---|---|
children |
Element |
- Source:
initialFetch() → {Promise}
initial fetch method
Properties:
| Type | Description |
|---|---|
| function |
- Source:
Returns:
- Type
- Promise
PrivateRoute(props)
private routs checks if current user exists then renders accordingly
Parameters:
| Name | Type | Description |
|---|---|---|
props |
PropTypes |
Properties:
| Type | Description |
|---|---|
| function |
- Source:
PublicRoute(props)
public routes checks if current user exists then renders accordingly
Parameters:
| Name | Type | Description |
|---|---|---|
props |
PropTypes |
Properties:
| Type | Description |
|---|---|
| function |
- Source:
Reducer(state, action)
a Reducer to maintain global state with the help of actions
Parameters:
| Name | Type | Description |
|---|---|---|
state |
Object | a global state |
action |
Object | an action declaring the type of process to perform |
- Source:
searchFetch() → {Promise}
search fetch method
Properties:
| Type | Description |
|---|---|
| function |
- Source:
Returns:
- Type
- Promise
useAuth() → {context}
decorative method to make use Auth simple
- Source:
Returns:
- Type
- context
Watchlist()
watchlist component
Properties:
| Type | Description |
|---|---|
| function |
- Source:


medSched
An all-in-one application for all of your medical needs.
{% if login %} Get started {% endif %} {% if not login %} Get started {% endif %}
An all-in-one application for all of your medical needs.
{% if login %} Get started {% endif %} {% if not login %} Get started {% endif %}


Power control¶
When running on battery, your script ought to conserve power. One way of doing this is to put the controller to
sleep for a certain amount of time. This can be done with the tbsense.deepsleep(s)
function, where s
is the number of seconds it will sleep for. Following are two code examples for reading the value of the
temperature sensor.
The first example reads the sensor data continuously:
import tbsense
while True:
tbsense.Environment.start()
temp = tbsense.Environment.temperature()
tbsense.Environment.stop()
print( temp )
The second example uses the tbsense.deepsleep()
function to control how often the sensor is read.
The micro controller goes to sleep between the sensor readings to conserve power:
import tbsense
while True:
tbsense.Environment.start()
temp = tbsense.Environment.temperature()
tbsense.Environment.stop()
print( temp )
tbsense.deepsleep(60)
The longer the chip is sleeping between the sensor readings, the less power is used.
Below is a comparison of how much energy is used with and without the deepsleep()
function.
Continuously reading of sensor.
Deepsleep for one minute between readings.
As seen above, the average current consumption while reading the temperature is 7.8 mA. By using the
deepsleep()
function and only performing readings every minute, the average current consumption is reduced
to approximately 8 \(\mu A\). Running this application on a coin cell battery with 250 mAh capacity, would result in a
battery life of 31 250 h, which is approximately 3.5 years.
Therefor it is a good idea to use the deepsleep()
fuction when making a battery powered application,
in order to increase battery life. It is also good practice to turn off sensors and LEDs not needed when running on battery.
The RGBLEDs should not be used when running on battery, as they consume a lot of power (119.6 mA for all 4 RGBLEDs).


--- title: "WASATCH CAMERA CLUB PHOTOGRAPHY EXHIBIT" date: "2016-04-07 00:00:00 -06:00" categories: - spring - exhibit subtitle: "" layout: "events" event-image: "wasatch-camera-club.jpg" event-dates: "MARCH 31 - APRIL 23, 2017" event-location: "Red Butte Garden" button-type: "" tickets-link: "" member-sale-date: "N/A" public-sale-date: "N/A" member-cost: "Free" public-cost: "Garden Admission" event-notes: "" tickets-button: "hide" published: true ---
Meet the Artists Reception
Saturday, April 8 from 2-4PM
The Wasatch Camera Club presents a photography exhibit featuring the botanical-inspired work of many of their club members.
The Wasatch Camera Club provides a rich and enjoyable environment for club members to improve their photography with six activities that support the Club's educational goal. These include: workshops, field trips, lectures, exhibits, competitions, and one-on-one mentoring. Join us for a better image.
For more please visit:
http://www.wasatchcameraclub.com/drupal/


Consultation outcome
PDF , 317KB , 6 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
We have decided to implement the Conditions, Requirements and guidance that we consulted on without making any changes, other than correcting one typographical error.
We have decided to put in place the following:
a qualification level Condition requiring exam boards to comply with any requirements we set, and have regard to any guidance we provide, in relation to setting grade boundaries
a qualification level Condition requiring exam boards to have regard to an appropriate range of evidence when setting grade boundaries, to maintain a record of this evidence and the rationale for selecting it, supported by guidance providing examples of such evidence
qualification-specific requirements about the way in which grade boundaries should be set
We have also decided to remove one requirement from the GCSE Subject Level Conditions and Requirements for Mathematics and GCSE Subject Level Conditions and Requirements for Modern Foreign Languages. This is because part of it duplicates a requirement we are putting in place in the qualification level Conditions as a result of our decisions above.
We have published updated versions of the following documents:
Published: PDF , 426KB , 12 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
There were nine responses to the consultation. Five of these were from teachers responding in a personal capacity; four were from exam boards.
Respondents supported the majority of our proposals. Respondents agreed with our proposed Condition; commenting only to request clarification about the meaning of ‘prior qualification’ in the Condition. Similarly, the only comment we received about the draft guidance was to clarify what we mean by a ‘similar subject’.
Of the comments we did receive, most were about specific parts of the drafting of our standard setting requirements, not the overall approach. The specific aspects respondents commented on were:
tiering - some respondents commented that where the 3/U grade boundary in higher tier papers is adjusted based on statistical and technical evidence, there should be a minimum mark gap between the 3/U and 4/3 grade boundaries
key grade boundaries - some respondents queried whether the grade 5/4 boundary should be a key grade boundary
allowed grades in higher tier - some respondents queried whether a 3-3 grade should be allowed in higher tier double-award GCSE papers
This consultation ran from
to
Consulting on the proposed regulations for setting grade boundaries in new GCSEs awarded from 2017 onwards.
Ref: Ofqual/16/6128 PDF , 519KB , 23 pages
If you use assistive technology (such as a screen reader) and need a version of this document in a more accessible format, please email<EMAIL_ADDRESS>. Please tell us what format you need. It will help us if you say what assistive technology you use.
This consultation is about the conditions, requirements and guidance we propose to put in place to implement some of the decisions from our April 2016 grading consultation and our April 2014 grading consultation . It includes our proposed requirements and guidance for setting grade boundaries for all GCSE (9 to 1) qualifications. We have consulted previously and announced our decisions for GCSE (A* to G), AS and A level qualifications and the equivalent requirements for these qualifications are already in place.
Published: 30 November 2016
Updated: 16 February 2017
From: Ofqual


funkyDOM is a small enhancement to basic jQuery or Zepto. It works as a functional mixin and implements some special methods (like ego, advisable, etc) on top of the basic jQuery/Zepto collection.
For convenience, the funkyDOM function is a factory function like jQuery()/Zepto() and accepts the same arguments as they do, therefor whatever can be done with a jQuery/Zepto collection factory can also be done with the funkyDOM factory.
In addition to adding special methods to a given or created collection, all methods also exist as static methods on the factory itself. If you want to use any of the static methods, the referencing collection has to be given as first argument. For example:
var all = f$('*'), body = f$('body');
var union = body.union(all);
var unionAlternative = body.add(all).unique();
var intersection = body.intersect(all);
var difference = body.difference(all);
// is literally equivalent to:
var unionStatic = f$.union(body, all);
var unionAlternativeStatic = f$.unique(body.add(all));
var intersectionStatic = f$.intersect(body, all);
var differenceStatic = f$.difference(body, all);
Besides the obvious dependency on jQuery or Zepto, funkyDOM depends on funkyJS 2 version 2.1.0 or greater. This has an upside and a downside. The downside is, the amount of data to load increases a bit. This does not hurt too much, as funkyJS 2 itself is relatively small itself, especially if you use the builder tool to create your version of funkyDOM, as it ensures all needed files are merged together into one source code so you do not have to take care of this yourself. Of course this does not apply to jQuery/Zepto files, which you'll likely use already. Be sure these meet the requirements to use funkyDOM with the version you use (all gzipped and minified):
jQuery: V. 2.0.0 or higher (30kb) or
Zepto: V. 1.1.0 or higher (10kb, just core modules) and
funkyJS & funkyDOM: V. 2.1.0 or higher (5 - 6kb, just needed modules)
The upside however is, that funkyJS enables you to do certain things in JavaScript, which are otherwise more tricky to achive and you'd have to implement a lot of stuff yourself. funkyDOM itself is written in a way that takes care to use as few modules of funkyJS as possible, to keep the filesize small.
Next, it implements fixes for certain situations, which – if not fixed – require you to add certain boilerplate over and over again throughout the whole application/website/widget/etc...
Below you see a example of how funkyDOM transforms the way you can write jQuery with it. The example is taken from the page you just watch and uses these additional methods from funkyJS:
var f$ = funkyDOM,
f = funkyJS;
// get element references (1)
var body = f$('body').ego('css', 'html', 'animate', 'off'),
lib = f$('.lib').ego('animate'),
claim = f$('.lib_claim').ego('animate'),
libText = f$('.lib_text').ego('animate');
// predefine animations to run (2)
var onAfterBodyAnim = f.pipe(
claim.evoke('animate', {opacity: 1}, 1000),
libText.evoke('animate', {opacity: 1}, 2000)
);
var animateBody = body.evoke(
'animate',
[{
marginTop: '280px'
},
600,
onAfterBodyAnim
);
// run the animations (3)
lib.animate(
{fontSize: '70px'},
{complete: animateBody}
);
Part 1
Let's step through the example. The first part shows querying the DOM with funkyDOM instead of jQuery. This should look pretty familiar so far. After that step, we immediatly call the method "ego" on each collection. The ego method accepts one to unlimited strings of method names and makes these methods egocentric on the collection. This means, whenever your program calls a egocentric method, the "this" part inside the method always points to the instance it is egocentric about. You might notice a relationship to Function.prototype.bind here. Simply said, both do the same and in reality, Function.prototype.bind is used inside ego, but in addition to that the ego methods preserves the correct arity while binding and in fact is much easier to handle if binding methods to instances as it can be called in chained calls, which feels very naturally in and around the jQuery world.
Calls to ego also allow you to pass only the (afterwards) egocentric method around and invoke it later, for example in callback chains. funkyDOM also installs a helper method to ease that too which we'll discuss in short.
Part 2
The next part first consists of a funkyJS invocation of the pipe method. You can read more about it in the funkyJS documentation, but in short, it allows to create a pipeline of functions to execute.
var onAfterBodyAnim = f.pipe(
claim.evoke('animate', {opacity: 1}, 1000),
libText.evoke('animate', {opacity: 1}, 2000)
);
So, we are building a pipeline of functions. We want to make calls to the already egocentric animate method of two collections we queried – sounds quite simple so far.
But, you'll see – in reality it's not that simple. Even though the animate methods of both collections are egocentric, the problem now is that we have to pass different arguments to both collections (the duration parameter). And even if it would be possible to pass different arguments in a single function invocation (which would be crazy already) to the functions contained inside it's body, how to ensure the correct functions are applied to the correct arguments (so first to first, third to second if second should be third, etc.)? You would have to take care that each pipeline of functions you create would have been written in the same order to rely on the order of arguments given. For small projects that would be an option, for larger projects it would be just horrible.
The solution of funkyDOM instead works in the opposite direction. It implements an evoke method, which allows to call any egocentric method with a predefined set of arguments by returning the invocation as raw function. Sounds crazy? Read on.
This is also a bit similiar to Function.prototype.bind's behaviour of presetting arguments of a bound function. This is where it get's interesting, because evoke and ego together can be used just like Function.prototype.bind and you could emulate their behaviour with Function.prototype.bind (although doing so would introduce much more noise in your code). Please note that evoke does not bind the function's context like bind does, it just presets the arguments applied. Therefor, the variable "animateBody" in the example contains the raw invocation of the animate method on the body collection with just a predefined set of arguments.
var animateBody = body.evoke(
'animate',
[{
marginTop: '280px'
},
600,
onAfterBodyAnim
);
Part 3
There's not much left to say. The last part just contains a normal invocation of the animate method on the lib collection. As soon as the animation completes, the variable "animateBody" is called and kicks off the next animation. Done.
lib.animate(
{fontSize: '70px'},
{complete: animateBody}
);
The ego and evoke methods are not the only benefit of funkyDOM, but both of them operate at the heart of what funkyDOM tries to do: Lifiting jQuery or Zepto as OO methology based frameworks into the world of functional programming, which allows from a general point of view much easier modularity at atomic level. It does so by pointing our perspective away from the OO level right to functions as first-class citizens. This allows you to pass method invocations around like normal collections.
From that description emerges what funkyDOM really is: A enhancement instead of a new library. Use it or don't use it. And if you do, use it exclusively or beneath plain jQuery collections, the choice is completely up to you.
var f$ = funkyDOM,
f = funkyJS;
// a "Clickable" class constructor
function Clickable (selector, root) {
// get root element and make egocentric methods
this.$root = fdom(selector, root).
ego('addClass', 'removeClass', 'toggleClass');
// create a activate method
this.activate = this.$root.evoke('addClass', 'is-clicked');
// create a deactivate method
this.deactivate = this.$root.evoke('removeClass', 'is-clicked');
// create a toggle method and bind it
this.toggle = this.$root.evoke('toggleClass', 'is-clicked');
// set css and event listeners
this.$root.css('cursor', 'pointer').on('click', this.toggle);
}
// create a factory function for the constructor
var makeClickable = f.factory(Clickable);
The example demonstrates how to create a class and all of it's methods just inside the constructor. Finally, the constructor is passed into funkyJS.factory which returns a factory function for it which eliminates the need for the "new" keyword. Don't panic if you havn't chosen the funkyJS objects module, you can still use the Clickable constructor, just prefix it with "new" like:
new Clickable('#selector');
It works just the same. If you want to see it in action, just click on one of the above code boxes and inspect the HTML markup through your browser inspector.
Just in case you still have this question:
Because it's super usefulSee: We created a new class at runtime without ever having to write "function () {}" to define a method anywhere ourself, which immensly helps to remove noise from your code. On top of that, we have set an event listener to the click event which is correcly bound automatically. Of course nothing stops us from adding more complexity to the prototype chain too, but I kind of like the idea of small things. They tend to have a much higher reuse as big fat parts of any application. So this is it: A class which can be used on any clickable element, which adds and removes (programatically) or toggles (event driven as well as programatically) the CSS class "is-clicked" on the element. I'm sure you can come up with more usable solutions yourself :)
If you need more stuff to chew on, think about this: You've already seen that funkyDOM makes it possible to create deferred functions of method invocations as well as egocentric methods on the created collection. First of all, what do you think happens if we write this:
var styleBody = funkyDOM('body').ego('css').css;
Of course, the variable now contains the function which represents the "css" method of the collection containing  which is a egocentric method since we called "ego" with it as argument. All right.
Now we can style the body element by calling "styleBody" with the arguments we want. See?
styleBody({fontSize: 16});
If "styleBody" has been a plain old function like the usually ones:
function styleBody (props) {
$('body').css(props);
}
the calling chain would have stopped here. But this isn't just a plain function. This one has super powers! … OK, it's a normal function, but with a little twist on it: It automatically is executed in the context of the body collection and – guess what – it returns the collection after a call!
styleBody({fontSize: 16}).html('
Hello World
');
How cool is that? Passing around a bound function itself can be really powerful and usually leads to different solutions which we might not think of in the first place but which are often much easier to understand than the usual ones. And by using the evoke method of every funkyDOM collection, you may also predefine a function invocation with the evoke method. That gives you, instead of the raw function, the invocation of a function with optionally predefined arguments (as seen above). And the invocation of a function returns the same as the function itself does if it is invoked: The collection it is about.
Here's some usual stuff to do: Set up a eventlistener which triggers a animation and unbinds itself after a click. Just stuff it into a class if you like, abstracting it further into a more reusable component:
// simple implementation (example)
var listener = body.ego('animate', 'off').
evoke('animate', {fontSize: 16}, 500, body.evoke('off', 'click'));
body.on('click', listener);
// class implementation (example)
function Anim (el, props, ms) {
this.el = funkyDOM(el).ego('animate', 'on', 'off');
this.offClick = this.el.evoke('off', 'click');
this.onClick = this.el.evoke('on', 'click');
this.animate = this.el.evoke('animate', props, ms, this.offClick);
this.onClick(this.animate);
}
var anim = new Anim('#myElement', {left: 300}, 500);
Below you'll find the documentation of the static and instance/collection methods provided by funkyDOM.
| funkyDOM.method | args | arg type(s) | returns |
|---|---|---|---|
| Description | |||
| ego | self, method1 [, ...methodN] | collection, string1 [, ...stringN] | collection |
| Given a collection and one to N method names, makes all fields which are methods on the collection egocentric or bound to the collection. Returns the collection. | |||
| is | self | collection | boolean |
| Given a collection returns true if it is a funkyDOM collection and false if not. | |||
| evoke | self, method [, ... additional args] | collection, string [, ...*] | function |
| Given a collection, a method name and one to N optional arguments, returns a function wrapping the invocation of the method with the given arguments predefined from the left. Additional arguments passed to the deferred invocation at application time are added to the right of the predefined argument set. | |||
| evokeRight | self, method [, ... additional args] | collection, string [, ...*] | function |
| Given a collection, a method name and one to N optional arguments, returns a function wrapping the invocation of the method with the given arguments predefined from the right. Additional arguments passed to the deferred invocation at application time are added to the left of the predefined argument set. | |||
| advisable | self, method | collection, string | collection |
| Given a collection and a method name, makes the given method advisable. A advisable method has like method-methods: Methods you can call on the methods itself. Please see the funkyJS documentation for detailed information (coming soon, currently on Github: https://github.com/urbandrone/funkyJS2/) | |||
| unique | self | collection | new collection |
| Returns a new collection with all duplicates removed. Very useful if you have build a collection from a array of elements which contains some doubled ones. | |||
| union | self, other | collection, collection | new collection |
| Returns a collection with the union of two collections, so that both collections are merged into another but all duplicated elements have been removed. | |||
| intersect | self, other | collection, collection | new collection |
| Returns a collection with the intersection of two other collections. | |||
| difference | self, other | collection, collection | new collection |
| Returns a new collection containing the difference of two given collections. | |||
| fEach | self, fn [, scope] | collection, fn [, *] | collection |
Finally makes jQuery's "each" method behave like the one on Array.prototype insofar, as it alters the given arguments to the equivalents of a array ones.
. For technical reasons, it's impossible to overwrite jQuery's/Zepto's "each" method because there is no way to determine the past call stack to find out which internal each method has been called by a wrapped method inside the funkyDOM wrapper, and which calls have been made from outside the wrapper. Hence the name.
|
|||
| fMap | self, fn [, scope] | collection, fn [, *] | new collection |
Finally makes jQuery's "map" method behave like the one on Array.prototype insofar, as it alters the given arguments to the equivalents of a array ones.
. For technical reasons, it's impossible to overwrite jQuery's/Zepto's "filter" method because there is no way to determine the past call stack to find out which internal filter method has been called by a wrapped method inside the funkyDOM wrapper, and which calls have been made from outside the wrapper. Hence the name.
|
|||
| fFilter | self, fn [, scope] | collection, fn [, *] | new collection |
Finally makes jQuery's "filter" method behave like the one on Array.prototype insofar, as it alters the given arguments to the equivalents of a array ones.
. For technical reasons, it's impossible to overwrite jQuery's/Zepto's "filter" method because there is no way to determine the past call stack to find out which internal filter method has been called by a wrapped method inside the funkyDOM wrapper, and which calls have been made from outside the wrapper. Hence the name.
|
| collection.method | args | arg type(s) | returns |
|---|---|---|---|
| Description | |||
| ego | method1 [, ...methodN] | string1 [, ...stringN] | collection |
| Given one to N method names, makes all fields which are methods on the collection egocentric or bound to the collection. Returns the collection. | |||
| evoke | method [, ... additional args] | string [, ...*] | function |
| Given a method name and one to N optional arguments, returns a function wrapping the invocation of the method with the given arguments predefined from the left. Additional arguments passed to the deferred invocation at application time are added to the right of the predefined argument set. | |||
| advisable | method | string | collection |
| Given a method name, makes the given method advisable. A advisable method has like method-methods: Methods you can call on the methods itself. Please see the funkyJS documentation for detailed information (coming soon, currently on Github: https://github.com/urbandrone/funkyJS2/) | |||
| unique | - | - | new collection |
| Returns a new collection with all duplicates removed. Very useful if you have build a collection from a array of elements which contains some doubled ones. | |||
| union | other | collection | new collection |
| Returns a collection with the union of two collections, so that both collections are merged into another but all duplicated elements have been removed. | |||
| intersect | other | collection | new collection |
| Returns a collection with the intersection of two collections. | |||
| difference | other | collection | new collection |
| Returns a new collection containing the difference of two given collections. | |||
| fEach | fn [, scope] | fn [, *] | collection |
Finally makes jQuery's "each" method behave like the one on Array.prototype insofar, as it alters the given arguments to the equivalents of a array ones.
. For technical reasons, it's impossible to overwrite jQuery's/Zepto's "each" method because there is no way to determine the past call stack to find out which internal each method has been called by a wrapped method inside the funkyDOM wrapper, and which calls have been made from outside the wrapper. Hence the name.
|
|||
| fMap | fn [, scope] | fn [, *] | new collection |
Finally makes jQuery's "map" method behave like the one on Array.prototype insofar, as it alters the given arguments to the equivalents of a array ones.
. For technical reasons, it's impossible to overwrite jQuery's/Zepto's "filter" method because there is no way to determine the past call stack to find out which internal filter method has been called by a wrapped method inside the funkyDOM wrapper, and which calls have been made from outside the wrapper. Hence the name.
|
|||
| fFilter | fn [, scope] | fn [, *] | new collection |
Finally makes jQuery's "filter" method behave like the one on Array.prototype insofar, as it alters the given arguments to the equivalents of a array ones.
. For technical reasons, it's impossible to overwrite jQuery's/Zepto's "filter" method because there is no way to determine the past call stack to find out which internal filter method has been called by a wrapped method inside the funkyDOM wrapper, and which calls have been made from outside the wrapper. Hence the name.
|
|||
| to$ | - | - | jQuery/Zepto collection |
| Returns a jQuery (or Zepto) collection from the funkyDOM collection. |
Additionally, here is the list of jQuery methods which are modified when creating a funkyDOM collection. They work just the same but ensure to return a funkyDOM collection instead of a plain jQuery collection.
| collection.method | returns |
|---|---|
| find | new funkyDOM collection |
| closest | new funkyDOM collection |
| parent | new funkyDOM collection |
| parents | new funkyDOM collection |
| parentsUntil | new funkyDOM collection |
| children | new funkyDOM collection |
| siblings | new funkyDOM collection |
| prev | new funkyDOM collection |
| prevAll | new funkyDOM collection |
| prevUntil | new funkyDOM collection |
| next | new funkyDOM collection |
| nextAll | new funkyDOM collection |
| nextUntil | new funkyDOM collection |
| contents | new funkyDOM collection |
| eq | new funkyDOM collection |
| first | new funkyDOM collection |
| last | new funkyDOM collection |
| offsetParent | new funkyDOM collection |
| add | new funkyDOM collection |
| addSelf | new funkyDOM collection |
| addBack | new funkyDOM collection |
| end | new funkyDOM collection |
| has | new funkyDOM collection |
| clone | new funkyDOM collection |
| not | new funkyDOM collection |


A complication is a feature in a watch face that shows any information beyond the simple display of hours and minutes. By using Facer Tags creatively, you can create any number of your own complications! To get started, we provide some simple examples that you can use in your watch face. These can all be edited to show different information by changing the tags in the advanced settings of the element.
Date
This complication provides the date in a readable text format, using the formula #DEEEE#, #DMMMM# #DdL#
(Day of Week, Month, Date) as the Text property.
Weather Text
This complication provides the current temperature in fahrenheit (simulated in the creator), using the formula #WCT##WM#
as the Text property.
Weather Icons
This complication provides a tintable, pre-designed set of icons to show the current weather conditions (simulated in the creator).
Hint: Try dragging the time machine slider to see icons for other weather conditions.
Battery
This complication shows the current battery percentage of your Smartwatch using the #BLP#
tag for the Text property.
Activity
This complication shows the step count for the user, using the formula #ZSC# Steps
.


{% include "includes/header.html" %}
Add XML Document
Author:
Or (select one):
{% for author, children in authors %}
{{author}}
{% endfor %}
Category:
Or (select one):
{% for category in categories %}
{{category}}
{% endfor %}
Upload
{% include "includes/footer.html" %}


Jeff Brazier says being a single dad was 'really tough' amid marriage difficulties
Jeff has two sons, Bobby and Freddie, with Jade Goody, who sadly died aged 27 after a battle with cervical cancer
by Will Twigger, https://www.mirror.co.uk/authors/will-twigger/Jeff Brazier has opened up about his experience of being a single dad to his two lads, Bobby, 16, and Freddie, 15.
The 40 year old had his two boys with Jade Goody , but had to bring them up on his own after the tragic death of their mum in 2009.

Jeff has since remarried to Kate Dwyer, and recently revealed that they've had "difficulties" because Kate had a "change of heart" about having kids after they tied the knot.

"It's been the most difficult experience in my life," he said. "But the most rewarding.
"And there are moments like, when the boys were best men at my wedding a year ago and they stood up and spoke with such humour and maturity and such feeling and emotional intelligence.
"And that was the first and only time I think I've ever really allowed myself to pat myself on the back, because it was just, it was there on front of me."
Jeff added: "I couldn't deny it was incredible because children don't really show you their best, they save that for everybody else. So I hang on some moments like that."
On his marriage, Jeff's also been very candid.
Chatting to The Mail , he said: "Being married makes you feel more settled, but life doesn't feel much different because Kate has a wonderful career in PR where she works very hard and long hours, so it's still just me and the boys at home a fair bit.
"I'm not sure whether we'll have children.
"I had thought when we got married we'd go straight in [on starting a family] but there seems to have been a change of heart about that, and a need for a little more time before those decisions are made.
"I'm just happy if we do or don't, and I'm content to be patient and let Kate figure all that out."
He put rumours to bed about a possible split between him and Kate, saying: "It has been tough, but then it was meant to be tough.
"You know, it was what I signed up to. I didn't necessarily sign up to doing it on my own, but that's nobody's fault.
"I like to think we've all got the ability to step up and whatever it requires in order to give your children what they need until they no longer require it."


This demo uses the inputValue attribute on the <prism-js> element to bind between it and the input to <iron-input>
inputValue


new EventListenerWrapper() → {undefined}
Wraps event listeners with new functions.
- Source:
Returns:
- Type
- undefined
Methods
(static) addEventListener(element, eventName, callback, scope, useCapture) → {undefined}
Adds a DOM event listener, with new functions alongside Event's functions and stores reference for easier removal.
Parameters:
| Name | Type | Description |
|---|---|---|
element |
DOMElement | Element on which we attach the listener. |
eventName |
String | DOMEvent name e.g. "click". |
callback |
function | Method called by the event. |
scope |
Object | Context | The scope/context of the method called by the event. |
useCapture |
Boolean | Same as on the DOMEvent. |
- Source:
Returns:
- Type
- undefined
(static) getListener(element, eventName) → {Object}
Removes event listener
Parameters:
| Name | Type | Description |
|---|---|---|
element |
DOMElement | Element on which we attached the listener. |
eventName |
String | DOMEvent name e.g. "click". |
- Source:
Returns:
- Type
- Object
(static) indexListener(listener) → {Number}
Removes event listener
Parameters:
| Name | Type | Description |
|---|---|---|
listener |
Object | The listener we have as object. |
- Source:
Returns:
- Type
- Number
(static) initWrappers() → {DOMEvent}
Initializes the new functions on the triggered event.
- Source:
Returns:
- Type
- DOMEvent
(static) removeEventListener(element, eventName) → {undefined}
Removes event listener
Parameters:
| Name | Type | Description |
|---|---|---|
element |
DOMElement | Element on which we attached the listener. |
eventName |
String | DOMEvent name e.g. "click". |
- Source:
Returns:
- Type
- undefined


{{site.author.name}}
About
From a young age I have always harbored the urge to create. Whether it be sewing homemade dresses, sketching out botanical drawings, or glazing endless pottery pieces I've come to realize there is no greater sense of happiness than seeing a physical manifestation of my passion come to fruition.
So, when I was first introduced to macramé , I knew I wanted to try and make pieces that I could share with other people. The joy that I receive from creating wall hangings, purses, and everything in between is something that I knot into every part of my work. And as I start this new journey into blogging, I look forward bringing a little bit of happiness into the lives of my customers and followers!
Favorite Books & Works of Literature
- "The Joy Luck Club" - Amy Tan
- "As I Lay Dying" - William Faulkner
- "The Canterbury Tales" - Geoffrey Chaucer
- "Alice in Wonderland" - Lewis Carroll
- "Girl in Translation" - Jean Kwok


{% extends 'layout.html' %} {% block styles %}{% endblock %} {% block content %}
What food component do you want to eat, or what do you have?
What are your preferences?
How many recipes do you want?


Hello, I’m Min, an experienced UX researcher and Designer having a background in Psychology / Business(B.A.) and Human-Computer Interaction(M.S.). I worked as a user experience researcher and designer at SK planet and PXD, Korea.
To make people’s lives happier and more comfortable with usable technologies, I conduct design research and discover meaningful findings. My primary goal is conducting and probing UX research across mixed methods(both quantitative and qualitative) to turn into actionable insights at any design phases that help the service move forward.
With an open mind, I stay curious and enjoy to experiment with new technologies having the eyes of user-centered design.
My journey so far, I've had many learnings from failures and successes. I’m still learning every day and pushing myself beyond boundaries.
• Designed UI guidelines and executed user studies for integrating ads & commerce and improving user engagement
• Delivered actionable insights based on a thorough analysis of quantitative and qualitative research data
• Collaborated with stakeholders throughout the product development cycle to develop the driving pattern
feature resulted in increased active users and car insurance purchase
• Developed design strategies and identified opportunities to combine existing transportation applications
• Conducted iterative usability testings to investigate user needs and product usability
• Efficiently provided reports on a week turnaround to inform further product decisions and strategies
• Awarded to Special Recognition for Outstanding Works in 2018
• Designed, planned and conducted user research to identify user needs across multiple projects
• Organized, planned, and led international research studies involving cross-functional stakeholders, and field logistics in the U.S., India, and Japan
• Delivered in-depth research insights through synthesizing qualitative and quantitative data
• Worked with a variety of clients including Samsung Electronics, LG Electronics, SK Telecom, Twitter Korea, MiraeAsset Securities, BalanceHero and SapientNitro
• Designed and researched the online advertising interaction model in the context of social media.
• Issued online advertisement system and methods patents in Korea and U.S
• Presented at CHI 2013, HCI international 2013
• Strategic analyst managing business plans and sales strategies of RF payment system
• Proposed business models of unified RF payment system of festivals and universities
• Designing and conducting user research to identify user attitude, behaviors and needs with quantitative and qualitative methods.
• Developing actionable insights in both generative ideas and evaluative designs.
• Adapting in a fast-paced to do exploratory field studies in various countries.
• Professional with the ability to deliver solid results and suggestions in compelling ways.
• Skills: Research design, usability studies(remote/lab), experiments, survey design, interviews, contextual inquiries, field research, heuristic evaluation, card sorts, statistical analysis, affinity diagramming, persona development, journey mapping, literature reviews, SPSS, R(basic).
• Storyboards, Wireframes, Information Architecture, Sketch
• HTML, CSS, Javascript(basic)


Formerly Golden Tandoori, Sweet 'n' Spice is located on Upper Dorset Street in the centre of Dublin. This Indian takeaway serves a wide range of classic dishes such as Korma, Masala, Jalfrezi and Madras.
You will find us at 64 Dorset Street Upper, Dublin 1
Three brothers who shared the passion for food and tradition.
We opened our restaurant in 2013 with the idea of sharing
the taste and flavor of famous and delicious Indian cuisine with you in Dublin.


Public Member Functions | |
Constructors | |
| XSModel (XMLGrammarPool *grammarPool, MemoryManager *const manager=XMLPlatformUtils::fgMemoryManager) | |
| The constructor to be used when a grammar pool contains all needed info. | |
| XSModel (XSModel *baseModel, GrammarResolver *grammarResolver, MemoryManager *const manager=XMLPlatformUtils::fgMemoryManager) | |
| The constructor to be used when the XSModel must represent all components in the union of an existing XSModel and a newly-created Grammar(s) from the GrammarResolver. | |
Destructor | |
| ~XSModel () | |
XSModel methods | |
| StringList * | getNamespaces () |
| Convenience method. | |
| XSNamespaceItemList * | getNamespaceItems () |
A set of namespace schema information information items ( of type XSNamespaceItem ), one for each namespace name which appears as the target namespace of any schema component in the schema used for that assessment, and one for absent if any schema component in the schema had no target namespace. | |
| XSNamedMap< XSObject > * | getComponents (XSConstants::COMPONENT_TYPE objectType) |
| [schema components]: a list of top-level components, i.e. | |
| XSNamedMap< XSObject > * | getComponentsByNamespace (XSConstants::COMPONENT_TYPE objectType, const XMLCh *compNamespace) |
| Convenience method. | |
| XSAnnotationList * | getAnnotations () |
| [annotations]: a set of annotations. | |
| XSElementDeclaration * | getElementDeclaration (const XMLCh *name, const XMLCh *compNamespace) |
| Convenience method. | |
| XSAttributeDeclaration * | getAttributeDeclaration (const XMLCh *name, const XMLCh *compNamespace) |
| Convenience method. | |
| XSTypeDefinition * | getTypeDefinition (const XMLCh *name, const XMLCh *compNamespace) |
| Convenience method. | |
| XSAttributeGroupDefinition * | getAttributeGroup (const XMLCh *name, const XMLCh *compNamespace) |
| Convenience method. | |
| XSModelGroupDefinition * | getModelGroupDefinition (const XMLCh *name, const XMLCh *compNamespace) |
| Convenience method. | |
| XSNotationDeclaration * | getNotationDeclaration (const XMLCh *name, const XMLCh *compNamespace) |
| Convenience method. | |
| XSObject * | getXSObjectById (XMLSize_t compId, XSConstants::COMPONENT_TYPE compType) |
| Optional. | |
| XMLStringPool * | getURIStringPool () |
| methods needed by implementation | |
| XSNamespaceItem * | getNamespaceItem (const XMLCh *const key) |
| XSObject * | getXSObject (void *key) |
| Get the XSObject (i.e. | |
Protected Attributes | |
| MemoryManager *const | fMemoryManager |
| StringList * | fNamespaceStringList |
| XSNamespaceItemList * | fXSNamespaceItemList |
| RefVectorOf< XSObject > * | fIdVector [XSConstants::MULTIVALUE_FACET] |
| XSNamedMap< XSObject > * | fComponentMap [XSConstants::MULTIVALUE_FACET] |
| XMLStringPool * | fURIStringPool |
| XSAnnotationList * | fXSAnnotationList |
| RefHashTableOf< XSNamespaceItem > * | fHashNamespace |
| XSObjectFactory * | fObjFactory |
| RefVectorOf< XSNamespaceItem > * | fDeleteNamespace |
| XSModel * | fParent |
| bool | fDeleteParent |
| bool | fAddedS4SGrammar |
Friends | |
| class | XSObjectFactory |
| class | XSObject |
| XSModel::XSModel | ( | XMLGrammarPool * | grammarPool, | |
| MemoryManager *const | manager = XMLPlatformUtils::fgMemoryManager | |||
| ) |
The constructor to be used when a grammar pool contains all needed info.
| grammarPool | the grammar pool containing the underlying data structures | |
| manager | The configurable memory manager |
| XSModel::XSModel | ( | XSModel * | baseModel, | |
| GrammarResolver * | grammarResolver, | |||
| MemoryManager *const | manager = XMLPlatformUtils::fgMemoryManager | |||
| ) |
The constructor to be used when the XSModel must represent all components in the union of an existing XSModel and a newly-created Grammar(s) from the GrammarResolver.
| baseModel | the XSModel upon which this one is based | |
| grammarResolver | the grammar(s) whose components are to be merged | |
| manager | The configurable memory manager |
| XSModel::~XSModel | ( | ) |
| StringList * XSModel::getNamespaces | ( | ) |
Convenience method.
Returns a list of all namespaces that belong to this schema. The value null
is not a valid namespace name, but if there are components that don't have a target namespace, null
is included in this list.
References fNamespaceStringList.
| XSNamespaceItemList * XSModel::getNamespaceItems | ( | ) |
A set of namespace schema information information items ( of type XSNamespaceItem
), one for each namespace name which appears as the target namespace of any schema component in the schema used for that assessment, and one for absent if any schema component in the schema had no target namespace.
For more information see schema information.
References fXSNamespaceItemList.
| XSNamedMap<XSObject>* XSModel::getComponents | ( | XSConstants::COMPONENT_TYPE | objectType | ) |
[schema components]: a list of top-level components, i.e.
element declarations, attribute declarations, etc.
| objectType | The type of the declaration, i.e. ELEMENT_DECLARATION , TYPE_DEFINITION and any other component type that may be a property of a schema component. |
objectType
or null
. | XSNamedMap<XSObject>* XSModel::getComponentsByNamespace | ( | XSConstants::COMPONENT_TYPE | objectType, | |
| const XMLCh * | compNamespace | |||
| ) |
Convenience method.
Returns a list of top-level component declarations that are defined within the specified namespace, i.e. element declarations, attribute declarations, etc.
| objectType | The type of the declaration, i.e. ELEMENT_DECLARATION . | |
| compNamespace | The namespace to which declaration belongs or null (for components with no target namespace). |
objectType
and defined in the specified namespace
or null
. | XSAnnotationList* XSModel::getAnnotations | ( | ) |
[annotations]: a set of annotations.
| XSElementDeclaration* XSModel::getElementDeclaration | ( | const XMLCh * | name, | |
| const XMLCh * | compNamespace | |||
| ) |
Convenience method.
Returns a top-level element declaration.
| name | The name of the declaration. | |
| compNamespace | The namespace of the declaration, null if absent. |
null
if such declaration does not exist. | XSAttributeDeclaration* XSModel::getAttributeDeclaration | ( | const XMLCh * | name, | |
| const XMLCh * | compNamespace | |||
| ) |
Convenience method.
Returns a top-level attribute declaration.
| name | The name of the declaration. | |
| compNamespace | The namespace of the declaration, null if absent. |
null
if such declaration does not exist. | XSTypeDefinition* XSModel::getTypeDefinition | ( | const XMLCh * | name, | |
| const XMLCh * | compNamespace | |||
| ) |
Convenience method.
Returns a top-level simple or complex type definition.
| name | The name of the definition. | |
| compNamespace | The namespace of the declaration, null if absent. |
XSTypeDefinition
or null
if such definition does not exist. | XSAttributeGroupDefinition* XSModel::getAttributeGroup | ( | const XMLCh * | name, | |
| const XMLCh * | compNamespace | |||
| ) |
Convenience method.
Returns a top-level attribute group definition.
| name | The name of the definition. | |
| compNamespace | The namespace of the declaration, null if absent. |
null
if such definition does not exist. | XSModelGroupDefinition* XSModel::getModelGroupDefinition | ( | const XMLCh * | name, | |
| const XMLCh * | compNamespace | |||
| ) |
Convenience method.
Returns a top-level model group definition.
| name | The name of the definition. | |
| compNamespace | The namespace of the declaration, null if absent. |
null
if such definition does not exist. | XSNotationDeclaration* XSModel::getNotationDeclaration | ( | const XMLCh * | name, | |
| const XMLCh * | compNamespace | |||
| ) |
Convenience method.
Returns a top-level notation declaration.
| name | The name of the declaration. | |
| compNamespace | The namespace of the declaration, null if absent. |
null
if such declaration does not exist. | XSObject* XSModel::getXSObjectById | ( | XMLSize_t | compId, | |
| XSConstants::COMPONENT_TYPE | compType | |||
| ) |
Optional.
Return a component given a component type and a unique Id. May not be supported for all component types.
| compId | unique Id of the component within its type | |
| compType | type of the component |
| XMLStringPool * XSModel::getURIStringPool | ( | ) |
| XSNamespaceItem* XSModel::getNamespaceItem | ( | const XMLCh *const | key | ) |
| XSObject* XSModel::getXSObject | ( | void * | key | ) |
Get the XSObject (i.e.
XSElementDeclaration) that corresponds to to a schema grammar component (i.e. SchemaElementDecl)
| key | schema component object |
friend class XSObjectFactory [friend] |
friend class XSObject [friend] |
MemoryManager* const XSModel::fMemoryManager [protected] |
StringList* XSModel::fNamespaceStringList [protected] |
Referenced by getNamespaces().
XSNamespaceItemList* XSModel::fXSNamespaceItemList [protected] |
Referenced by getNamespaceItems().
RefVectorOf<XSObject>* XSModel::fIdVector[XSConstants::MULTIVALUE_FACET] [protected] |
XSNamedMap<XSObject>* XSModel::fComponentMap[XSConstants::MULTIVALUE_FACET] [protected] |
XMLStringPool* XSModel::fURIStringPool [protected] |
Referenced by getURIStringPool().
XSAnnotationList* XSModel::fXSAnnotationList [protected] |
RefHashTableOf<XSNamespaceItem>* XSModel::fHashNamespace [protected] |
XSObjectFactory* XSModel::fObjFactory [protected] |
RefVectorOf<XSNamespaceItem>* XSModel::fDeleteNamespace [protected] |
XSModel* XSModel::fParent [protected] |
bool XSModel::fDeleteParent [protected] |
bool XSModel::fAddedS4SGrammar [protected] |


transaction
— Transaction Controllers for Pymodbus¶
API Documentation¶
Collection of transaction based abstractions
-
class
pymodbus.transaction.
DictTransactionManager
(client, **kwargs)[source]¶ Impelements a transaction for a manager where the results are keyed based on the supplied transaction id.
-
__init__
(client, **kwargs)[source]¶ Initializes an instance of the ModbusTransactionManager
Parameters: client – The client socket wrapper
-
__iter__
()[source]¶ Iterater over the current managed transactions
Returns: An iterator of the managed transactions
-
addTransaction
(request, tid=None)[source]¶ Adds a transaction to the handler
This holds the requets in case it needs to be resent. After being sent, the request is removed.
Parameters: - request – The request to hold on to
- tid – The overloaded transaction id to use
-
-
class
pymodbus.transaction.
FifoTransactionManager
(client, **kwargs)[source]¶ Impelements a transaction for a manager where the results are returned in a FIFO manner.
-
__init__
(client, **kwargs)[source]¶ Initializes an instance of the ModbusTransactionManager
Parameters: client – The client socket wrapper
-
__iter__
()[source]¶ Iterater over the current managed transactions
Returns: An iterator of the managed transactions
-
addTransaction
(request, tid=None)[source]¶ Adds a transaction to the handler
This holds the requets in case it needs to be resent. After being sent, the request is removed.
Parameters: - request – The request to hold on to
- tid – The overloaded transaction id to use
-
-
class
pymodbus.transaction.
ModbusSocketFramer
(decoder)[source]¶ Modbus Socket Frame controller
Before each modbus TCP message is an MBAP header which is used as a message frame. It allows us to easily separate messages as follows:
[ MBAP Header ] [ Function Code] [ Data ] [ tid ][ pid ][ length ][ uid ] 2b 2b 2b 1b 1b Nb while len(message) > 0: tid, pid, length`, uid = struct.unpack(">HHHB", message) request = message[0:7 + length - 1`] message = [7 + length - 1:] * length = uid + function code + data * The -1 is to account for the uid byte
-
__init__
(decoder)[source]¶ Initializes a new instance of the framer
Parameters: decoder – The decoder factory implementation to use
-
advanceFrame
()[source]¶ Skip over the current framed message This allows us to skip over the current message after we have processed it or determined that it contains an error. It also has to reset the current frame header handle
-
isFrameReady
()[source]¶ Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase to let the decoder factory know that there is still data in the buffer.
Returns: True if ready, False otherwise
-
addToFrame
(message)[source]¶ Adds new packet data to the current frame buffer
Parameters: message – The most recent packet
-
populateResult
(result)[source]¶ Populates the modbus result with the transport specific header information (pid, tid, uid, checksum, etc)
Parameters: result – The response packet
-
processIncomingPacket
(data, callback)[source]¶ The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That is, checks for complete messages, and once found, will process all that exist. This handles the case when we read N + 1 or 1 / N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters: - data – The new packet data
- callback – The function to send results to
-
resetFrame
()[source]¶ Reset the entire message frame. This allows us to skip ovver errors that may be in the stream. It is hard to know if we are simply out of sync or if there is an error in the stream as we have no way to check the start or end of the message (python just doesn’t have the resolution to check for millisecond delays).
-
-
class
pymodbus.transaction.
ModbusRtuFramer
(decoder)[source]¶ Modbus RTU Frame controller:
[ Start Wait ] [Address ][ Function Code] [ Data ][ CRC ][ End Wait ] 3.5 chars 1b 1b Nb 2b 3.5 chars
Wait refers to the amount of time required to transmist at least x many characters. In this case it is 3.5 characters. Also, if we recieve a wait of 1.5 characters at any point, we must trigger an error message. Also, it appears as though this message is little endian. The logic is simplified as the following:
block-on-read: read until 3.5 delay check for errors decode
The following table is a listing of the baud wait times for the specified baud rates:
------------------------------------------------------------------ Baud 1.5c (18 bits) 3.5c (38 bits) ------------------------------------------------------------------ 1200 13333.3 us 31666.7 us 4800 3333.3 us 7916.7 us 9600 1666.7 us 3958.3 us 19200 833.3 us 1979.2 us 38400 416.7 us 989.6 us ------------------------------------------------------------------ 1 Byte = start + 8 bits + parity + stop = 11 bits (1/Baud)(bits) = delay seconds
-
__init__
(decoder)[source]¶ Initializes a new instance of the framer
Parameters: decoder – The decoder factory implementation to use
-
advanceFrame
()[source]¶ Skip over the current framed message This allows us to skip over the current message after we have processed it or determined that it contains an error. It also has to reset the current frame header handle
-
resetFrame
()[source]¶ Reset the entire message frame. This allows us to skip ovver errors that may be in the stream. It is hard to know if we are simply out of sync or if there is an error in the stream as we have no way to check the start or end of the message (python just doesn’t have the resolution to check for millisecond delays).
-
isFrameReady
()[source]¶ Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase to let the decoder know that there is still data in the buffer.
Returns: True if ready, False otherwise
-
populateHeader
()[source]¶ Try to set the headers uid, len and crc.
This method examines self.__buffer and writes meta information into self.__header. It calculates only the values for headers that are not already in the dictionary.
Beware that this method will raise an IndexError if self.__buffer is not yet long enough.
-
addToFrame
(message)[source]¶ This should be used before the decoding while loop to add the received data to the buffer handle.
Parameters: message – The most recent packet
-
populateResult
(result)[source]¶ Populates the modbus result header
The serial packets do not have any header information that is copied.
Parameters: result – The response packet
-
processIncomingPacket
(data, callback)[source]¶ The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That is, checks for complete messages, and once found, will process all that exist. This handles the case when we read N + 1 or 1 / N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters: - data – The new packet data
- callback – The function to send results to
-
-
class
pymodbus.transaction.
ModbusAsciiFramer
(decoder)[source]¶ Modbus ASCII Frame Controller:
[ Start ][Address ][ Function ][ Data ][ LRC ][ End ] 1c 2c 2c Nc 2c 2c * data can be 0 - 2x252 chars * end is '\r\n' (Carriage return line feed), however the line feed character can be changed via a special command * start is ':'
This framer is used for serial transmission. Unlike the RTU protocol, the data in this framer is transferred in plain text ascii.
-
__init__
(decoder)[source]¶ Initializes a new instance of the framer
Parameters: decoder – The decoder implementation to use
-
checkFrame
()[source]¶ Check and decode the next frame
Returns: True if we successful, False otherwise
-
advanceFrame
()[source]¶ Skip over the current framed message This allows us to skip over the current message after we have processed it or determined that it contains an error. It also has to reset the current frame header handle
-
isFrameReady
()[source]¶ Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase to let the decoder know that there is still data in the buffer.
Returns: True if ready, False otherwise
-
addToFrame
(message)[source]¶ Add the next message to the frame buffer This should be used before the decoding while loop to add the received data to the buffer handle.
Parameters: message – The most recent packet
-
populateResult
(result)[source]¶ Populates the modbus result header
The serial packets do not have any header information that is copied.
Parameters: result – The response packet
-
processIncomingPacket
(data, callback)[source]¶ The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That is, checks for complete messages, and once found, will process all that exist. This handles the case when we read N + 1 or 1 / N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters: - data – The new packet data
- callback – The function to send results to
-
-
class
pymodbus.transaction.
ModbusBinaryFramer
(decoder)[source]¶ Modbus Binary Frame Controller:
[ Start ][Address ][ Function ][ Data ][ CRC ][ End ] 1b 1b 1b Nb 2b 1b * data can be 0 - 2x252 chars * end is '}' * start is '{'
The idea here is that we implement the RTU protocol, however, instead of using timing for message delimiting, we use start and end of message characters (in this case { and }). Basically, this is a binary framer.
The only case we have to watch out for is when a message contains the { or } characters. If we encounter these characters, we simply duplicate them. Hopefully we will not encounter those characters that often and will save a little bit of bandwitch without a real-time system.
Protocol defined by jamod.sourceforge.net.
-
__init__
(decoder)[source]¶ Initializes a new instance of the framer
Parameters: decoder – The decoder implementation to use
-
checkFrame
()[source]¶ Check and decode the next frame
Returns: True if we are successful, False otherwise
-
advanceFrame
()[source]¶ Skip over the current framed message This allows us to skip over the current message after we have processed it or determined that it contains an error. It also has to reset the current frame header handle
-
isFrameReady
()[source]¶ Check if we should continue decode logic This is meant to be used in a while loop in the decoding phase to let the decoder know that there is still data in the buffer.
Returns: True if ready, False otherwise
-
addToFrame
(message)[source]¶ Add the next message to the frame buffer This should be used before the decoding while loop to add the received data to the buffer handle.
Parameters: message – The most recent packet
-
populateResult
(result)[source]¶ Populates the modbus result header
The serial packets do not have any header information that is copied.
Parameters: result – The response packet
-
processIncomingPacket
(data, callback)[source]¶ The new packet processing pattern
This takes in a new request packet, adds it to the current packet stream, and performs framing on it. That is, checks for complete messages, and once found, will process all that exist. This handles the case when we read N + 1 or 1 / N messages at a time instead of 1.
The processed and decoded messages are pushed to the callback function to process and send.
Parameters: - data – The new packet data
- callback – The function to send results to
-


Set
struct Set<Element> where Element : Hashable
-
Returns the sum of all elements.
Declaration
Swift
var total: Element { get }
-
Returns the average of all elements.
Declaration
Swift
var average: Double { get }
-
Returns a new set with the elements that are different from the given sets.
let set: Set = ["hello", "world"] print(set.difference(["hello"], ["!"])) // Prints "["!", "world"]"
Declaration
Swift
func difference(_ others: Set...) -> Set
Parameters
others
Other sets.
Return Value
A new set.
-
Returns a Boolean value that indicates whether this set contains the given set.
print(["hello", "world"].contains(["hello"])) // Prints "true"
Declaration
Swift
func contains(_ other: Set) -> Bool
Parameters
other
Another set.
Return Value
true
if the set containsother
; otherwise,false
. -
Returns a set with the elements to add after comparing the other set.
struct Data: Hashable { let id: Int let title: String } let set: Set = [Data(id: 0, title: "hello"), Data(id: 1, title: "world")] let anotherSet: Set = [Data(id: 1, title: "hello"), Data(id: 2, title: "world")] let result = set.elementsToAdd(other: anotherArray) { $0.id == $1.id } print(result) // Prints "[Data(id: 2, title: "world")]"
Declaration
Swift
func elementsToAdd(other: Set, isIncluded: (Element, Element) -> Bool) -> Set
Parameters
other
Another set.
isIncluded
A closure that takes a element as its argument and returns a Boolean value indicating whether the element should be included.
Return Value
A set.
-
Returns a set with the elements to remove after comparing the other set.
struct Data: Hashable { let id: Int let title: String } let set: Set = [Data(id: 0, title: "hello"), Data(id: 1, title: "world")] let anotherSet: Set = [Data(id: 1, title: "hello"), Data(id: 2, title: "world")] let result = set.elementsToRemove(other: anotherSet) { $0.id == $1.id } print(result) // Prints "[Data(id: 0, title: "hello")]"
Declaration
Swift
func elementsToRemove(other: Set, isIncluded: (Element, Element) -> Bool) -> Set
Parameters
other
Another set.
isIncluded
A closure that takes a element as its argument and returns a Boolean value indicating whether the element should be included.
Return Value
A set.
-
Returns a set with the elements to update after comparing the other set.
struct Data: Hashable { let id: Int let title: String } let set: Set = [Data(id: 0, title: "hello"), Data(id: 1, title: "world")] let anotherSet: Set = [Data(id: 1, title: "hello"), Data(id: 2, title: "world")] let result = set.elementsToUpdate(other: anotherSet) { $0.id == $1.id } print(result) // Prints "[Data(id: 1, title: "hello")]"
Declaration
Swift
func elementsToUpdate(other: Set, isIncluded: (Element, Element) -> Bool) -> Set
Parameters
other
Another set.
isIncluded
A closure that takes a element as its argument and returns a Boolean value indicating whether the element should be included.
Return Value
A set.
-
Returns a union set of two sets.
print(["hello", "world"] | ["!"]) // Prints "["hello", "world", "!"]"
Declaration
Swift
static func | (lhs: Set, rhs: Set) -> Set
Parameters
lhs
A set.
rhs
The set to combile with
lhs
.Return Value
A set.
-
Subtracts the second value from the first if the elements are equal.
print(["hello", "world"] - ["world"]) // Prints "["hello"]"
Declaration
Swift
static func - (lhs: Set, rhs: Set) -> Set
Parameters
lhs
The first set.
rhs
The set to subtract.
Return Value
A set.
-
Subtracts the second set from the first if the elements are equal and stores the difference in the left-hand-side variable.
var hello = ["hello", "world"] hello -= ["world"] print(hello) // Prints "["hello"]"
Declaration
Swift
static func -= (lhs: inout Set, rhs: Set)
Parameters
lhs
A set.
rhs
The set to subtract from
lhs
. -
Returns a new set with the elements that are common to both ywo sets.
print(["hello"] & ["hello", "world"]) // Prints "["hello"]"
Declaration
Swift
static func & (lhs: Set, rhs: Set) -> Set
Parameters
lhs
A set.
rhs
The set to compare with
lhs
.Return Value
A set.
-
Returns a set which does not contain any empty element.
let emptyDictionaryValueSet: Set<[String: String]> = [["hello": ""]] print(emptyDictionaryValueSet.removingEmpty().isEmpty) // Prints "true"
Declaration
Swift
func removingEmpty() -> Set
Return Value
A set.
-
Returns a set which does not contain the given elements.
print(["hello", "world", "!"].removing("hello", "world")) // Prints "["!"]"
Declaration
Swift
func removing(_ elements: Element...) -> Set
Parameters
elements
The elements to remove.
Return Value
A set.