public interface HGStoreImplementation
A HGStoreImplementation
provides the crucial storage layer for a
HyperGraphDB instance. This interface allows one to plug different storage layers
based on different lower-level stores and thus obtain various performance characteristics
or transaction guarantees. Implementing this interface is not trivial and some
core assumption must be carefully observed.
Note that this interface is an SPI (Service Provider Interface) and it
is not intended to be used by an application. Instead, applications should use
the HGStore
class which offers the same functionality, but in
the context of a HyperGraphDB instance. All methods here are intended for use
by HyperGraphDB itself.
| Modifier and Type | Method and Description |
|---|---|
void |
addIncidenceLink(HGPersistentHandle handle,
HGPersistentHandle newLink)
And an element to the incidence set of a given atom (as identified by the
handle
parameter). |
boolean |
containsData(HGPersistentHandle handle)
Return
true if the data space contains data with the given
handle and false otherwise. |
boolean |
containsLink(HGPersistentHandle handle)
Return
true if there is a primitive link for the given handle. |
java.lang.Object |
getConfiguration()
Each different storage mechanism provides its own configuration object
with parameters that can be set before storage is initialized.
|
byte[] |
getData(HGPersistentHandle handle)
Return the data corresponding to a given handle or
null if it is not found. |
HGRandomAccessResult<HGPersistentHandle> |
getIncidenceResultSet(HGPersistentHandle handle)
Return the incidence set associate with the given handle.
|
long |
getIncidenceSetCardinality(HGPersistentHandle handle)
Return the number of elements of the incidence set for the given handle or 0
if no such set exists.
|
<KeyType,ValueType> |
getIndex(java.lang.String name)
Get the HyperGraphDB index with the given name.
|
<KeyType,ValueType> |
getIndex(java.lang.String name,
ByteArrayConverter<KeyType> keyConverter,
ByteArrayConverter<ValueType> valueConverter,
java.util.Comparator<byte[]> keyComparator,
java.util.Comparator<byte[]> valueComparator,
boolean isBidirectional,
boolean createIfNecessary)
Retrieve the index with the given name, or create a new index if no index with
that name exists.
|
HGPersistentHandle[] |
getLink(HGPersistentHandle handle)
Return the link corresponding to a given handle or
null if it is not found. |
HGTransactionFactory |
getTransactionFactory()
Return the transaction factory associated with this storage instance.
|
void |
removeData(HGPersistentHandle handle)
Remove the data corresponding to a given handle.
|
void |
removeIncidenceLink(HGPersistentHandle handle,
HGPersistentHandle oldLink)
Remove a specifiec element from the incidence set of a given atom (as identified by
the
handle parameter). |
void |
removeIncidenceSet(HGPersistentHandle handle)
Remove the incidence set associated with the given handle.
|
void |
removeIndex(java.lang.String name)
Remove the index with the given name.
|
void |
removeLink(HGPersistentHandle handle)
Remove the link corresponding to a given handle.
|
void |
shutdown()
Stops the storage engine.
|
void |
startup(HGStore store,
HGConfiguration configuration)
Starts the storage engine.
|
HGPersistentHandle |
store(HGPersistentHandle handle,
byte[] data)
Store a raw data buffer and return its handle.
|
HGPersistentHandle |
store(HGPersistentHandle handle,
HGPersistentHandle[] link)
Store a primitive link and return its handle.
|
java.lang.Object getConfiguration()
void startup(HGStore store, HGConfiguration configuration)
Starts the storage engine.
This method is invoked after storage configuration parameters have been set and its purpose is to perform complete initialization for the underlying storage layer, possibly creating a new database instance. When this method returns, the storage should be ready for use.
void shutdown()
Stops the storage engine.
This method is invoked when the database instance is closed. It is expected to perform all necessary cleanup and closing of resources of the storage layer.
HGTransactionFactory getTransactionFactory()
Return the transaction factory associated with this storage instance. Storage implementations in HyperGraphDB are expected to be transactional and support snapshot isolation semantics.
HGPersistentHandle store(HGPersistentHandle handle, HGPersistentHandle[] link)
handle
- The handle to use as the identifier of the link.link
- The primitive link. Neither the array nor any of its element can
be null
.handle
argument.HGPersistentHandle[] getLink(HGPersistentHandle handle)
null
if it is not found.void removeLink(HGPersistentHandle handle)
boolean containsLink(HGPersistentHandle handle)
true
if there is a primitive link for the given handle.HGPersistentHandle store(HGPersistentHandle handle, byte[] data)
handle
- The handle to use as identifier within the data space.data
- The buffer to store. There is no limit to the size of this buffer, but it can't be null.handle
argument.byte[] getData(HGPersistentHandle handle)
null
if it is not found.void removeData(HGPersistentHandle handle)
boolean containsData(HGPersistentHandle handle)
true
if the data space contains data with the given
handle and false
otherwise.HGRandomAccessResult<HGPersistentHandle> getIncidenceResultSet(HGPersistentHandle handle)
void removeIncidenceSet(HGPersistentHandle handle)
long getIncidenceSetCardinality(HGPersistentHandle handle)
void addIncidenceLink(HGPersistentHandle handle, HGPersistentHandle newLink)
handle
parameter).void removeIncidenceLink(HGPersistentHandle handle, HGPersistentHandle oldLink)
handle
parameter).<KeyType,ValueType> HGIndex<KeyType,ValueType> getIndex(java.lang.String name)
null
if no
index with that name exists.<KeyType,ValueType> HGIndex<KeyType,ValueType> getIndex(java.lang.String name, ByteArrayConverter<KeyType> keyConverter, ByteArrayConverter<ValueType> valueConverter, java.util.Comparator<byte[]> keyComparator, java.util.Comparator<byte[]> valueComparator, boolean isBidirectional, boolean createIfNecessary)
name
- The name of the index. It must be unique for the storage layer.keyConverter
- Converter to byte [] for the keys in this index. Necessary when creating
a new index. If null
, a default converter should be used.valueConverter
- Converter to byte [] for the values in this index. Necessary when creating
a new index. If null
, a default converter should be used.keyComparator
- A comparator for the keys in this index. If a non-null comparator is provided, it will be
used by the storage implementation to main the keys in order.valueComparator
- A comparator for the values in this index. This comparator will be used only when
there are multiple values associated with a given key (i.e. "duplicate values").isBidirectional
- If true
a HGBidirectionalIndex
will be created and
returned, otherwise a normal HGIndex
is returned.createIfNecessary
- Only when this flag is true
will an index be created. Otherwise,
if this flag is false
a no index with the given name
exists then
null
will be returned.void removeIndex(java.lang.String name)


ORG_0000049 - region
Label
region
Sub class of
Definition
A subdivision of the territory of a country
Definition source
Michael Conlon https://orcid.org/0000-0002-1304-8447
Example
US states, counties, Candian Provinces, US Zip codes, US SMSAs, US time zone territories are all examples of regions.
Editor’s note
This term is about the territory, not its governance. It could be subclassed to define verious types of regions – census tracts, zip codes, and others.
Term editor
Michael Conlon https://orcid.org/0000-0002-1304-8447


Red especially loves fighting against trainers that are stronger than he is
Nobody really knows how old this trainer is, but he sure loves to battle Pokemon
Gotta' fetch 'em all
Specializes in fighting pokemon from all over, this trainer wants to be the best


Behold, Low-Budget Death Stranding Cosplay
by Brian AshcraftEarlier this month, Kotaku’s Tim Rogers brought Death Stranding to life in a realistic, yet inexpensive way. He is not alone. Others have also been doing their own Death Stranding cosplays on the cheap.
Below is a GIF of Tim’s Death Stranding budget-priced cosplay in action.
GIF: tim rogers (Kotaku)
In case you missed it, you can watch his video review right here. Have a look at other inexpensive (and creative) Death Stranding cosplays.
Header image: Twitch


Register and Start Selling Today
Please have the following before you begin:
- Your business name, address, and contact information
- An internationally-chargeable credit card with valid billing address
- A phone number where you can be reached during this registration process
Important Notice for International Sellers
- If you are registering from a country which is outside of the United States, there are important steps you must take before you begin selling on our Amazon.com website to ensure a great experience for you and for customers. These steps include:
- You will have to provide a bank account in a country supported by Amazon.com in order to be paid. Currently Amazon supports UK, Austrian, French, German and US bank accounts.
- You must accurately state the 'shipping from' country in your Amazon.com seller profile for display to customers.
- You will be responsible for assuring that you will meet the shipping expectations for all orders you receive.
- Products must be listed in US Dollars.
- All customer facing content and communications must be in English.
- You should understand the laws that apply to you as a seller on our website and only list, sell, and export products that comply with those laws.
- Please read this important information for international sellers for more details of your obligations as a seller on our website.
If you cannot comply with the requirements of this registration, please do NOT continue with this registration process.


This page shows information about the authenticated user:
Principal
subject
Authentication type
OIDCToken
Granted authorities
Go back to the storage area index page


---
layout: post
title: On second thought...
date: '2010-03-12T11:21:00.002-06:00'
author: Jabell
tags:
- Humor
- Quotes
- Movies
modified_time: '2010-03-12T11:24:12.932-06:00'
blogger_id: tag:blogger.com,1999:blog-19739956.post-2388808074554832642
blogger_orig_url: http://theabellsix.blogspot.com/2010/03/on-second-thought.html
---
“On second thought, let’s not go to Camelot. It is a silly place.”
—King Arthur in Monty Python and the Holy Grail


User Documentation¶
Interface Language¶
You can change the interface language on the top side of the browser, in the menu like the one in this image. The first four languages are clickable, upon click the page will reload and the language will be displayed. On the ‘+’ icon you will find a dropdown menu containing more languages that are browsable.
References & Download¶
References to the resources used are on the references page which is accessed through the icon on the left.
The link to the download is on the icon on the right side.
Search¶
Search bar¶
By clicking enter or the magnifying glass icon the search will be triggered, given that there is a word being searched for. The icon on the right with the globe reveals the translation menu.
You can select however many languages you would like to see the translations of words on.


Contrary to popular belief, Lorem Ipsum is not simply random text.  Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections 1.10.32 and 1.10.33 asdasdasdsdaof "de Finibus Bonorum et Malorum" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, googlevery popular during the Renaissance. The first line of Lorem Ipsum, "Lorem ipsum dolor sit amet..", comes from a line in section 1.10.32.
Contrary to popular belief, Lorem Ipsum is not simply random text.  Richard McClintock, a Latin professor at Hampden-Sydney College in Virginia, looked up one of the more obscure Latin words, consectetur, from a Lorem Ipsum passage, and going through the cites of the word in classical literature, discovered the undoubtable source. Lorem Ipsum comes from sections 1.10.32 and 1.10.33 of "de Finibus Bonorum et Malorum" (The Extremes of Good and Evil) by Cicero, written in 45 BC. This book is a treatise on the theory of ethics, very popular during the Renaissance. The first line of Lorem Ipsum, "Lorem ipsum dolor sit amet..", comes from a line in section 1.10.32.


BFP admin (Reports)
×
Add File
Report Files
{{(index + 1)}}
{{item.filename +" " +item.date}}
download
delete
Add New File


"URIAH "the Lord is my light. (1.) A Hittite, the husband of Bathsheba, whom David first seduced, and then after Uriah’s death married. He was one of the band of David’s “mighty men.” The sad story of the curel wrongs inflicted upon him by David and of his mournful death are simply told in the sacred record (2 Samuel 11:2-12:26). (See BATHSHEBA; DAVID.)(2.) A priest of the house of Ahaz (Isaiah 8:2). (3.) The father of Meremoth, mentioned in Ezra 8:33.
"URIAH "the Lord is my light. (1.) A Hittite, the husband of Bathsheba, whom David first seduced, and then after Uriah’s death married. He was one of the band of David’s “mighty men.” The sad story of the curel wrongs inflicted upon him by David and of his mournful death are simply told in the sacred record (2 Samuel 11:2-12:26). (See BATHSHEBA; DAVID.)(2.) A priest of the house of Ahaz (Isaiah 8:2).
(3.) The father of Meremoth, mentioned in Ezra 8:33.


| Package | com.sibirjak.jakute |
| Class | public class JCSS_Sprite |
| Inheritance | JCSS_Sprite flash.display.Sprite |
Although it is intended to fully decouple Jaktute Styling Engine code from the actual component implementations, the probable cleanest and preferred way to work is to put the style handling in a base ui class, and let all components inherit from that class. Such a class is JCSS_Sprite.
Notes
JCSS_Sprite has nearly the same interface as JCSS_Adapter with the difference, that all properties and methods carry a leading "jcss_" prefix to avoid collision with component code.
A handler for the component registered event is not available. Related code might be added right to the constructor of the subclass, because the constructor itself performs the registraion.
| Property | Defined by | ||
|---|---|---|---|
| jcss : JCSS
[static]
| JCSS_Sprite | ||
| jcss_cssClass : String
Sets and returns the component css class.
| JCSS_Sprite | ||
| jcss_cssID : String
Sets and returns the component selector ID.
| JCSS_Sprite | ||
| jcss_cssName : String
Sets and returns the component selector name.
| JCSS_Sprite | ||
| jcss_initialized : Boolean [read-only]
Returns true if styles already have been initialized.
| JCSS_Sprite | ||
| jcss_virtualParent : DisplayObject
Sets and gets the virtual parent of a component.
| JCSS_Sprite |
| Property | Defined by | ||
|---|---|---|---|
| _jcssAdapter : JCSS_Adapter
The JCSS adapter.
| JCSS_Sprite |
| Method | Defined by | ||
|---|---|---|---|
|
JCSS_Sprite.
| JCSS_Sprite | ||
|
cleanUp():void
| JCSS_Sprite | ||
|
jcss_childrenEnclosed():Boolean
Returns
true , if encloseChildren() is set, else false. | JCSS_Sprite | ||
|
Removes a style that has formerly been set.
| JCSS_Sprite | ||
|
jcss_commitBulkUpdate():void
Executes a bulk update that was started via
startBulkUpdate() . | JCSS_Sprite | ||
|
jcss_componentSelectorAsString():String
Returns the full selector of a component.
| JCSS_Sprite | ||
|
Defines a style prior to be used with JCSS.
| JCSS_Sprite | ||
|
jcss_encloseChildren():void
Declares all child component to be selectable only via this component selector.
| JCSS_Sprite | ||
|
jcss_getState(stateName:String):String
Returns the value of a component state.
| JCSS_Sprite | ||
|
jcss_getStyle(styleName:String):*
Returns the current value for the given style name.
| JCSS_Sprite | ||
|
jcss_parentChainAsString():String
Returns the JCSS parent chain of a componet.
| JCSS_Sprite | ||
|
Sets a component state.
| JCSS_Sprite | ||
|
Sets a style to a component instance.
| JCSS_Sprite | ||
|
jcss_setStyleSheet(styleSheet:String):void
Sets a style sheet to a component instance.
| JCSS_Sprite | ||
|
jcss_startBulkUpdate():void
Starts a bulk update procedure.
| JCSS_Sprite | ||
|
jcss_styleRuleTreeAsString():String
Returns a formatted tree of all currently set style rules.
| JCSS_Sprite | ||
|
jcss_stylesAsString():String
Returns a formatted String with all currently set styles.
| JCSS_Sprite |
| Method | Defined by | ||
|---|---|---|---|
|
jcss_onStyleRulesChanged(changedStyles:JCSS_ChangeEvent):void
| JCSS_Sprite | ||
|
jcss_onStylesChanged(changedStyles:JCSS_ChangeEvent):void
Default handler for the styles changed event.
| JCSS_Sprite | ||
|
jcss_onStylesInitialized():void
Default handler for the initialized event.
| JCSS_Sprite |
| jcss | property |
public static var jcss:JCSS
| _jcssAdapter | property |
protected var _jcssAdapter:JCSS_Adapter
The JCSS adapter.
| jcss_cssClass | property |
jcss_cssClass:String
[read-write]Sets and returns the component css class.
Can be set initially or at runtime.
Implementation public function get jcss_cssClass():String
public function set jcss_cssClass(value:String):void
| jcss_cssID | property |
jcss_cssID:String
[read-write]Sets and returns the component selector ID.
Can be set only initially (before the initialized event). Otherwise throws an error.
Implementation public function get jcss_cssID():String
public function set jcss_cssID(value:String):void
| jcss_cssName | property |
jcss_cssName:String
[read-write]Sets and returns the component selector name.
Can be set only initially (before the initialized event). Otherwise throws an error.
Implementation public function get jcss_cssName():String
public function set jcss_cssName(value:String):void
| jcss_initialized | property |
jcss_initialized:Boolean
[read-only]Returns true if styles already have been initialized.
Implementation public function get jcss_initialized():Boolean
| jcss_virtualParent | property |
jcss_virtualParent:DisplayObject
[read-write]Sets and gets the virtual parent of a component.
If a virtual parent is set, the component styles are calculated using the virtual parent's display list instead of the physical parent's display list. A virtual parent is a great possibility to connect components that do not have a physical parent-child relation such as tooltips or popups, which usually live in a separated container.
CSS ----------------------------------------------- Button.red ToolTip { color: red; } Button.blue ToolTip { color: blue; } Pseudo code ----------------------------------------------- redButton.onMouseOver = { tooltip.virtualParent = redButton; tooltip.show(redButton.position.toGlobal()); } blueButton.onMouseOver = { tooltip.virtualParent = blueButton; tooltip.show(blueButton.position.toGlobal()); }
Can be set initially or at runtime.
Implementation public function get jcss_virtualParent():DisplayObject
public function set jcss_virtualParent(value:DisplayObject):void
| JCSS_Sprite | () | constructor |
public function JCSS_Sprite()
JCSS_Sprite.
| cleanUp | () | method |
public function cleanUp():void
| jcss_childrenEnclosed | () | method |
public function jcss_childrenEnclosed():Boolean
Returns true
, if encloseChildren()
is set, else false.
Boolean |
| jcss_clearStyle | () | method |
public function jcss_clearStyle(selector:String, styleName:String = null):void
Removes a style that has formerly been set.
If styleName
is specified, the style is removed from the style
rule specified with the given selector.
The method does nothing if a style rule with the given selector has not been
set beforehand or a style with the given styleName
has not been declared
within the style rule described by the given selector.
Using this method to clear styles set to the component directly (by passing
the selector "This"
or ""
) will reset the style
to its default value specified by the component.
selector:String — A selector that matchs a particular component.
|
|
styleName:String (default = null ) — The name of the style to remove.
|
| jcss_commitBulkUpdate | () | method |
public function jcss_commitBulkUpdate():void
Executes a bulk update that was started via startBulkUpdate()
.
Affected components are notified only once regardless of the specific
changes between startBulkUpdate()
and this command.
Ancestor components are always notified before their children. A further order is not specified. It can be possible that children of different branches are notified alternating, e.g. C-1, C-2, C-2.1, C-2.2, C-1.3, C-2.4, C-1.1
| jcss_componentSelectorAsString | () | method |
public function jcss_componentSelectorAsString():String
Returns the full selector of a component.
E.g. Box#mini.highlight
String — The component selector.
|
| jcss_defineStyle | () | method |
public function jcss_defineStyle(styleName:String, styleValue:String, format:uint, priority: = 0):void
Defines a style prior to be used with JCSS.
Styles need to be defined initially. Not initially defined styles are ignored and never affect the particular component.
Styles can only be defined initially (before the initialized event). Otherwise an error is thrown.
ParametersstyleName:String — The name of the style of a component.
|
|
styleValue:String — The initial value of the component style.
|
|
format:uint — The key of the formatter of the style value.
|
|
priority: (default = 0 ) — Style priority (default, fix, important).
|
| jcss_encloseChildren | () | method |
public function jcss_encloseChildren():void
Declares all child component to be selectable only via this component selector.
Enclosing children is useful when setting up stateful default styles that
should not be overriden by accident. In example, we create a Button with several
states and default styles that affect the contained label color. Setting now a
global label color would override the Button declarations and make the label
state insensitive. Invoking encloseChildren()
lets match only styles rules
that include this component in the selector chain.:
Without encloseChildren(); ----------------------------------------------- myButton.setStyle(":over Label", "color", "red", "default"); // Button Label is red on mouse over by default. JCSS.getInstance().setStyle("Label", "color", "blue"); // Button Label is now blue even on mouse over. With encloseChildren(); ----------------------------------------------- myButton.setStyle(":over Label", "color", "red", "default"); // Button Label is red on mouse over by default. myButton.encloseChildren(); JCSS.getInstance().setStyle("Label", "color", "blue"); // Does not affect the Button Label. JCSS.getInstance().setStyle("Button Label", "color", "blue"); // Button Label is now blue, since the selector includes Button.
This method can be called only initially (before the initialized event). Otherwise an error is thrown.
| jcss_getState | () | method |
public function jcss_getState(stateName:String):String
Returns the value of a component state.
ParametersstateName:String |
String — The state value.
|
| jcss_getStyle | () | method |
public function jcss_getStyle(styleName:String):*
Returns the current value for the given style name.
Returns initially (before the initialized event) null
, for sure.
styleName:String — The name of the style.
|
* — The current value of the style.
|
| jcss_onStyleRulesChanged | () | method |
protected function jcss_onStyleRulesChanged(changedStyles:JCSS_ChangeEvent):void
Parameters
changedStyles:JCSS_ChangeEvent |
| jcss_onStylesChanged | () | method |
protected function jcss_onStylesChanged(changedStyles:JCSS_ChangeEvent):void
Default handler for the styles changed event.
Template method, to be overridden in a sub class.
ParameterschangedStyles:JCSS_ChangeEvent — All recently changed styles.
|
| jcss_onStylesInitialized | () | method |
protected function jcss_onStylesInitialized():void
Default handler for the initialized event.
Template method, to be overridden in a sub class.
| jcss_parentChainAsString | () | method |
public function jcss_parentChainAsString():String
Returns the JCSS parent chain of a componet.
E.g. Box#mini.highlight(64) < Box(56) < Box(48) < Box.blue(39)
String — The parent chain of a component.
|
| jcss_setState | () | method |
public function jcss_setState(stateName:String, value:String):void
Sets a component state.
Can be set initially or at runtime.
ParametersstateName:String — The name of the state.
|
|
value:String — The value of the state.
|
| jcss_setStyle | () | method |
public function jcss_setStyle(selector:String, styleName:String, styleValue:uint, priority: = 1):void
Sets a style to a component instance.
It is possible to repeatedly invoke this method with equal style rules. They are then merged together for performance reasons, no worries, too.
Parametersselector:String — A selector that matchs a particular component.
|
|
styleName:String — The name of the style to set.
|
|
styleValue:uint — The value of the style to set.
|
|
priority: (default = 1 ) — The style priority (null, "!important" or "default").
|
| jcss_setStyleSheet | () | method |
public function jcss_setStyleSheet(styleSheet:String):void
Sets a style sheet to a component instance.
The style sheet can be loaded from an external source or created at runtime.
var styleSheet : String = <styles><![CDATA[ Box { backgroundColor: 0xFF0000; } ]]></styles>.toString()
It is possible to repeatedly invoke this method with different style sheets. Equal style rules in different or the same sheet are merged together for performance reasons, no worries.
ParametersstyleSheet:String — The stylesheet to set.
|
| jcss_startBulkUpdate | () | method |
public function jcss_startBulkUpdate():void
Starts a bulk update procedure.
If invoked, affected components are buffered and notified only once
after a later call of commitBulkUpdate()
. If there are
different styles or state to set, that might affect a particular multiple
times, it is recommended to wrap the update in the bulk transaction.
| jcss_styleRuleTreeAsString | () | method |
public function jcss_styleRuleTreeAsString():String
Returns a formatted tree of all currently set style rules.
The following example shows a style sheet and its tree representation.
var styleSheet : String = <styles><![CDATA[ ToolTip { borderSize: 0; } Blue { backgroundColor: #0000CC; borderColor: #000066; color: #FFFFFF; } Blue ToolTip { backgroundColor: #6666FF; color: #FFFFFF; } Red { backgroundColor: #CC0000; borderColor: #660000; color: #FFFFFF; } Red ToolTip { backgroundColor: #FF6666; color: #FFFFFF; } Yellow { backgroundColor: #CCCC00; borderColor: #666600; } Yellow ToolTip { backgroundColor: #FFFF66; } ]]></styles>.toString();
[This 2] |_____[Yellow 22] | >This Yellow specifity:2 { | backgroundColor: #CCCC00 (12); | borderColor: #666600 (13); | } |_____[ToolTip 26] | >This Yellow ToolTip specifity:3 { | backgroundColor: #FFFF66 (14); | } |_____[Blue 8] | >This Blue specifity:2 { | backgroundColor: #0000CC (2); | color: #FFFFFF (4); | borderColor: #000066 (3); | } |_____[ToolTip 12] | >This Blue ToolTip specifity:3 { | backgroundColor: #6666FF (5); | color: #FFFFFF (6); | } |_____[ToolTip 5] | >This ToolTip specifity:2 { | borderSize: 0 (1); | } |_____[Red 15] | >This Red specifity:2 { | backgroundColor: #CC0000 (7); | color: #FFFFFF (9); | borderColor: #660000 (8); | } |_____[ToolTip 19] | >This Red ToolTip specifity:3 { | backgroundColor: #FF6666 (10); | color: #FFFFFF (11); | }
String |
| jcss_stylesAsString | () | method |
public function jcss_stylesAsString():String
Returns a formatted String with all currently set styles.
Styles for Box#mini.highlight(64) < Box(56) < Box(48) < Box.blue(39) borderColor: 255; ------------------------------ specifity:103 timestamp:7 backgroundColor: 16777215; ------------------------------ specifity:3 timestamp:11 borderAlpha: 0.5; ------------------------------ specifity:2 timestamp:2 color: 0 default; ------------------------------ specifity:40001 timestamp:35 borderSize: 1; ------------------------------ specifity:2 timestamp:1
String — Currently set styles in a formatted string.
|


Nameless Spirit:
What do you want? I have nothing to say to you.
(Characters must have achieved at least level 74 and completed the "Last Imperial Prince" quest before undertaking this quest.)


Plugins in Capacitor are centered around JavaScript modules that call into Capacitor's runtime to perform actions on the underlying platform.
Plugins thus consist of a simple JavaScript layer installed through npm
, and then platform specific
dependencies that are managed by each platform's dependency manager of choice.
Found a plugin you like? First, install its JS library through npm:
npm install --save capacitor-plugin-guacamole
Some plugins support iOS, Android, Electron, the web, or only a subset of those options.
For a CocoaPod based plugin, cd into your ios
platform directory and run


RNANO(1) RNANO(1) NAME rnano - Restricted mode for Nano's ANOther editor, an enhanced free Pico clone SYNOPSIS rnano [OPTIONS] [[+LINE,COLUMN] FILE]... DESCRIPTION This manual page briefly documents the rnano command. nano is a small, free and friendly editor which aims to replace Pico, the default editor included in the non-free Pine package. Rather than just copying Pico's look and feel, nano also implements some missing (or dis‐ abled by default) features in Pico, such as "search and replace" and "go to line and column number". rnano is a restricted version of nano, which only edits specific files and doesn't allow the user access to the filesystem or a command shell. In restricted mode, nano will not: · read or write to any file not specified on the command line; · read any nanorc files; · allow suspending; · allow a file to be appended to, prepended to, or saved under a differ‐ ent name; · use backup files or spell checking. OPTIONS +LINE,COLUMN Places cursor at line number LINE and column number COLUMN (at least one of which must be specified) on startup, instead of the default of line 1, column 1. -? Same as -h (--help). -h (--help) Show a summary of command line options and exit. -V (--version) Show the current version number and exit. See the nano(1) manpage for the complete documentation of nano. BUGS Please send any comments or bug reports to<EMAIL_ADDRESS>The nano mailing list is available from<EMAIL_ADDRESS>To subscribe, email to<EMAIL_ADDRESS>with a subject of "sub‐ scribe". HOMEPAGE http://www.nano-editor.org/ AUTHOR Chris Allegretta<EMAIL_ADDRESS>et al (see AUTHORS for details). This manual page was originally written by Thijs Kinkhorst<EMAIL_ADDRESS>for the Debian system (but may be used by others). August 23, 2007 version 2.0.0 RNANO(1)


(Coming soon)
Our ship set sail in Gurgaon, when we decided to rent a room and start building something amazing.
We buy the domain name for Blivet Labs. We are blivetlabs.com now :D
The Lazy Hacker
The Crazy Optimist
The Sassy Designer


canvas::zoom - Zoom control for canvas::sqmap
This package provides a widget to enable the user of a map display to control the zoom level.
Creates the zoom control widget pathName and configures it. The methods and options supported by the new widget are described in the following sections.
The result of the command is pathName.
The widget supports no methods beyond the standard (configure, cget, etc.).
This document, and the package it describes, will undoubtedly contain bugs and other problems. Please report such in the category canvas of the Tklib Trackers. Please also report any ideas for enhancements you may have for either package and/or documentation.


Before Change
<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
for k, v in info_plist_dict.items():
info_plist += u"<key>%s</key>\n<string>%s</string>\n" % (k, v)
info_plist += u</dict>
</plist>
After Change
plist_filename = os.path.join(self.name, "Contents", "Info.plist")
try:
// python >= 3.4
with open(plist_filename, "wb") as plist_fh:
plistlib.dump(info_plist_dict, plist_fh)
except AttributeError:
// python 2.7
plistlib.writePlist(info_plist_dict, plist_filename)


The best way for me to compare the three languages is to think of HTML as the framework or basic structure much like a housing frame.
CSS is the decor, layout of rooms, colours etc. JavaScript is like the wiring that makes everything work, JavaSript controls the behaviour of the code (elements).
Control Flows allow the coder to run certain scenaros or until certain conditions are met using different staements, eg; IF today is Saturday then alarm goes off at 9.00am ELSE alarm goes off at 7.00am.
Loops let you run code a certain number of times until a condition is met, eg; When cleaning teeth, Brush up and down, are teeth clean yes/no IF yes then stop, ELSE repeat, etc etc
Arrays and objects are similar, whats different is how they are structered. Arrays apply numbers to strings (item listed) so to access anything in an array you would need
to call the number related to that particular string.
Objects are similar in that thay store information and you call that information out from them, but the information is stored differently
Objects store there info in lists and they are referred to as keys and values, the key is similar to a heading and the value id usually related
to that heading for eg: headig would be name value would be Bob, to call the information you waould call the key and it would output the
value for that key.
Functions group together a set of statements that calculates a value, to run a function you need to call it, the function will
then perform the specified actions to provide an output.


This room will be removed from the realm or everwhere.
If you change your mind later, choose
[ChatPlus Controls]
[Realm Controls]
The name of the realm
Rooms to Hide
And remove the room from that list.
If you removed it from EVERYWHERE
[ChatPlus Controls]
[Master Controls]
Rooms to never see
|


I've been enhancing ACO's support for extended precision integers in a number of ways. In particular
I now support 192 bit integers instead of 160 bit integers. Current documentation on elliptic curve cryptography suggests that 160 bit keys are no longer considered secure.
I added support for addition and subtraction in the field Fp (for 192 bit primes p). This is in anticipation of my intended ECC application.
All SPARK verification conditions for the previously defined subprograms have been discharged. This proves they are free of runtime errors (won't throw any exceptions), but does not prove that they necessarily compute the correct values.
I started implementing a division subprogram that will divide a 384 bit dividend by a 192 bit divisor (producing a 384 bit quotient and a 192 bit remainder).
For division I'm following Donald Knuth's "Algorithm D" in his book The Art of Computer Programming, Volume 2: Seminumerical Algorithms. Currently I have an implementation that appears to work and is acceptable to the SPARK Examiner, but it has undischarged verification conditions.
Fully handling all VCs in my implementation of Algorithm D is likely to be challenging.
The problem is that the algorithm as published by Knuth (and at
least one other
implementation I've seen on line) relies on the fact that the estimated quotient digit
Q_Hat
is, after a couple of possible adjustments, really a single digit
number. There is a critical place in the algorithm where Q_Hat
is stored in a
single digit storage area. Naturally SPARK wants to be sure it will fit and generates a VC
with a conclusion saying so.
Unfortunately the argument that allows one to conclude Q_Hat
is a single
digit at that point is non-trivial. I haven't yet worked out the details myself, but it
appears to require fairly high level reasoning about what is going on in the algorithm.
Discharging the critical VC I mentioned above will therefor require conveying that
reasoning to the SPARK tools in some manner.
Recently Alexander Senier announced on comp.lang.ada his library of cryptographic algorithms in SPARK called libsparkcrypto. Based on the project's web page it looks like libsparkcrypto's basic goals overlap considerably with my goals for ACO. Also at the moment libsparkcrypto contains a much richer collection of algorithm implementations than the meager set in ACO and is more polished than ACO. If you have an immediate need for a cryptography library in SPARK, libsparkcrypto is in a better position to meet that need.
Of course who knows what the future will bring. ACO contains a collection of high level object-oriented wrappers intended to abstract out various cryptographic interfaces in a useful way. Those wrappers are not SPARK but for applications that don't need SPARK they might be more convenient than interacting with the low level algorithms directly. Also my long term plans for ACO entail supporting various cryptographic and security services beyond "just" algorithm implementations. On the other hand talk is cheap. It is entirely possible that those plans will never be realized.
In any case it is good to have options. When I started ACO it appeared to me that the other Ada cryptographic libraries I found were either dead projects or did not have the sort of algorithms I needed. It is good for the Ada ecology in general and for SPARK in particular to have two SPARK cryptography libraries being actively developed. Since ACO is primarily a hobby project for me, I don't mind reinventing the wheel as long as I'm having fun doing it!
Several years ago I wrote, largely as an exercise, a general purpose extended precision integer class for C++. Knowing that extended precision integers were needed for certain cryptographic algorithms, I later translated my C++ class into Ada with the intention of using it with ACO.
My original Ada version followed my C++ class's design and featured support for signed integers of arbitrary size. This is fine as far as it goes, but the implementation also used dynamic memory allocation (via the Ada 2005 Vectors package). When I decided to implement the core algorithms in ACO using SPARK I needed to rework my extended integer package to conform to SPARK rules. I removed the ability to dynamically resize the integers and I also dropped support for negative integers. I don't believe I will need negative values in my intended cryptographic applications (but we'll see).
The result is a package providing a type Very_Long
that, currently, only
supports 160-bit unsigned values. All operations on a Very_Long
object are
implicitly done modulo 2160. My choice of 160-bit values is tied to my immediate need. I
anticipate soon adding support in ACO
for elliptic curve
based (ECC) public key algorithms. Such algorithms do their computations in an underlying
field such as Fp for some large prime p. It turns out that 160-bit field sizes
provides reasonable security with ECC algorithms. Focusing on that size should be
sufficient for now.
Ultimately I would like to support various field sizes, of course, and also
use Very_Long
objects to support other public key schemes besides ECC. A
secure application of the RSA algorithm, for example, needs much larger integers. However,
writing generalized SPARK code is a little tricky because SPARK currently supports neither
generics nor object oriented techniques. Since everything in SPARK needs to be statically
sized it seems likely that a general purpose Very_Long
type would need to
always allocate enough memory for the largest values that would ever be needed. Of course
this is an inefficient use of memory for applications that need only small values. My plan
is to address this issue at a later time.
I moved the development site for ACO from SourceForge to Assembla. I have nothing against SourceForge, but I'm using Assembla for another project (the VTC CubeSat Laboratory), and I find that I like it fairly well. Assembla feels lighter weight than SourceForge and that seems like a better fit for a small scale project of this nature. Also Assembla's site does not use ads which provides a nicer experience for visitors.
The Assembla site is a little rough at the moment. I hope to get it configured in the next few weeks. I also hope to pick up the pace of development on ACO itself. This work deserves more attention than I've been giving it recently.
The old SourceForge site still exists and is basically frozen. SourceForge's policy is to hold moved projects in an archived state for reference purposes. That seems like a reasonable policy. In fact, I could even imagine moving ACO development back to SourceForge at some future time depending on how things unfold.
I recently committed a draft implementation of the SHA-1 hash algorithm to the ACO repository. This implementation is only a draft because it currently lacks any test cases and documentation. I thus consider it to be incomplete at this time. However, this is the first activity in the ACO project in a while so I thought it would be good to post a message about it anyway. I am alive! Hopefully I will be able to make steady progress from now on.
My SHA-1 implementation follows as directly as possible the description of the primary algorithm given in FIPS 180-1. My idea was to create an implementation that could eventually be proved correct with respect to the specification. I assumed that would be easier if I followed the specification as literally as possible. Alas, constructing a proof of correctness will be complicated by the fact that the specification isn't as formal as one might like. I will worry about that problem later. In the meantime it is my hope that my implementation is at least easy to review manually.
Ultimately I would also like to provide an implementation of the low memory consuming "alternate" algorithm described in FIPS 180-1. Of course it will additionally be necessary to formally show that the alternate algorithm produces the same result as the primary algorithm (FIPS 180-1 doesn't really do this), and that my implementation of it is correct with respect to its specification. What fun!
I decided to try using SPARK after I had already started the design of the ACO library and implemented one encryption algorithm (Blowfish). Once I decided to use SPARK for the core algorithms, I knew that I needed to refactor my existing code to make it conform to SPARK rules. I wasn't sure how that was going to work out so I felt the refactoring had to be done right away to ensure that it was even going to be possible.
I just completed the refactoring yesterday. I had to rearrange a number of packages, as
expected, but overall it went fine and the resulting code is quite reasonable. The main
tricky aspect was related to the intrinsic shift procedures. GNAT
provides Shift_Left
and
Shift_Right
procedures as "intrinsics" in package Interfaces
.
This means that they are compiled directly into single machine instructions without
procedure call overhead. However, I didn't want to use the types defined in
package Interfaces
because I wanted to use representation clauses to define
the properties of my basic types precisely (specifically, the size). Such clauses must
appear in the same package as where the type is defined, and I don't have the option of
editing the library package Interfaces
.
However, my benchmark experiments with Blowfish showed that it was very important to
performance to use the intrinsic procedures. Correctness may have first priority in ACO,
but performance is important too. I didn't feel like I could worry about this matter
later. Fortunately GNAT allows me to specify procedures of my own as intrinsic provided
the procedures have the proper names and operate on types with appropriate properties.
This allowed me to define Shift_Left
and Shift_Right
procedures
for my type ACO.Octet
while retaining the speed of the intrinsic
operations.
The complication that arose was that I also wanted to do the same for the
types ACO.Double_Octet
, ACO.Quadruple_Octet
,
and ACO.Octuple_Octet
. To make all the necessary shifts intrinsic I had to
use particular procedure names. However, SPARK does not allow overloading of procedure
names so this created a conflict between SPARK rules and my desire for an efficient
implementation. To work around this, I created separate packages for the operations on
each type. This caused something of a proliferation of packages, but it worked out to be a
reasonable approach.
I also factored out the core algorithms from the object oriented interfaces so that the core algorithms could be made SPARKable while still retaining the convenient interfaces for users who want them. This went smoothly. There is now slightly more overhead involved when using the object oriented interfaces than there used to be because of the extra layer of procedure calling involved. However, benchmark tests on Blowfish show only a slight slowdown due to this effect. The beauty of this approach is that while the main algorithms are (will be) SPARKable, the high level interfaces made available by the library can continue to use full Ada 2005.
So far I have only applied flow annotations to the packages that I intend to be SPARKable. This helps increase confidence in those packages somewhat, but I believe the real gain in reliability will come when I start using the proof annotations. I intend to put that off for a while, however, until the library has been fleshed out a bit more. Yet even the flow annotations are useful. They forced me to properly check error status on all called procedures; something I hadn't been doing consistently before.
I feel that now the basic structure of ACO is complete and what remains is mostly a matter of building on that structure with actual algorithm implementations. I will probably continue by implementing SHA1 next.
How does one test an implementation of a cryptographic algorithm? This question is surprisingly tricky. In general many algorithms have at least some easy to determine correct results, so writing test cases for them is relatively straight forward. For example consider red-black trees. If one inserts a collection of integers into a red-black tree it is easy to see that a search operation on one of those integers should succeed. The test case author can now focus on writing test cases that search for particularly "interesting" integers so the insertion and search code are well exercised. However, the output of an encryption algorithm looks indistinguishable from random data. How can one know what the correct "random" data should be? Of course one could decrypt the result of encryption and verify that it agrees with the original input. Such round trip testing is certainly valuable but it's not enough. A round trip might succeed even though the ciphertext produced by the encryption is wrong. The implementation of decryption would have to be flawed in a complementary way, but it is easy to imagine that happening.
It seems like the only way to really test the validity of an encryption implementation is to check its output against a known correct implementation. The problem is how do we know a correct implementation when we see it? Certainly if multiple independently written implementations produce the same output that increases confidence in the correctness of all of them. However, how many implementations of an algorithm are really independently written?
For example, the Blowfish algorithm is initialized with 4168 digits from the hexadecimal expansion of Pi. The implementation of Blowfish currently in ACO uses the values for those digits that are posted on Bruce Schneier's web site. As a result ACO's implementation of Blowfish is not 100% independent of Schneier's. If those digits of Pi are wrong, we are both wrong in the same way. Even when multiple implementations of an algorithm are written independently there is still a possibility of them all making the same error, each on their own. While this might seem unlikely, it is certainly conceivable.
Published cryptographic algorithms are analyzed for security using mathematical methods. That analysis is done based on the published formal description of the algorithm. In order to ensure that an implementation of a cryptographic algorithm actually provides the security the theoretical results suggest, it is important to be using code that actually implements the algorithm's specification correctly. No amount of checking against other implementations will verify that the formal mathematical specification is being followed. Thus I submit that one should instead try to prove that an implementation is correct using formal methods.
It is for this reason that I intend to use the SPARK tools during the development of ACO. Although ACO is not at this point yet, I hope to eventually use SPARK to formally prove the correctness of all the core algorithms in the library. Of course formal proof at the level of the source code will not find errors in the compiler's code generator, or in numerous other places where errors might arise. Thus I fully intend to also check ACO's output against other implementations. It is my hope that the combination of testing and formal proof will give users a high level of confidence that ACO library actually provides the security assurances claimed by the published mathematical analysis.
This is a blog about the Ada Cryptographic Objects (ACO) library and all things related to it. ACO is a pet project of mine to build a high quality crypto library in Ada. I have a number of Ada projects in mind that could use cryptography and for various reasons none of the existing free crypto libraries really suited my tastes. In any case, as a hobby project this effort is not necessarily about quick development or maximum software reuse. Rather this project is just for my own enjoyment. Using other people's code, while highly practical, isn't nearly as much fun as writing my own.
Right now ACO is in its early stages. Most of my work has been focused on organizing the library rather than actually implementing cryptographic algorithms. I believe this is as it should be since I want to create a good foundation for the library before spending a lot of time writing the wrong code. I am using the AUnit unit test framework for my unit tests, I am building benchmark programs to check the performance of my algorithm implementations, and I am writing detailed documentation for ACO as I write the code. I hate dealing with software that has incomplete documentation and I don't want ACO to have that problem.
My plan is also to use the SPARK tool set to analyze my implementation of the core algorithms. SPARK is a powerful static analysis tool that can be used, for example, to help prove the correctness of one's code. I'm not sure right now how far I will take my use of SPARK; I'm using it here partly to learn about SPARK's issues and capabilities.
Right now ACO lives on SourceForge. I have been using the developers forum there to make notes about my work as I go along. My thought was that if another developer joins me in the future he or she might want to review those notes to get a better understanding of my design decisions and why I made them. After making a few entries in the developers forum, I realized that I probably really should be posting such material in a public place. Others who are interested in Ada, cryptography, or highly reliable software might be interested in following or commenting on ACO's development. It is in that spirit that I created this blog.


| NCBI/PubChem | NCI/CIR |
|---|---|
|
test http sync (failing in FF)
test https sync (works)
test http async (failing in FF) test https async (works) My observations are that PubChem access is now (as of 3/7/2014) by https only. This is a problem. |
test http sync (works)
test https sync (will time out)
test http async (works) test https async (will time out) NCI's Chemical Identifier Resolver does not provide https service. This is a different problem. |


01 - JavaScript Drum Kit
02 - JS and CSS Clock
/03 - CSS Variables
04 - Array Cardio Day 1
05 - Flex Panel Gallery
06 - Type Ahead
07 - Array Cardio Day 2
08 - Fun with HTML5 Canvas
09 - Dev Tools Domination
10 - Hold Shift and Check Checkboxes
11 - Custom Video Player
12 - Key Sequence Detection
13 - Slide in on Scroll
14 - JavaScript References VS Copying
15 - LocalStorage
16 - Mouse Move Shadow
17 - Sort Without Articles
18 - Adding Up Times with Reduce
19 - Webcam Fun
20 - Speech Detection
21 - Geolocation
22 - Follow Along Link Highlighter
23 - Speech Synthesis
24 - Sticky Nav
25 - Event Capture, Propagation, Bubbling and Once
26 - Stripe Follow Along Nav
27 - Click and Drag
28 - Video Speed Controller
29 - Countdown Timer
30 - Whack A Mole


High dimensional interaction search by brute force requires a quadratic computational cost in the number of variables. The xyz algorithm provably finds strong interactions in almost linear time. For details of the algorithm see: G. Thanei, N. Meinshausen and R. Shah (2016). The xyz algorithm for fast interaction search in high-dimensional data <https://arxiv.org/pdf/1610.05108v1.pdf>.
| Version: | 0.2 |
| Imports: | stats, Rcpp (≥ 0.12.6) |
| LinkingTo: | Rcpp |
| Suggests: | knitr, rmarkdown |
| Published: | 2017-04-03 |
| Author: | Gian-Andrea Thanei |
| Maintainer: | Gian-Andrea Thanei <thanei at stat.math.ethz.ch> |
| License: | GPL-2 | GPL-3 [expanded from: GPL] |
| NeedsCompilation: | yes |
| SystemRequirements: | C++11 |
| Materials: | README |
| CRAN checks: | xyz results |
| Reference manual: | xyz.pdf |
| Vignettes: |
Vignette Title |
| Package source: | xyz_0.2.tar.gz |
| Windows binaries: | r-devel: xyz_0.2.zip, r-release: xyz_0.2.zip, r-oldrel: xyz_0.2.zip |
| OS X binaries: | r-release: xyz_0.2.tgz, r-oldrel: xyz_0.2.tgz |
| Old sources: | xyz archive |
Please use the canonical form https://CRAN.R-project.org/package=xyz to link to this page.


--- layout: page title: "Papermaking classes, events, news" main_image_path: image_caption: permalink: /posts/ frontpage: false description_markdown: frontpagetitle: _options: layout: hidden: true image_path: uploads_dir: "assets/images/:year" width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg main_image_path: uploads_dir: "assets/images/:year" width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg content: uploads_dir: "assets/:year" ---
Regular studio updates, pictures and news are now on Facebook at Lucy Baxandall Paperwoman (it's a public page so you don't need a Facebook account to view it, only if you want to like, comment or share). I also post frequent updates on Twitter as @LucyPaperBax and Instagram as Lucypaperbax, so feel free to follow.
You can join my mailing list via the contact page for email updates at decent intervals.
We can arrange a studio visit or customised workshop for up to four people, adults or children - anything from an introduction to papermaking to more specialised areas. If you are an artist or student who wishes to incorporate handmade paper into a project, I would be happy to help. I also provide a very reasonably-priced fibre processing service if you don't have access to a beater.
Lucy is available to teach papermaking and bookbinding workshops for adults and children by arrangement. Please use the contact page to discuss your requirements.
{% else %}
{% endif %} {{ post.content | strip_html | truncatewords: 50 }} read more
{% endfor %}


Data Science Capstone Project (ITEC877) - Marking Criteria for Supervisors at the Company
85-100 (High Distinction):
The student's quality of work exceeded your expectation, the student's effort was well above your expectations, the student was very professional and the student strongly desired to improve and learn.
75-84 (Distinction):
The student's quality of work met your expectations, the student's effort was sufficient, the student was sufficiently professional, and the student sufficiently desired improvement and learning.
65-74 (Credit):
The student's quality of work was below standard but met your expectations, the student's effort was poor, the student was not professional, the student had little desire for improvement and learning.
50-64 (Pass):
The student's quality of work didn't met your expectations but the student's effort Provided sufficient evidence of the achievement of projects's learning outcomes.
0-49 (Fail):
The student's quality of work didn't met your expectations and the student's effort did not provide evidence of attainment of project's learning outcomes.
Data Science Capstone Project (ITEC877) - Report Templates
Mid-Term Report structure
Final Project Presentation Slide Template
Final Project report structure
Final Project Report Template
template-MQ-Data Science Project-letter


|
Assimp
5.0.1, master @ cd42b955
|
Loads the material description from a mtl file. More...
Public Types | |
| typedef std::vector< char >::const_iterator | ConstDataArrayIt |
| typedef std::vector< char > | DataArray |
| typedef std::vector< char >::iterator | DataArrayIt |
Public Member Functions | |
| ObjFileMtlImporter (const ObjFileMtlImporter &rOther)=delete | |
| ObjFileMtlImporter (std::vector< char > &buffer, const std::string &strAbsPath, ObjFile::Model *pModel) | |
| The class default constructor. More... | |
| ~ObjFileMtlImporter () | |
| The class destructor. More... | |
| ObjFileMtlImporter & | operator= (const ObjFileMtlImporter &rOther)=delete |
Static Public Attributes | |
| static const size_t | BUFFERSIZE = 2048 |
Private Member Functions | |
| void | createMaterial () |
| Creates a new material from loaded data. More... | |
| void | getColorRGBA (aiColor3D *pColor) |
| Get color data. More... | |
| void | getFloatValue (ai_real &value) |
| Gets a float value from data. More... | |
| void | getIlluminationModel (int &illum_model) |
| Get illumination model from loaded data. More... | |
| void | getTexture () |
| Get texture name from loaded data. More... | |
| void | getTextureOption (bool &clamp, int &clampIndex, aiString *&out) |
| void | load () |
| Copy constructor, empty. More... | |
Private Attributes | |
| std::vector< char > | m_buffer |
| Helper buffer. More... | |
| DataArrayIt | m_DataIt |
| Data iterator showing to the current position in data buffer. More... | |
| DataArrayIt | m_DataItEnd |
| Data iterator to end of buffer. More... | |
| ObjFile::Model * | m_pModel |
| USed model instance. More... | |
| std::string | m_strAbsPath |
| Absolute pathname. More... | |
| unsigned int | m_uiLine |
| Current line in file. More... | |
Loads the material description from a mtl file.
| typedef std::vector<char>::const_iterator Assimp::ObjFileMtlImporter::ConstDataArrayIt |
| typedef std::vector<char> Assimp::ObjFileMtlImporter::DataArray |
| typedef std::vector<char>::iterator Assimp::ObjFileMtlImporter::DataArrayIt |
| Assimp::ObjFileMtlImporter::ObjFileMtlImporter | ( | std::vector< char > & | buffer, |
| const std::string & | strAbsPath, | ||
| ObjFile::Model * | pModel | ||
| ) |
The class default constructor.
| Assimp::ObjFileMtlImporter::~ObjFileMtlImporter | ( | ) |
The class destructor.
|
delete |
|
private |
Creates a new material from loaded data.
|
private |
Get color data.
|
private |
Gets a float value from data.
|
private |
Get illumination model from loaded data.
|
private |
Get texture name from loaded data.
|
private |
|
private |
Copy constructor, empty.
Load the whole material description
|
delete |
|
static |
|
private |
Helper buffer.
|
private |
Data iterator showing to the current position in data buffer.
|
private |
Data iterator to end of buffer.
|
private |
USed model instance.
|
private |
Absolute pathname.
|
private |
Current line in file.


Note the YAML contains specifications for a github document and html. The best way to deal with this is to knit them separately from the knit menu. Otherwise the html has blurry plots and tends to delete the md cached plots unless you tell it to cache everything!
library(tidyverse)
library(cowplot)
library(broom)
library(modelr)
library(viridis)
library(lubridate)
library(knitr)
#knitr::opts_knit$set(root.dir = '/Users/scottsaunders/git/labwork/IDA/12_10_18')
knitr::opts_chunk$set(tidy.opts=list(width.cutoff=60),tidy=TRUE, echo = TRUE, message=FALSE, warning=FALSE, fig.align="center")
theme_1 <- function () {
theme_classic() %+replace%
theme(
axis.text = element_text( size=12),
axis.title=element_text(size=14),
strip.text = element_text(size = 14),
strip.background = element_rect(color='white'),
legend.title=element_text(size=14),
legend.text=element_text(size=12),
legend.text.align=0,
panel.grid.major = element_line(color='grey',size=0.1)
)
}
theme_set(theme_1())
source("../../tools/echem_processing_tools.R")
I finally tried the experiment that Jackie has been encouraging me to do for a while. The idea was to treat an IDA biofilm with psoralen (a DNA crosslinker) in an attempt to disrupt DNA CT. If PYO participates in DNA CT in the biofilm, we would expect that psoralen treatment affects the measured \(D_{ap}\).
First let’s just look at the plot of swv signal vs. gc signal. The slope of these lines is proportional to \(D_{ap}\) (\(m\sim \sqrt{D_{ap}}\)).
gc_swv_equil <- read_csv("../Processing/12_04_18_processed_gc_swv_equil.csv")
ggplot(gc_swv_equil, aes(x = signal_from_swv, y = signal_from_gc,
color = condition)) + geom_point() + geom_line() + facet_wrap(~segment,
scales = "free") + ylim(0, 1.2e-08)
This plot is showing how GC collector current scales with SWV current for 5 different concentrations of PYO soaks (25,50,75,100,200uM), and that data has been quantified for segments 1 and 2 of the GC scan. The GC data is being compared to i1 from the SWV.
You can see that the control curves look pretty similar between the segments and look relatively linear. In contrast, the psoralen biofilms look a little different depending on which segment is quantified and it appears like the slope might be less than the control.
Fitting linear models to this plot verifies our intuition, but remember it’s only fitting 5 datapoints…
ggplot(gc_swv_equil, aes(x = signal_from_swv, y = signal_from_gc,
color = condition)) + geom_point() + geom_smooth(method = "lm") +
facet_wrap(~segment, scales = "free") + ylim(0, 1.2e-08)
So, the question is: “Is this difference in slope actually meaningful?”
equil_lm <- gc_swv_equil %>% group_by(condition, segment) %>%
do(tidy(lm(signal_from_gc ~ signal_from_swv, .)))
knitr::kable(equil_lm %>% filter(term == "signal_from_swv"))
| condition | segment | term | estimate | std.error | statistic | p.value |
|---|---|---|---|---|---|---|
| control | 1 | signal_from_swv | 0.2415593 | 0.0105240 | 22.953187 | 0.0001811 |
| control | 2 | signal_from_swv | 0.2558664 | 0.0155098 | 16.497120 | 0.0004848 |
| psoralen | 1 | signal_from_swv | 0.1137052 | 0.0247621 | 4.591910 | 0.0194044 |
| psoralen | 2 | signal_from_swv | 0.1335914 | 0.0340230 | 3.926509 | 0.0293980 |
Based on this linear model the two slopes are actually different. So the experiment worked! Right?? Not necessarily.
I decided to explicitly measure the background signal in the solution on a blank electrode. I expected that there would be very little signal…but I was wrong. Here’s a plot of GCs from the biofilms compared to the respective blank scans.
blank_GC_scans <- read_csv("../Processing//12_04_18_processed_blank_GC_scans.csv")
ggplot(blank_GC_scans %>% filter(E < 0), aes(x = E, y = current,
color = blank)) + geom_point() + facet_wrap(PHZadded ~ condition,
scales = "free") + scale_x_reverse()
Therefore, the solution phase PYO is likely significant enough to affect the measured biofilm “equilibrium” current.
One option could be to background subtract the biofilm GC curve from the blank. However this assumes \[I_{gc} = I_{biofilm}+I_{solution}\]
This may be a reasonable assumption, but we know during the biofilm soak step, that it seems like biofilm coated electrodes actually show less signal than bare electrodes. Remember that \(I_{gc}\) depends on concentration, but also on \(D_{ap}\). So even if the biofilm does sequester a high concentration of PYO near the electrode, if it is diffusing slowly it will not contribute in the same way as the solution PYO.
Therefore, it seems dangerous to background subtract and draw conclusions from that data, but just for fun let’s do exactly that.
From quantifying the curves in the above plot, we can now plot the background subtracted GC signal vs. added soak [PYO]. Ideally we would use the background subtract the SWV signal, but the signal isn’t that easy to work with, and isn’t worth it right now. Also unfortunately, we only have background signals from the blank electrode for two datapoints from each condition…so we’re just going to connect two points with a line.
gc_bgsub_swv <- read_csv("../Processing/12_04_18_processed_gc_swv_bgsub.csv")
ggplot(gc_bgsub_swv, aes(x = PHZaddedInt, bg_signal, color = condition,
shape = factor(segment))) + geom_point() + geom_line()
Obviously, this is pretty sparse data, but it does show that the control biofilm shows a positive slope with increasing PYO for segments 1 and 2, while the psoralen treated biofilm shows zero or negative slope. If this were an accurate reflection of the biofilm GC signal, it would suggest that the control has a measureable \(D_{ap}\), while the psoralen treated biofilm doesn’t really have a slope at all and therefore \(D_{ap}\) is significantly reduced.
This is definitely thought provoking, but it will require further experiments to make any legitimate point.
Thankfully, due to my paranoia about this experiment, I did the 12_10_18 experiment. This experiment seemed to indicate that we can actually take GC measurements during the 1 hour equilibration to get measurements at multiple concentrations. Taking the same approach with psoralen biofilms will make it easier to get quality data.


NEW VERMONT
Labels
EDGES
Aromatic stacking
Hydrogen bond
Hydrophobic
Repulsive
Salt bridge
CINEMA
Polar Positive
H,K,R
Polar Negative
D,E
Polar Neutral
N,Q,S,T
Non-Polar Aliphatic
A,G,I,L,M,V
Non-Polar Rings
F,P,W,Y
Cysteine
C
Grafo
Filters
FILTER BY LINK TYPE
Select the interactions
Aromatic stacking
Hydrogen bond
Hydrophobic
Repulsive
Salt bridge
SEARCH BY RESIDUE NAME
Search
Clear
FILTER BY RESIDUE TYPE
Select the residue types
Polar Positive
Polar Negative
Polar Neutral
Non-Polar Aliphatic
Non-Polar Rings
Cysteine
CHANGE COLOR PATTERN
CINEMA
CLUSTAL
LESK
3DMOL


As per my other post, I am looking to install a monitoring system on an air source heat pump.
One of the key parts of working out the COP on a heat pump is how much heat the system is producing, and this is normally done using a heat meter (which is essentially an integrated flow meter and two temperature sensors).
I am going to try to do this with a cheap clamp on ultrasonic flow meter from China, connected to two PT100 sensors. When I say cheap, this is probably still going to be in the region of £150.
Has anyone else had any experience of heat metering in domestic heating systems? I would like to have a non-invasive system - draining down a system to fit a flow meter and pockets is expensive and time consuming.
The cheapest easily available heat meter appears to be the ELF ones:
http://www.bellflowsystems.co.uk/heat-meters-15-20mm-compact-mounted-rhi/
And there are ultrasonic meters available as part of the RHI scheme, but they aren't clamp on so require draining down.
I remember seeing a project where the flow meter was disposed of, and just temperature sensors were used. Some kind of inference is made from the temperature to work out the flow, but I can't find it now.
Re: Heat metering in domestic heating systems
A flow meter using just temperature sensors:
http://circuitcellar.com/editorsblog/microcontroller-based-heating-monitor/
Re: Heat metering in domestic heating systems
That is a nice idea! it would be interesting to try that.
Re: Heat metering in domestic heating systems
lurking on openenergy again i wonder if reading data from meters that require 2 way coms could be included under the subject?
my meter requires a kind of request before it will deliver data on the ir interface....
i have tried to build an interface but failed.... first of all i simply did not get enough difference between 5V and 0V to be able to read of data if any came out at all
please give an idea if there is much interest in getting kamstrup meters included... i even have the full protocol sheet but no expert in reading those...
the ir interface should be pretty simple.... http://kildal.dk/wordpress/wp-content/uploads/2010/10/kamstrup-ir.png
one guy have done this on arduino but did not know the specs on the ir diodes as he had just taken them out of old ir remotes...
upps.. his site is updated... so now i know excatly what to get: http://www.seeedstudio.com/wiki/index.php?title=Photo_Reflective_Sensor
and a sketch.... http://kildal.dk/?page_id=432
let me know if there is any interest.... if not if any could help me adjust the sketch to work on openenegy's platform
Re: Heat metering in domestic heating systems
not sure if my last post is waiting for a mod to see it...
but would inclusion of heat meters that use 2way ir coms be of interest? mostly i think of my own, a kamstrup multical 601... i have the full potocol sheets but dont understand any of it...
thou i will try and put an arduino to get readings from it either tomorrow or during weekend


Concur Expense Bot
Conversational UX
Summary
The Concur Expense bot (beta) is a simplified version of the Concur app, that allows users to submit expenses and create expense reports.
I worked on the
- Voice & tone
- Conversational UX and script
- Onboarding for new users
- Integration with Concur Bot and Microsoft teams
Users
Users can upload their receipts to the bot to create expenses, submit expense reports and see what their upcoming trips are.
Managers
Managers can approve (or reject) expense reports, view upcoming trips, and manage their own expenses.
The bot is now in beta on
Slack, and is in the process of being built for Microsoft Teams.


|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object javax.swing.text.AbstractDocument
public abstract class AbstractDocument
An implementation of the document interface to serve as a basis for implementing various kinds of documents. At this level there is very little policy, so there is a corresponding increase in difficulty of use.
This class implements a locking mechanism for the document. It
allows multiple readers or one writer, and writers must wait until
all observers of the document have been notified of a previous
change before beginning another mutation to the document. The
read lock is acquired and released using the render
method. A write lock is aquired by the methods that mutate the
document, and are held for the duration of the method call.
Notification is done on the thread that produced the mutation,
and the thread has full read access to the document for the
duration of the notification, but other readers are kept out
until the notification has finished. The notification is a
beans event notification which does not allow any further
mutations until all listeners have been notified.
Any models subclassed from this class and used in conjunction
with a text component that has a look and feel implementation
that is derived from BasicTextUI may be safely updated
asynchronously, because all access to the View hierarchy
is serialized by BasicTextUI if the document is of type
AbstractDocument
. The locking assumes that an
independant thread will access the View hierarchy only from
the DocumentListener methods, and that there will be only
one event thread active at a time.
If concurrency support is desired, there are the following
additional implications. The code path for any DocumentListener
implementation and any UndoListener implementation must be threadsafe,
and not access the component lock if trying to be safe from deadlocks.
The repaint
and revalidate
methods
on JComponent are safe.
AbstractDocument models an implied break at the end of the document.
Among other things this allows you to position the caret after the last
character. As a result of this, getLength
returns one less
than the length of the Content. If you create your own Content, be
sure and initialize it to have an additional character. Refer to
StringContent and GapContent for examples of this. Another implication
of this is that Elements that model the implied end character will have
an endOffset == (getLength() + 1). For example, in DefaultStyledDocument
getParagraphElement(getLength()).getEndOffset() == getLength() + 1
.
Warning:
Serialized objects of this class will not be compatible with
future Swing releases. The current serialization support is
appropriate for short term storage or RMI between applications running
the same version of Swing. As of 1.4, support for long term storage
of all JavaBeansTM
has been added to the java.beans
package.
Please see XMLEncoder
.
| Nested Class Summary | |
|---|---|
class |
AbstractDocument.AbstractElement
Implements the abstract part of an element. |
static interface |
AbstractDocument.AttributeContext
An interface that can be used to allow MutableAttributeSet implementations to use pluggable attribute compression techniques. |
class |
AbstractDocument.BranchElement
Implements a composite element that contains other elements. |
static interface |
AbstractDocument.Content
Interface to describe a sequence of character content that can be edited. |
class |
AbstractDocument.DefaultDocumentEvent
Stores document changes as the document is being modified. |
static class |
AbstractDocument.ElementEdit
An implementation of ElementChange that can be added to the document event. |
class |
AbstractDocument.LeafElement
Implements an element that directly represents content of some kind. |
| Field Summary | |
|---|---|
protected static String |
BAD_LOCATION
Error message to indicate a bad location. |
static String |
BidiElementName
Name of elements used to hold a unidirectional run |
static String |
ContentElementName
Name of elements used to represent content |
static String |
ElementNameAttribute
Name of the attribute used to specify element names. |
protected EventListenerList |
listenerList
The event listener list for the document. |
static String |
ParagraphElementName
Name of elements used to represent paragraphs |
static String |
SectionElementName
Name of elements used to hold sections (lines/paragraphs). |
| Fields inherited from interface javax.swing.text.Document |
|---|
StreamDescriptionProperty, TitleProperty |
| Constructor Summary | |
|---|---|
protected |
AbstractDocument(AbstractDocument.Content data)
Constructs a new AbstractDocument , wrapped around some
specified content storage mechanism. |
protected |
AbstractDocument(AbstractDocument.Content data,
AbstractDocument.AttributeContext context)
Constructs a new AbstractDocument , wrapped around some
specified content storage mechanism. |
| Method Summary | ||
|---|---|---|
void |
addDocumentListener(DocumentListener listener)
Adds a document listener for notification of any changes. |
|
void |
addUndoableEditListener(UndoableEditListener listener)
Adds an undo listener for notification of any changes. |
|
protected Element |
createBranchElement(Element parent,
AttributeSet a)
Creates a document branch element, that can contain other elements. |
|
protected Element |
createLeafElement(Element parent,
AttributeSet a,
int p0,
int p1)
Creates a document leaf element. |
|
Position |
createPosition(int offs)
Returns a position that will track change as the document is altered. |
|
void |
dump(PrintStream out)
Gives a diagnostic dump. |
|
protected void |
fireChangedUpdate(DocumentEvent e)
Notifies all listeners that have registered interest for notification on this event type. |
|
protected void |
fireInsertUpdate(DocumentEvent e)
Notifies all listeners that have registered interest for notification on this event type. |
|
protected void |
fireRemoveUpdate(DocumentEvent e)
Notifies all listeners that have registered interest for notification on this event type. |
|
protected void |
fireUndoableEditUpdate(UndoableEditEvent e)
Notifies all listeners that have registered interest for notification on this event type. |
|
int |
getAsynchronousLoadPriority()
Gets the asynchronous loading priority. |
|
protected AbstractDocument.AttributeContext |
getAttributeContext()
Fetches the context for managing attributes. |
|
Element |
getBidiRootElement()
Returns the root element of the bidirectional structure for this document. |
|
protected AbstractDocument.Content |
getContent()
Gets the content for the document. |
|
protected Thread |
getCurrentWriter()
Fetches the current writing thread if there is one. |
|
abstract Element |
getDefaultRootElement()
Returns the root element that views should be based upon unless some other mechanism for assigning views to element structures is provided. |
|
DocumentFilter |
getDocumentFilter()
Returns the DocumentFilter that is responsible for
filtering of insertion/removal. |
|
DocumentListener[] |
getDocumentListeners()
Returns an array of all the document listeners registered on this document. |
|
Dictionary<Object,Object> |
getDocumentProperties()
Supports managing a set of properties. |
|
Position |
getEndPosition()
Returns a position that represents the end of the document. |
|
int |
getLength()
Returns the length of the data. |
|
|
getListeners(Class<T> listenerType)
Returns an array of all the objects currently registered as FooListener s
upon this document. |
|
abstract Element |
getParagraphElement(int pos)
Get the paragraph element containing the given position. |
|
Object |
getProperty(Object key)
A convenience method for looking up a property value. |
|
Element[] |
getRootElements()
Gets all root elements defined. |
|
Position |
getStartPosition()
Returns a position that represents the start of the document. |
|
String |
getText(int offset,
int length)
Gets a sequence of text from the document. |
|
void |
getText(int offset,
int length,
Segment txt)
Fetches the text contained within the given portion of the document. |
|
UndoableEditListener[] |
getUndoableEditListeners()
Returns an array of all the undoable edit listeners registered on this document. |
|
void |
insertString(int offs,
String str,
AttributeSet a)
Inserts some content into the document. |
|
protected void |
insertUpdate(AbstractDocument.DefaultDocumentEvent chng,
AttributeSet attr)
Updates document structure as a result of text insertion. |
|
protected void |
postRemoveUpdate(AbstractDocument.DefaultDocumentEvent chng)
Updates any document structure as a result of text removal. |
|
void |
putProperty(Object key,
Object value)
A convenience method for storing up a property value. |
|
void |
readLock()
Acquires a lock to begin reading some state from the document. |
|
void |
readUnlock()
Does a read unlock. |
|
void |
remove(int offs,
int len)
Removes some content from the document. |
|
void |
removeDocumentListener(DocumentListener listener)
Removes a document listener. |
|
void |
removeUndoableEditListener(UndoableEditListener listener)
Removes an undo listener. |
|
protected void |
removeUpdate(AbstractDocument.DefaultDocumentEvent chng)
Updates any document structure as a result of text removal. |
|
void |
render(Runnable r)
This allows the model to be safely rendered in the presence of currency, if the model supports being updated asynchronously. |
|
void |
replace(int offset,
int length,
String text,
AttributeSet attrs)
Deletes the region of text from offset to
offset + length , and replaces it with text . |
|
void |
setAsynchronousLoadPriority(int p)
Sets the asynchronous loading priority. |
|
void |
setDocumentFilter(DocumentFilter filter)
Sets the DocumentFilter . |
|
void |
setDocumentProperties(Dictionary<Object,Object> x)
Replaces the document properties dictionary for this document. |
|
protected void |
writeLock()
Acquires a lock to begin mutating the document this lock protects. |
|
protected void |
writeUnlock()
Releases a write lock previously obtained via writeLock . |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
protected EventListenerList listenerList
protected static final String BAD_LOCATION
public static final String ParagraphElementName
public static final String ContentElementName
public static final String SectionElementName
public static final String BidiElementName
public static final String ElementNameAttribute
| Constructor Detail |
|---|
protected AbstractDocument(AbstractDocument.Content data)
AbstractDocument
, wrapped around some
specified content storage mechanism.
data
- the contentprotected AbstractDocument(AbstractDocument.Content data, AbstractDocument.AttributeContext context)
AbstractDocument
, wrapped around some
specified content storage mechanism.
data
- the contentcontext
- the attribute context| Method Detail |
|---|
public Dictionary<Object,Object> getDocumentProperties()
documentProperties
dictionary
to annotate the document with document-wide properties.
null
Dictionary
setDocumentProperties(java.util.Dictionary)
public void setDocumentProperties(Dictionary<Object,Object> x)
x
- the new dictionarygetDocumentProperties()
protected void fireInsertUpdate(DocumentEvent e)
e
- the eventEventListenerList
protected void fireChangedUpdate(DocumentEvent e)
e
- the eventEventListenerList
protected void fireRemoveUpdate(DocumentEvent e)
e
- the eventEventListenerList
protected void fireUndoableEditUpdate(UndoableEditEvent e)
e
- the eventEventListenerList
public <T extends EventListener> T[] getListeners(Class<T> listenerType)
FooListener
s
upon this document.
FooListener
s are registered using the
addFooListener
method.
You can specify the listenerType
argument
with a class literal, such as
FooListener.class
.
For example, you can query a
document d
for its document listeners with the following code:
DocumentListener[] mls = (DocumentListener[])(d.getListeners(DocumentListener.class));If no such listeners exist, this method returns an empty array.
listenerType
- the type of listeners requested; this parameter
should specify an interface that descends from
java.util.EventListener
FooListener
s on this component,
or an empty array if no such
listeners have been added
ClassCastException
- if listenerType
doesn't specify a class or interface that implements
java.util.EventListener
getDocumentListeners()
,
getUndoableEditListeners()
public int getAsynchronousLoadPriority()
-1
if the document should not be loaded asynchronouslypublic void setAsynchronousLoadPriority(int p)
p
- the new asynchronous loading priority; a value
less than zero indicates that the document should not be
loaded asynchronouslypublic void setDocumentFilter(DocumentFilter filter)
DocumentFilter
. The DocumentFilter
is passed insert
and remove
to conditionally
allow inserting/deleting of the text. A null
value
indicates that no filtering will occur.
filter
- the DocumentFilter
used to constrain textgetDocumentFilter()
public DocumentFilter getDocumentFilter()
DocumentFilter
that is responsible for
filtering of insertion/removal. A null
return value
implies no filtering is to occur.
setDocumentFilter(javax.swing.text.DocumentFilter)
public void render(Runnable r)
This is implemented to aquire a read lock for the duration of the runnables execution. There may be multiple runnables executing at the same time, and all writers will be blocked while there are active rendering runnables. If the runnable throws an exception, its lock will be safely released. There is no protection against a runnable that never exits, which will effectively leave the document locked for it's lifetime.
If the given runnable attempts to make any mutations in this implementation, a deadlock will occur. There is no tracking of individual rendering threads to enable detecting this situation, but a subclass could incur the overhead of tracking them and throwing an error.
This method is thread safe, although most Swing methods are not. Please see Threads and Swing for more information.
render
in interface Document
r
- the renderer to executepublic int getLength()
getLength
in interface Document
Document.getLength()
public void addDocumentListener(DocumentListener listener)
addDocumentListener
in interface Document
listener
- the DocumentListener
to addDocument.addDocumentListener(javax.swing.event.DocumentListener)
public void removeDocumentListener(DocumentListener listener)
removeDocumentListener
in interface Document
listener
- the DocumentListener
to removeDocument.removeDocumentListener(javax.swing.event.DocumentListener)
public DocumentListener[] getDocumentListeners()
DocumentListener
s
or an empty array if no document listeners are
currently registeredaddDocumentListener(javax.swing.event.DocumentListener)
,
removeDocumentListener(javax.swing.event.DocumentListener)
public void addUndoableEditListener(UndoableEditListener listener)
UndoableEdit
will cause the appropriate DocumentEvent to be fired to keep
the view(s) in sync with the model.
addUndoableEditListener
in interface Document
listener
- the UndoableEditListener
to addDocument.addUndoableEditListener(javax.swing.event.UndoableEditListener)
public void removeUndoableEditListener(UndoableEditListener listener)
removeUndoableEditListener
in interface Document
listener
- the UndoableEditListener
to removeDocument.removeDocumentListener(javax.swing.event.DocumentListener)
public UndoableEditListener[] getUndoableEditListeners()
UndoableEditListener
s
or an empty array if no undoable edit listeners are
currently registeredaddUndoableEditListener(javax.swing.event.UndoableEditListener)
,
removeUndoableEditListener(javax.swing.event.UndoableEditListener)
public final Object getProperty(Object key)
getDocumentProperties().get(key);
getProperty
in interface Document
key
- the non-null
property key
null
getDocumentProperties()
public final void putProperty(Object key, Object value)
getDocumentProperties().put(key, value);If
value
is null
this method will
remove the property.
putProperty
in interface Document
key
- the non-null
keyvalue
- the property valuegetDocumentProperties()
public void remove(int offs, int len) throws BadLocationException
This method is thread safe, although most Swing methods are not. Please see Threads and Swing for more information.
remove
in interface Document
offs
- the starting offset >= 0len
- the number of characters to remove >= 0
BadLocationException
- the given remove position is not a valid
position within the documentDocument.remove(int, int)
public void replace(int offset, int length, String text, AttributeSet attrs) throws BadLocationException
offset
to
offset + length
, and replaces it with text
.
It is up to the implementation as to how this is implemented, some
implementations may treat this as two distinct operations: a remove
followed by an insert, others may treat the replace as one atomic
operation.
offset
- index of child elementlength
- length of text to delete, may be 0 indicating don't
delete anythingtext
- text to insert, null
indicates no text to insertattrs
- AttributeSet indicating attributes of inserted text,
null
is legal, and typically treated as an empty attributeset,
but exact interpretation is left to the subclass
BadLocationException
- the given position is not a valid
position within the documentpublic void insertString(int offs, String str, AttributeSet a) throws BadLocationException
This method is thread safe, although most Swing methods are not. Please see Threads and Swing for more information.
insertString
in interface Document
offs
- the starting offset >= 0str
- the string to insert; does nothing with null/empty stringsa
- the attributes for the inserted content
BadLocationException
- the given insert position is not a valid
position within the documentDocument.insertString(int, java.lang.String, javax.swing.text.AttributeSet)
public String getText(int offset, int length) throws BadLocationException
getText
in interface Document
offset
- the starting offset >= 0length
- the number of characters to retrieve >= 0
BadLocationException
- the range given includes a position
that is not a valid position within the documentDocument.getText(int, int)
public void getText(int offset, int length, Segment txt) throws BadLocationException
If the partialReturn property on the txt parameter is false, the data returned in the Segment will be the entire length requested and may or may not be a copy depending upon how the data was stored. If the partialReturn property is true, only the amount of text that can be returned without creating a copy is returned. Using partial returns will give better performance for situations where large parts of the document are being scanned. The following is an example of using the partial return to access the entire document:
int nleft = doc.getDocumentLength(); Segment text = new Segment(); int offs = 0; text.setPartialReturn(true); while (nleft > 0) { doc.getText(offs, nleft, text); // do something with text nleft -= text.count; offs += text.count; }
getText
in interface Document
offset
- the starting offset >= 0length
- the number of characters to retrieve >= 0txt
- the Segment object to retrieve the text into
BadLocationException
- the range given includes a position
that is not a valid position within the documentpublic Position createPosition(int offs) throws BadLocationException
This method is thread safe, although most Swing methods are not. Please see Threads and Swing for more information.
createPosition
in interface Document
offs
- the position in the model >= 0
BadLocationException
- if the given position does not
represent a valid location in the associated documentDocument.createPosition(int)
public final Position getStartPosition()
getStartPosition
in interface Document
public final Position getEndPosition()
getEndPosition
in interface Document
public Element[] getRootElements()
getRootElements
in interface Document
public abstract Element getDefaultRootElement()
getDefaultRootElement
in interface Document
Document.getDefaultRootElement()
public Element getBidiRootElement()
public abstract Element getParagraphElement(int pos)
pos
- the starting offset >= 0
protected final AbstractDocument.AttributeContext getAttributeContext()
protected void insertUpdate(AbstractDocument.DefaultDocumentEvent chng, AttributeSet attr)
chng
- a description of the changeattr
- the attributes for the changeprotected void removeUpdate(AbstractDocument.DefaultDocumentEvent chng)
chng
- a description of the changeprotected void postRemoveUpdate(AbstractDocument.DefaultDocumentEvent chng)
chng
- a description of the changepublic void dump(PrintStream out)
out
- the output streamprotected final AbstractDocument.Content getContent()
protected Element createLeafElement(Element parent, AttributeSet a, int p0, int p1)
parent
- the parent elementa
- the attributes for the elementp0
- the beginning of the range >= 0p1
- the end of the range >= p0
protected Element createBranchElement(Element parent, AttributeSet a)
parent
- the parent elementa
- the attributes
protected final Thread getCurrentWriter()
null
if there are no modifications in progressprotected final void writeLock()
writeLock
,
as long as it doesn't attempt to gain additional writeLock
s
from within document notification. Attempting to gain a
writeLock
from within a DocumentListener notification will
result in an IllegalStateException
. The ability
to obtain more than one writeLock
per thread allows
subclasses to gain a writeLock, perform a number of operations, then
release the lock.
Calls to writeLock
must be balanced with calls to writeUnlock
, else the
Document
will be left in a locked state so that no
reading or writing can be done.
IllegalStateException
- thrown on illegal lock
attempt. If the document is implemented properly, this can
only happen if a document listener attempts to mutate the
document. This situation violates the bean event model
where order of delivery is not guaranteed and all listeners
should be notified before further mutations are allowed.protected final void writeUnlock()
writeLock
.
After decrementing the lock count if there are no oustanding locks
this will allow a new writer, or readers.
writeLock()
public final void readLock()
readUnlock
.
readUnlock()
public final void readUnlock()
readLock();
try {
// do something
} finally {
readUnlock();
}
readLock()
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Copyright © 2004, 2010 Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.


Baby Boy * * 1/2 (out of * * * * )
Directed by John Singleton. Cast: Tyrese Gibson, A.J. Johnson, Taraji P. Henson, Ving Rhames, Omar Gooding, Snoop Dogg, Tamara LaSeon Bass. 2001 - 128 minutes Rated R (for sex, nudity, violence, and profanity). Reviewed by Dustin Putman, June 27, 2001.
In a film that is far closer to his roots in filmmaking than 2000's big-budget remake of "Shaft," John Singleton's "Baby Boy" is a low-key, often astute, drama. Described as a companion piece to his masterful debut film, 1991's "Boyz N the Hood," the picture is considerably less violent and bleak, but is still set in a world (to be exact, a troubled, crime-ridden Southern California neighborhood) in which its residents can never be too sure if their lives are going to work out as planned, or even if they're going to survive to see tomorrow.
A film about growing up and taking responsibility for your actions and relationships, R&B singer Tyrese Gibson stars as Jody, a 20-year-old "boy" who has fathered two children from two separate women (one of which he is in love with), but remains at home living with his lonely 36-year-old mother, Juanita (A.J. Johnson). Juanita loves Jody, but feels that he should "leave the nest" and accept becoming an independent man, just as she wants to move on with her own life. Meanwhile, Jody's long-time, long-suffering girlfriend, Yvette (Taraji P. Henson), is beginning to feel like she isn't being appreciated in the relationship as she should be, and suspects that he has been sleeping around. Sure, they love one another, but is love really enough when your significant other almost outwardly cheats behind your back?
John Singleton, whose career has been quite varied ("Boyz N the Hood" and 1995's "Higher Learning" were powerful statements on society, while 1993's "Poetic Justice" and 1997's "Rosewood" were ambitious blunders), has made a serious-minded, ardent motion picture with "Baby Boy," although it fails to succeed in quite the same way that his greatest achievements have. For one, Singleton, who also penned the screenplay, too often goes for over-exaggeration when dealing with his characters' mannerisms, and the path that the movie follows is an admittedly cliched one. While it may be truthful up to a point, the actors are instructed to yell their lines in certain scenes, rather than just speak them in a normal tone, as if to be black you have to have a nasty temper and be sassy. While this aspect of the characters' interaction is unnecessary, it thankfully does not takes up the majority of the running time.
For much of the 128-minute running time, "Baby Boy" is an involving romantic drama that treats its participants with respect and understanding, never fully condemning them for their mistakes. Jody, played maturely by Tyrese Gibson in his first film role, is a likable, sympathetic young man, even when he makes mistakes and isn't always faithful to Yvette. In one of the movie's most powerful moments, following Yvette's discovery that he has been with many different women, Jody earnestly explains that he hasn't been honest with her because he actually does love her and didn't want to hurt her feelings. The same goes for Jody's mother, Juanita, who begins to see, and subsequently falls in love with, a man named Melvin (Ving Rhames), who is a reformed gangster.  As for Ving Rhames (2000's "Mission: Impossible 2"), his sure-to-be-remembered frog-hopping sex scene has got to be seen to be believed.
Newcomer Taraji P. Henson has the most interesting and finely-tuned role, as Yvette, and runs away with the entire film. Henson is a lovely fresh face whose performance is both perceptive and touching, and Yvette is written with an intelligent delicacy that makes you instantly care about what happens to her. It's the trickiest role, too, as a young mother who is trying to make a good life for her and her son, and would love to include Jody in it if only he could show her some commitment.
The plot takes a wrong turn with the appearance of Yvette's criminal ex-boyfriend, Rodney (Snoop Dogg), who is released from jail and promptly takes over Yvette's apartment. Not sure how to get him out, and scared of his dangerous streak, the film culminates in a false-alarm drive-by shooting that later turns to real violence. While what takes place is captivating, and even effective in the issues it raises, the appearance of guns in the final act of an otherwise non-violent motion picture was a bit of a letdown. Snoop Dogg, who is fine with what he has been given, is equipped with a character who is portrayed as less of a person, and more of an obnoxious story device. Luckily, once he is out of the picture, the film concludes with several extremely well-written passages that wrap up the film in a hopeful, satisfying manner.
"Baby Boy" is not a great movie, and lacks the overall realism and intensity of "Boyz N the Hood," but it is a good one. The engaging performances, mixed with its keen observations on love and maturation, are worth seeing, even if, in order to get to them, you must walk down a road that has been covered many times before. It is clear that when he set out to make "Baby Boy," John Singleton's heart was in the right place.
- Copyright 2001 by Dustin Putman http://us.imdb.com/ReviewsBy?Dustin+Putman
* COMING SOON - The grand opening of my new movie review site, themovieboy.com! *
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews