XStream 1.5.x requires Java 1.7 or later. Note, that the XStream libraries contains class files targeting different Java runtime versions or Java features. These classes are loaded by reflection and only used if XStream is running on an appropriate runtime environment.
Environments that load all class files of a Java archive can fail with this approach, the Android runtime is such an example. You can build your own version of XStream with a lower JDK then.
For Java 9 and later you will currently have to permit the now illegal access for XStream to operate.
XStream 1.5.x can be build still with JDK 1.7 (see BUILD.txt). However, to support the latest features it requires currently a JDK of Java 8. Otherwise the resulting jar files will miss some classes not available on earlier runtimes. Depending on the target environment this can be useful (e.g. for Android or GAE).
Note, that such Java archives will fail on higher Java runtimes then.
All dependencies are optional, XStream uses since version 1.4.1 by default xpp3:xpp3_min and xmlpull:xmlpull. However it depends on the use case. XStream will run without dependencies using the DOM driver on all Java runtimes or the StAX driver in combination with Java 6 or greater. See the list of optional dependencies.
Note, that XStream's manifest contains OSGi entries that declare all dependencies as optional.
XStream has two modes of operation: Pure Java and Enhanced. In pure Java mode, XStream behaves in the same way across different JVMs, however its features are limited to what reflection allows, meaning it cannot serialize certain classes or fields. In enhanced mode, XStream does not have these limitations, however this mode of operation is not available to all JVMs.
XStream checks since version 1.4.5 automatically for a working enhanced mode - based on undocumented internal Java runtime classes. This enhanced mode is known to be working on the Oracle/Sun, Apple, HP, IBM and Blackdown 1.4 JVMs and onwards, for IcedTea 6 and onwards, for Hitachi, SAP and Diablo from 1.5 and onwards, for BEA JRockit starting with R25.1.0. Generally it works for all modern Java runtimes based on OpenJDK. Android basically supports the enhanced mode as well as the Google Application Engine, but the latter's security model limits the types that can be handled. Note, that an active SecurityManager might prevent the usage of the enhanced mode also.
Since Java 9 it is required to permit the now illegal access. For Java 17 see below.
Currently it is not possible to recreate every instance of a type using the official Java API only. The enhanced mode uses some undocumented, but wide-spread available functionality to recreate such instances nevertheless. However, in a secured secured environment, older Java run times or a limited Java environment might prevent the usage of the enhanced mode and XStream uses the plain Java API as fallback. This mode has some restrictions though:
| Feature | Pure Java | Enhanced Mode |
|---|---|---|
| Public classes | Yes | Yes |
| Non public classes | No | Yes |
| Static inner classes | Yes | Yes |
| Non-static inner classes | No | Yes |
| Anonymous inner classes | No | Yes |
| With default constructor | Yes | Yes |
| Without default constructor | No | Yes |
| Private fields | Yes | Yes |
| Final fields | Yes >= JDK 1.5 | Yes |
Yes, this is normal. A big part of XStream is reflection based and there is currently no replacement for the complete required functionality. You will have to permit this access currently, otherwise XStream will not work.
Again, this is normal. The reflection stuff is required to get all required information to recreate an instance of a Java type at unmarshalling time. However, since Java 17 it is no longer possible to allow this access with a single runtime option. You have to open all packages of the individual modules for the unnamed module with the option --add-opens, where XStream requires access, e.g. --add-opens java.base/java.util=ALL-UNNAMED
Such a declaration would move XStream automatically into the module class path. However, in this environment a lot of functionality does no longer work. Therefore it is on purpose that XStream stays currently in the unnamed module.
At some point definitely. However, you will have to accept a limited functionality only, comparable to the pure Java mode. The access model is very restrictive and XStream will no longer be able to marshal all types of the Java runtime like now.
The XML Pull Parser API defines an own mechanism to load the factory for the available XPP implementation. XStream's XppDriver never used this lookup mechanism automatically before version 1.4, now it will. Therefore you will have to add a dependency to xmlpull if the XPP implementation does not deliver the classes on its own. This dependency is necessary for Xpp3 in contrast to kXML2 that contains the classes. Use the Xpp3Driver or the KXml2Driver if you want to select one of the directly supported XPP implementation on your own without using the XPP factory. Note, that the minimal version of kXML2 does not support the XPP factory, but can be used by the KXml2Driver.
XStream does work in Android 1.0, but is reported to have limited capabilities. Since XStream 1.4 Android is treated at least as JDK 5 platform, but it e.g. does not include the java.beans package. Therefore you cannot use the JavaBeanConverter. Note, that Android provides an XML Pull Parser, therefore XStream can work without additional dependencies.
XStream contains class files targeting different Java runtime versions. Depending on the target version of Android, it is not possible to use the original XStream library directly, because it tries to convert all classes of XStream to the Dalvik runtime. You might have to build a custom version of XStream (see BUILD.txt) with a JDK that is equivalent to the Java level supported by the target version of Android.
Since XStream 1.4.10 an additional artifact is deployed to the Central Maven Repository with -java7 appended to the version that explicitly does not contain any Java 8 related stuff. Note that this version will fail on higher runtimes.
Starting with XStream 1.4.6 it is possible to instantiate an XStream instance in a GAE environment. Nevertheless does GAE set some severe restrictions for XStream and therefore XStream will behave differently. Actually a reflection-based converter cannot handle any type from the JDK itself. Nor is it possible to create an ObjectInputStream or an ObjectOutputStream. It is not possible to define a field alias for any type within the JDK. XStream will typically work as general rule, if you process your own objects.
Yes. Let us know which JVM you would like supported.
Running XStream in a secured environment can prevent XStream from running in enhanced mode. This is especially true when running XStream in an applet. You may also try to use the JavaBeanConverter as alternative to the ReflectionConverter running in enhanced or pure Java mode.
This depends on the mode XStream is running in. Refer to the SecurityManagerTest for details. Actually XStream's converters try to check since version 1.4.6 any critical operation, before they claim to be able to handle a type. As consequence XStream can behave differently running under a SecurityManager. E.g. if the SecurityManager does not permit to create an instance for a derived class of ObjectOutputStream, the SerializationConverter will not handle any type and the ReflectionConverter will take over (as long it has proper rights for its own reflection-based operations).
The architecture in XStream has slightly changed. Starting with XStream 1.2 the HierarchicalStreamDriver implementation is responsible to ensure that XML tags and attributes are valid names in XML, in XStream 1.1.x this responsibility was part of the ClassMapper implementations. Under some rare circumstances this will result in an unreadable XML due to the different processing order in the workflow of such problematic tag names.
You can run XStream in 1.1 compatibility mode though:
XStream xstream = new XStream(new XppDriver(new XStream11XmlFriendlyReplacer())) { protected boolean useXStream11XmlFriendlyMapper() { return true; } };
XStream has a long history to support types from recent JDKs without dropping backward compatibility. Therefore it contains class files targeting different JDKs. However, WebShpere scans by default all JAR files in its classpath for annotations to support CDI independent of the presence of a beans.xml file in META-INF. This scanning fails for class files targeting a higher JDK runtime as currently used by WebSphere. Please, consult your WebSphere documentation, how to turn off the scanning for individual files by providing an amm.filter.proeprties file.
In contrast to the JDK XStream is not tied to a marker interface to serialize a class. XStream ships with some specialized converters, but will use reflection by default for "unknown" classes to examine, read and write the class' data. Therefore XStream can handle quite any class, especially the ones referred as POJO (Plain Old Java Object).
However, some types of classes exist with typical characteristics, that cannot be handled - at least not out of the box:
Make it transient
, specify it with XStream.omitField()
or
annotate it with @XStreamOmitField
XStream uses the same mechanism as the JDK serialization. Example:
class ThreadAwareComponent { private transient ThreadLocal component; // ... private Object readResolve() { component = new ThreadLocal(); return this; } }
or in case your type implements java.io.Serializable, you have an alternative:
class ThreadAwareComponent implements Serializable{ private transient ThreadLocal component; // ... private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); component = new ThreadLocal(); } }
Use the latter in class hierarchies, readResolve is not called for base classes.
This is, in fact, the same case as above. XStream uses the same mechanism as the JDK serialization. When using the enhanced mode with the optimized reflection API, it does not invoke the default constructor. The solution is to implement the readResolve or readObject as demonstrated with the last question.
See example for the CollectionConverter.
Note, that it is possible to configure XStream to omit the container element toys using implicit collections.
XStream normally has no to separate between a primitive and its boxed type. The complete reflection API works always with the boxed types and converts to primitives types on the fly. However, for method and field type signatures the difference is essential. Nevertheless it is possible to register derived versions of the converters that are able to respect the aliasing with some minor effort. Following lines are taken from the AliasTest in the acceptance tests:
XStream xstream = new XStream(); Mapper mapper = new MapperWrapper(xstream.getMapper().lookupMapperOfType(ArrayMapper.class)) { public Class realClass(String elementName) { Class primitiveType = Primitives.primitiveType(elementName); return primitiveType != null ? primitiveType : super.realClass(elementName); } }; SingleValueConverter javaClassConverter = new JavaClassConverter(mapper) {}; xstream.registerConverter(javaClassConverter); xstream.registerConverter(new JavaMethodConverter(javaClassConverter){}); xstream.registerConverter(new JavaFieldConverter(javaClassConverter, mapper){});
By declaring a collection as implicit, the result will have no direct representation of the collection container itself anymore. Therefore, if the collection was empty at serialization time, the serialized result does not contain a trace of the collection anymore. At deserialization time it will therefore not know anything about the collection and will not initialize it. XStream cannot decide anyway at deserialization time, if the collection was empty or null.
By declaring a collection as implicit, the result will have no direct representation of the collection container itself anymore. Therefore XStream cannot track the original type of the collection. At deserialization time it will therefore look at the declaration type of the field that holds the collection and use this type's default implementation, e.g. for a List this is by default an ArrayList.
Beware, that this also means that collections with additional information (e.g. a TreeSet with a Comparator) cannot be restored, since the comparator was already omitted at serialization time.
No (except for lambda expressions), but XStream respects the Java serialization methods even for types not declared as Serializable.
Yes.
Adding a type as immutable implies that a referencing marshaller strategy will write each occurrence of the same instance separately into the stream without referencing it, i.e. instance of those types are normally never referenced at deserialization time. Such referenced can exist though for persisted streams when a type is added as immutable in later versions. In such cases the type can be added as immutable, but still referenceable.
Any immutable type could be dereferenced before version 1.4.9, but only at the cost of a large memory footprint. Since version 1.4.9 this is only possible if the immutable type has been explicitly declared as referenceable too. This should be done only if backward compatibility is required and a persisted stream may contain a reference of such an instance at all. Any type that has been declared as immutable by XStream itself before version 1.5 will not be referenceable now by default (all primitive types and their boxed counterparts, java.lang.Class, java.lang.String, java.math.BigInteger, java.math.BigDecimal, java.io.File, java.net.URL, java.awt.font.TextAttribute, java.util.Currency, java.util.UUID, java.net.URI, java.nio.charset.Charset and the empty collection types). You can always overwrite the default by adding the same type again as immutable with a different value for the referenceable flag.
Non-serializable lambda expressions to not contain any information at all to recreate the instance at a later time again. These instances are treated as temporary objects and as such XStream has no other possibility as to serialize null instead.
Serializable lambda expressions contain information that is specific for compiler and vendor. Even worse, the compiler is free to add information related to the location of the lambda expression in the source i.e. you may not be able to deserialize a lambda expression after source code changes. XStream has no control over this information and how it is used by native functionality in the JDK. Therefore Oracle strongly discourages the usage of serializable lambda expressions in the JDK documentation.
Only limitedly. A proxy generated with the CGLIB Enhancer is supported, if the proxy uses either a factory or only one callback. Then it is possible to recreate the proxy instance at unmarshalling time. Starting with XStream 1.3.1 CGLIB support is no longer automatically installed because of possible classloader problems and side-effects, because of incompatible ASM versions. You can enable CGLIB support with:
XStream xstream = new XStream() { protected MapperWrapper wrapMapper(MapperWrapper next) { return new CGLIBMapper(next); } }; xstream.registerConverter(new CGLIBEnhancedConverter(xstream.getMapper(), xstream.getReflectionProvider()));
This is not a problem of XStream. You have incompatible ASM versions in your classpath. CGLIB 2.1.x and below is based on ASM 1.5.x which is incompatible to newer versions that are used by common packages like Hibernate, Groovy or Guice. Check your dependencies and ensure that you are using either using cglib-nodep-2.x.jar instead of cglib-2.x.jar or update to cglib-2.2.x that depends on ASM 3.1. However, the nodep version contains a copy of the ASM classes with private packages and will therefore not raise class incompatibilities at all.
XStream uses this method to detect a CGLIB-enhanced proxy. Unfortunately the method is not available in the cglib-2.0 version. Since this version is many years old and the method is available starting with cglib-2.0.1, please consider an upgrade of the dependency, it works usually smoothly.
Support of Hibernate enhanced collections and proxied types. To drop the internals of Hibernate when marshalling such objects to XStream, all converters and the mapper has to be registered for the XStream instance:
final XStream xstream = new XStream() { protected MapperWrapper wrapMapper(final MapperWrapper next) { return new HibernateMapper(next); } }; xstream.registerConverter(new HibernateProxyConverter()); xstream.registerConverter(new HibernatePersistentCollectionConverter(xstream.getMapper())); xstream.registerConverter(new HibernatePersistentMapConverter(xstream.getMapper())); xstream.registerConverter(new HibernatePersistentSortedMapConverter(xstream.getMapper())); xstream.registerConverter(new HibernatePersistentSortedSetConverter(xstream.getMapper()));
Yes. Hibernate Envers is an optional dependency for XStream and it is automatically supported by XStream's Hibernate package when the proxy collection types of Envers are available on the classpath.
XStream's generic converters and the marshalling strategies use a number of attributes on their own. Especially the attributes named id, class and reference are likely to cause such collisions. Main reason is XStream's history, because originally user defined attributes were not supported and all attribute were system generated. Starting with XStream 1.3.1 you can redefine those attributes to allow the names to be used for your own ones. The following snippet defines XStream to use different system attributes for id and class while the field id of YourClass is written into the attribute class:
XStream xstream = new XStream() { xstream.useAttributeFor(YourClass.class, "id"); xstream.aliasAttribute("class", "id"); xstream.aliasSystemAttribute("type", "class"); xstream.aliasSystemAttribute("refid", "id");
Yes. XStream's ReflectionConverter uses the defined field order by default. You can override it by using an specific FieldKeySorter:
SortableFieldKeySorter sorter = new SortableFieldKeySorter(); sorter.registerFieldOrder(MyType.class, new String[] { "firstToSerialize", "secondToSerialize", "thirdToSerialize" }); xstream = new XStream(new Sun14ReflectionProvider(new FieldDictionary(sorter)));
For more advanced class migrations, you may
Future versions of XStream will include features to make these type of migrations easier.
Serializing an object graph is never a problem, even if the classes of those objects have been loaded by a different class loader. The situation changes completely at deserialization time. In this case you must set the class loader to use with:
xstream.setClassLoader(yourClassLoader);
Although XStream caches a lot of type related information to gain speed, it keeps those information in tables with weak references that should be cleaned by the garbage collector when the class loader is freed.
Note, that this call should be made quite immediately after creating the XStream and before any other configuration is done. Otherwise configuration based on special types might refer classes loaded with the wrong classloader.
XStream architecture is based on IO Readers and Writers, while the XML declaration is the responsibility of XML parsers. All HierarchicalStreamDriver implementations respect the encoding since version 1.3, but only if you provide an InputStream. If XStream consumes a Reader you have to initialize the reader with the appropriate encoding yourself, since it is now the reader's task to perform the encoding and no XML parser can change the encoding of a Reader and any encoding definition in the XML header will be ignored.
XStream is designed to write XML snippets, so you can embed its output into an existing stream or string. You can write the XML declaration yourself into the Writer before using it to call XStream.toXML(writer).
XStream does no character encoding by itself, it relies on the configuration of the underlying XML writer. By default it uses its own PrettyPrintWriter which writes into the default encoding of the current locale. To write UTF-8 you have to provide a Writer with the appropriate encoding yourself.
XStream maps Java class names and field names to XML tags or attributes. Unfortunately this mapping cannot be 1:1, since some characters used for identifiers in Java are invalid in XML names. Therefore XStream uses an XmlFriendlyNameCoder to replace these characters with a replacement. By default this NameCoder uses an underscore as escape character and has therefore to escape the underscore itself also. You may provide a different configured instance of the XmlFriendlyNameCoder or a complete different implementation like the NoNameCoder to prevent name coding at all. However it is your responsibility then to ensure, that the resulting names are valid for XML.
By default XStream is written for persistence i.e. it will read the XML it can write. If you have to transform a given XML into an object graph, you should go the other way round. Use XStream to transfer your objects into XML. If the written XML matches your schema, XStream is also able to read it. This way is much easier, since you can spot the differences in the XML much more easy than to interpret the exceptions XStream will throw if it cannot match the XML into your objects.
This is part of the XML specification and a required functionality for any XML parser called attribute value normalization. It cannot be influenced by XStream. A compliant XML parser will replace by default real tab, carriage return and line feed characters with normal spaces. If you want to keep these characters you will have to encode them with entities or use child elements instead of attributes.
Your parser is basically right! A character of value 0 is not valid as part of XML according the XML specification (see version 1.0 or 1.1), neither directly nor as character entity nor within CDATA. But not every parser respects this part of the specification (e.g. Xpp3 will ignore it and read character entities). If you expect such characters in your strings and you do not use the Xpp3 parser, you should consider to use a converter that writes the string as byte array in Base64 code. As alternative you may force the PrettyPrintWriter or derived writers to be XML 1.0 or 1.1. compliant, i.e. in this mode a StreamException is thrown.
 Control characters are only valid as part of XML 1.1. You should add an XML header declaring this version or use a parser that does not care about this part of the specification (e.g. Xpp3 parser).
As already seen in the answers above for the null and control characters, the different parsers respect the XML specification not always in every detail. The specification differs for XML 1.0 and 1.1 for the allowed characters in XML values, as the specification differs between XML 1.0 (4th edition) and XML 1.0 (5th edition) for the characters allowed in XML names. In this case the latter is equal to the specification for XML 1.1.
| Behavior | Specification | Xpp3 | kXML2 | StAX Oracle JVM | Woodstox | Sun StAX | BEA StAX RI | DOM | DOM4J | JDOM | JDOM2 | XOM |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| XML 1.1 Declaration | n/a | - | yes | yes | yes | yes | - | yes | yes | yes | yes | - |
| Null Character | - | yes | yes | - | - | - | - | - | - | - | - | - |
| Non-Unicode Character 0xFFFF | - | yes | yes | - | CDATA | - | yes | - | - | - | - | - |
| Control Character | XML 1.1 | yes | yes | XML 1.1 | XML 1.1 | XML 1.1 | CDATA | XML 1.1 | XML 1.1 | - | - | XML 1.1 |
| Enhanced Unicode in XML Names | XML 1.0 5th, XML 1.1 | yes | yes | XML 1.1 | XML 1.1 | XML 1.1 | yes | XML 1.1 | XML 1.1 | - | - | - |
| Attribute normalization for white spaces | yes | yes | not for tabs | yes | yes | yes | yes | yes | yes | yes | yes | yes |
Legend: XML 1.1 requires a XML declaration with version 1.1. CDATA requires the value in a CDATA section.
Note, that parsers might change their behavior in different versions.
You can only write types as attributes that are represented as a single String value and are handled therefore by SingleValueConverter implementations. If your type is handled by a Converter implementation, the configuration of XStream to write an attribute (using XStream.useAttributeFor() or @XStreamAsAttribute) is simply ignored.
Not every XML parser supports namespaces and not every XML parser that supports namespaces can be configured within XStream to use those. Basically namespaces must be supported individually for the different XML parsers and the only support for namespaces that has currently been implemented in XStream is for the StAX parser. Therefore use and configure the StaxDriver of XStream to use namespaces.
XStream generates only XPath compliant expressions. These have a very limited syntax and they are the only ones that can be interpreted at deserialization again, since XStream does not use an XPath interpreter. Therefore there is no support for attribute selectors, qualified element access with axis names or functions. For real XPath support you will have to implement your own MarshallingStrategy.
Yes, this is right. However, the result type of an XPath expression evaluation can be defined. A node result from a node list is the lists first node, therefore the XPath of XStream is compliant. Since XStream does not use a real XPath engine, you do not have to worry about memory consumption or wasted evaluation time, XStream will always operate on a single node anyway. Since XStream 1.4 you can force XStream to write XPath expressions that select explicit the single node by using the new modes XStream.SINGLE_NODE_XPATH_ABSOLUTE_REFERENCES or SINGLE_NODE_XPATH_RELATIVE_REFERENCES. Instead of generating a path like "/doc/list/elem/field" XStream will then generate "/doc[1]/list[1]/elem[1]/field[1]". The two notations are transparent at deserialization time.
Entity support is completely dependent on the XML parser. XStream uses by default the Xpp3 parser that does not support entities at all (like the kXML2 parser). Other parsers support entities, but they might have been turned off to avoid XXE vulnerability. To enable the entities again, you have to overload the individual method of the HierarchicalStreamDriver implementation that generated the parser factory.
XStream supports the usage of an XSL style sheet as post-processor for its output with its TraxSource type. It will utilize an XStream instance as direct input to the transformer.
As always, first for historical reasons! Main difference is that the JettisonMappedXmlDriver is a thin wrapper around Jettison in combination with the StaxDriver, while the JsonHierarchicalStreamDriver uses an own more flexible implementation, but can only be used to generate JSON, deserialization is not implemented.
Users of Java 6 or higher can use Jettison 1.2. Jettison 1.3 or higher is currently not supported.
XStream's implementation to deserialize JSON is based on Jettison and StAX. Jettison implements a XMLStreamReader of StaX and transforms the processed JSON virtually into XML first. However, if the JSON string starts with an array it is not possible for Jettison to create a valid root element, since it has no name.
Deserialization of JSON is currently done by Jettison, that transforms the JSON string into a StAX stream. XStream itself does nothing know about the JSON format here. If your JSON string reaches some kind of complexity and you do not know how to design your Java objects and configure XStream to match those, you should have a look at the intermediate XML that is processed by XStream in the end. This might help to identify the problematic spots. Also consider then marshalling your Java objects into XML first. You can use following code to generate the XML:
String json = "{\"string\": \"foo\"}"; HierarchicalStreamDriver driver = new JettisonMappedXmlDriver(); StringReader reader = new StringReader(json); HierarchicalStreamReader hsr = driver.createReader(reader); StringWriter writer = new StringWriter(); new HierarchicalStreamCopier().copy(hsr, new PrettyPrintWriter(writer)); writer.close(); System.out.println(writer.toString());
JSON represents a very simple data model for easy data transfer. Especially it has no equivalent for XML attributes. Those are written with a leading "@" character, but this is not always possible without violating the syntax (e.g. for array types). Those may silently dropped (and makes it therefore difficult to implement deserialization). References are another issue in the serialized object graph, since JSON has no possibility to express such a construct. You should therefore always set the NO_REFERENCES mode of XStream. Additionally you cannot use implicit collections, since the properties in a JSON object must have unique names.
JavaScript does not know about integer values. All numbers are represented with double precition floats using 64 bits (IEEE 754). These types cannot represent technically the complete value range of 64-bit integers like Java's Long. With the JsonWriter you have the possibility since XStream 1.4.5 to set IEEE_754_MODE to force any long value that is not representable as JavaScript number to be written as string value in JSON. With the Jettison-based JettisonMappedXmlDriver you may either set a different TypeConverter or force the default converter to write integer values out of the range of 32-bit always as string setting the system property jettison.mapped.typeconverter.enforce_32bit_integer to true (not available for Jettison 1.0.1 and Java 1.4).
The JSON spec requires any JSON string to be in UTF-8 encoding. However, XStream ensures this only if you provide an InputStream or an OutputStream. If you provide a Reader or Writer you have to ensure this requirement on your own.
Well, no, the JSON is valid! Please check yourself with the JSON syntax checker. However, some JavaScript libraries silently assume that the JSON labels are valid JavaScript identifiers, because JavaScript supports a convenient way to address an element, if the label is a valid JavaScript identifier:
var json = {"label": "foo", "label-with-dash": "bar"}; var fooVar = json.label; // works for labels that are JavaScript identifiers var barVar = json["label-with-dash"]; // using an array index works always
As alternative you may wrap the JsonWriter and replace any dash with an underscore:
HierarchicalStreamDriver driver = new JsonHierarchicalStreamDriver() { public HierarchicalStreamWriter createWriter(Writer out) { return new WriterWrapper(super.createWriter(out)) { public void startNode(String name) { startNode(name, null); } public void startNode(String name, Class clazz) { wrapped.startNode(name.replace('-', '_'), clazz); } } } }; XStream xstream = new XStream(driver);
Since XStream version 1.4.7 it does no longer handle an EventHandler automatically. Such an instance can be used to initiate calls on arbitrary instances at deserialization time e.g. ProcessBuilder.start() You can register a ReflectionConverter instance explicitly for the EventHandler if you need support for such instances.
Yes, XStream is designed to convert any object form Java to XML and back out of the box. In consequence it is possible to adjust the processed XML manually to inject arbitrary objects into the deserialized object graph. To avoid such a behavior, you have several options:
That was the case for XStream 1.4.x if the security framework has not been initialized. XStream 1.5.x initializes automatically a white list for well-known types of the Java runtime.
XStream does not contain an own XML parser, therefore it depends on the parser selected with the HierarchicalStreamDriver if the current XStream instance is XXE vulnerable at deserialization time. However, XStream tries to deactivate the processing of external entities by default. Status for the different supported XML parsers:
| Driver | Vulnerable | Explanation |
|---|---|---|
| BEAStaxDriver | yes | Setting XMLInputFactory.setProperty(
XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false) is only respected for general entities, but not
for parameter entities. |
| Dom4JDriver | no | Driver turns off DOCTYPE processing to suppress handling of external entities with SAX reader in use. |
| DomDriver | no, Java 6 or higher yes, Java 5 | Driver turns off DOCTYPE processing with Java 7 runtime or higher to suppress handling of external entities with SAX reader in use. Suppress external entities only for Java 6 or lower, fails for parameterized entities. |
| JDomDriver | no | Driver turns off DOCTYPE processing to suppress handling of external entities with SAX reader in use. |
| JDom2Driver | no | Driver turns off DOCTYPE processing to suppress handling of external entities with SAX reader in use. |
| KXml2DomDriver | no | kXML2 parser does not support entities. |
| KXml2Driver | no | kXML2 parser does not support entities. |
| SjsxpDriver | no, Java 7 or higher yes, Java 6 | Driver turns off support for external entities for the internal StaX parser of the Sun JDK, but fails for parameter entities in a Java 6 runtime. |
| StandardStaxDriver | ? | Driver tries to turn off support for external entities for the internal StaX parser of the Java runtime. Save for Oracle JDK 7 or higher. |
| StaxDriver | ? | Driver tries to turns off support for external entities for the standard StaX parser. However, the finally used StAX implementation is defined externally (see JDK documentation) and a test should be made on the target platform to ensure that the parser respects the setting. |
| WstxDriver | no | Driver turns off support for external entities for the Woodstox StAX parser. |
| XomDriver | yes | XOM uses an internal list to test for available SAX parsers on the classpath and will explicitly enable external entities, even if the SAXBuilder instance is provided manually. |
Note: Only a HierarchicalStreamReader created with the HierarchicalStreamDriver is setup to avoid the XXE vulnerability. If you create such driver instances on your own, it is also your task to setup the XML parser instance properly.
XStream is designed for serializing objects using internal fields, whereas
XMLEncoder is designed for
serializing JavaBeans using public API methods (typically in the form
of getXXX()
, setXXX()
, addXXX()
and removeXXX()
methods.
JAXB is a Java binding tool. It generates Java code from a schema and you are able to transform from those classes into XML matching the processed schema and back. Note, that you cannot use your own objects, you have to use what is generated.
Yes. Once the XStream instance has been created and configured, it may be shared across multiple threads allowing objects to be serialized/deserialized concurrently (unless you enable the auto-detection to process annotations on-the-fly). Actually the creation and initialization of XStream is quite expensive, therefore it is recommended to keep the XStream instance itself. If you absolutely have to rely on annotation processing on the fly, you will have to use separate XStream instances for each thread - either by using every time a new instance or by a shared pool.
This cannot be answered in general, but following topics have impact on the memory:
XStream is a generalizing library, it inspects and handles your types on the fly. Therefore it will normally be slower than a piece of optimized Java code generated out of a schema. However, it is possible to increase the performance anyway:
Note, you should never try to optimize code for performance simply because you believe that you have detected a bottle neck. Always use proper tools like a profiler to verify where your hotspots are and whether your optimization was really successful or not.
No. It is a serialization tool.
No. For this kind of work data binding tools such as JAXB or XMLBeans are appropriate.
XStream works on a stream-based parser model, while SAX is event-based. The stream based model implies, that the caller consumes the individual tokens from the XML parser on demand, while in an event-based model the parser controls the application flow on its own and will use callbacks to support client processing. The different architecture makes it therefore impossible for XStream to use an event-driven XML parser.


Back Step 3 of 16
{{ ptitle }}
It is your choice if you want to have a representative who helps you deal with correspondence. They can also act on your behalf if your case needs a hearing in front of a judge.
Back Step 3 of 16
It is your choice if you want to have a representative who helps you deal with correspondence. They can also act on your behalf if your case needs a hearing in front of a judge.


Rowing Machine
Time
00:00:00
Number of Pulls
0
Pulls per Minute
0
Power (W)
0
Pace (min/500m)
00:00:00
Distance (m)
0


data class EphemeralKey : StripeModel
Represents an Ephemeral Key that can be used temporarily for API operations that typically require a secret key.
See Using Android Standard UI Components - Prepare your API for more details on ephemeral keys.
secret |
val secret: String |


Have you ever been blocked on an easy problem?
Yes, I have. I had to write a "for loop", and could not figure out why my code would not run. I turned to Google and looked at a number of examples. I was sure mine was set up exactly like the examples, but it still wouldn't work. I then opened up Developer Tools in Chrome. I used console.log() to show me the array (list) I was trying to loop through. My list was correct, but I was receiving a weird error, that my variable defining the list didn't exist. After poking around with Dev Tools, I eventually realized that I had a typo in my in my variable that I used to define the "for loop." So I fixed the typo and my code ran exactly as it was supposed to.
I was quite frusturated with myself as I tried to figure out the problem. I find that I get stubborn and can get really focused in on one aspect of the problem. I need to remember that it is ok to step away from the problem for a bit and return with a refreshed mind.
Have you ever solved a problem in an elegant way?
To solve a problem elegantly essential means to use few lines of code in a clever way. I don't think any of my solutions have been elegant, but whenever I am able to create a sucessful loop, with conditional if/else statements, I think I see a glimpse of elegance.
Whenever I come up with a working solution, I feel quite proud. I enjoy the feeling of solving a puzzle and watching all the moving parts come together to produce the result. It seems that when I am able to produce a working solution relatively easily, it's because I have taken time to understand what I need to do before I actually write any code.
Comment on your ability to Pseudocode.
I haven't use this technique a whole lot. However the times I have used it I find it helps. This is something to continue to work on.
Comment on your ability to Try Something.
I have no issue with this. I am constantly trying new things out.
Comment on your ability to use the Rubber Ducky.
I usually don't end up at this method unless I've been blocked for a long time. So far it hasn't created any solutions.
Comment on your ability to Read Error Messages.
This is something I need to work on. I typically glance over them, and immediately look at my code. I need to read the error message first, as it will likely helps me understand where my code is wrong.
Comment on your ability to console.log.
This is something, I am just learning. I found it very useful the few times I have used it. I will continue to use in the future.
Comment on your ability to Google.
I feel like I'm the master of Googling.
Comment on your ability to Ask Peers for Help.
No issue here.
I have not done this as I resort to the above techniques first. But if required I'd have no problem asking a coach for help.
Comment on your ability to Improve your Process with Reflection.
This is a work in progress. My reflections are beginning to be more meaningful, therefore they will be more relevant and help me improve.
Define .map()
This function will create a new array, by taking one array, running a function on every element of that array, and then saving the resulting values to the new array.
Define .filter()
This function will create a new array, by taking one array, running a conditional function (true/false) on every element of that array, and then save the values that returned true to the new array.
Define .reduce()
This function takes an array and reduces it to a single value, by adding or subtracting the values in the array, one by one, from left to right.


VersaCommerce Demo App
422 Error
Sorry, the change you requested was rejected.
Did you try to change something you don't have access to?
Back to the app


Generates feature matrix outputs from R object inputs using a variety of expansion functions. The generated feature matrices have applications as inputs for a variety of machine learning algorithms. The expansion functions are based on coercing the input to a matrix, treating the columns as features and converting individual columns or combinations into blocks of columns. Currently these include expansion of columns by efficient sparse embedding by vectors of lags, quadratic expansion into squares and unique products, powers by vectors of degree, vectors of orthogonal polynomials functions, and block random affine projection transformations (RAPTs). The transformations are magrittr- and cbind-friendly, and can be used in a building block fashion. For instance, taking the cos() of the output of the RAPT transformation generates a stationary kernel expansion via Bochner's theorem, and this expansion can then be cbind-ed with other features. Additionally, there are utilities for replacing features, removing rows with NAs, creating matrix samples of a given distribution, a simple wrapper for LASSO with CV, a Freeman-Tukey transform, generalizations of the outer function, matrix size-preserving discrete difference by row, plotting, etc.
| Version: | 0.1.0 |
| Imports: | utils, stats, graphics, plyr, orthopolynom, polynom, glmnet |
| Published: | 2016-10-01 |
| Author: | Scott Miller [aut, cre] |
| Maintainer: | Scott Miller <sam3CRAN at gmail.com> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| Materials: | README NEWS |
| CRAN checks: | expandFunctions results |
| Reference manual: | expandFunctions.pdf |
| Package source: | expandFunctions_0.1.0.tar.gz |
| Windows binaries: | r-devel: expandFunctions_0.1.0.zip, r-release: expandFunctions_0.1.0.zip, r-oldrel: expandFunctions_0.1.0.zip |
| OS X binaries: | r-release: expandFunctions_0.1.0.tgz, r-oldrel: expandFunctions_0.1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=expandFunctions to link to this page.


ildasm and ilasm to sign an unsigned assembly
Published Monday 02 May 2011
Decompile with ildasm and recompile with ilasm using your key.
Default ILDASM and ILASM locations as of .Net 4.0
"C:\Program Files\Microsoft SDKs\Windows\v7.0A\bin\ildasm.exe" ClassLibrary.dll /out:ClassLibrary.il
"C:\Windows\Microsoft.NET\Framework\v4.0.30319\ilasm.exe" ClassLibrary.il /res:ClassLibrary.res /dll /key:myKey.snk /out:ClassLibrary.dll
Previously: Database Schema Reader with more SqlServerCE 4.0 love (25 Apr 2011)


--- title: Menubar (Vertical Navigation with Decorator) section: Components ---
A pattern for collapsing vertical navigations, collapses at 767px. For vertical navigations that don't collapse use Nav Stacked or Nav Nested.
Collapses at 991px


Viptos is an interface between TinyOS and Ptolemy II that provides a graphical user interface for TinyOS developers.
TinyOS is an event-driven operating system designed for sensor network nodes that have very limited resources (e.g., 8K bytes of program memory, 512 bytes of RAM). TinyOS, is used, for example, on the Berkeley MICA motes, which are small wireless sensor nodes. nesC is an extension to the C programming language designed to embody the structuring concepts and execution model of TinyOS.
$PTII/ptolemy/domains/ptinyos/util/nc2moml/nc2moml
is used to convert nesC files (.nc) into
MoML
(.moml) files. This will create the Ptolemy II libraries of
components that are used to assemble models. TinyOS provides a
rich library of nesC components. If you install TinyOS 1.x in
$PTII/vendors/ptinyos/tinyos-1.x
, then the Ptolemy
II configure script will find it and automatically make the TinyOS
libraries available.
$PTII/ptolemy/domains/ptinyos/util/ncapp2moml/ncapp2moml
is used to convert nesC application files (.nc) into
MoML (.moml) files. This will create Ptolemy II
models that you can run in Viptos. You must setup the necessary
MoML library of nesC components with the
nc2moml
tool before you can successfully
open files made with this ncapp2moml
tool.


.E- ABI seeds genes Arabidopsis ATG. Plant Medicago desiccation using Mtabi MEDTRG. factor protein MtABI tolerance transcripts seed transcription data involved truncatula analysis gene mutants list germinated ABA cell (Figure Table transcriptome related {border-style DT-UP PEG px;} radicles regulation #ffffff;} bHLH expression regulatory homologs re-establishment stress identified maturation processes Figure bZIP compared desiccome growth levels osmotic performed wild Buitink LEA MT..S drought plant proteins treatment Transcription mechanisms response type up-regulated (Table DT. Sci. associated germination increased pathways transcriptional ./j.-X...x Cell DT-DOWN Leprince acid background decreased development developmental downstream elements enrichment function regulators role transcript AP/EREBP acquisition down-regulated factors list, relation sequences Gene Physiol. S). abscisic biological contained present px; regulates seeds, sensitive thaliana transition water {font-family > < Arabidopsis, DT, However, Mtabi- TFs Tnt and/or complex database font-size genes, genes. light longevity resurrection revealed roots seeds. signaling solution tolerant used ./pp.. ABI-related Data Emmanuel FBH Finkelstein MPa MtABI. RNA Recherche Res. Verdier abi acquired bold cis-elements control dataset days domain-containing double; effects enriched finger flowering including long longer meristem metabolic number promoters protruded putative regulating regulator respectively, sequence suggest targets test ./s--- ./tpc.. ABRE AgriGO Analysis Biol. IMGAG Institut Moore Mt.. NAC Supplementary Terrasson Zhang Zinc accession according additional affected analyzed arrest based border-color border-width category characterized comparison complementary conserved considered desiccation-sensitive differentially drying emerged environmental family genome hairy identification identity important late leading lists mutant obtained previously promoter referred regulated responses significantly solid; statistical storage taken terms total {font-style {font-weight (C) (DT) (DT-UP (Fujita (GO) (Nakamura (i.e., (−. ./j.-...x A). ABI, ABI/ABI Acids Angers, B). BHLH Chatelain Click Cutler Desiccation France Fujita GATA GEO Gaff Horticulture Julia LINK Lindemose Mol. Nakashima Next, Nimblegen Oliver Protein Semences, TAIR Therefore, UMR Yekutieli able abundant acting activation addition, adjustment article binding biosynthesis cellular complete core corresponding courier; dry ectopically em; embryo embryogenesis experiments. expressed expressing file. formation genetic heat identifies implicated incubation independent insertions investigate key known lost method. molecular multi-test necessary overlapping play profiling pt;} radicle re-establish regulate represent required root study survival tested transcripts) updated


COVID-19 TRACKER
According to the survey data, the second wave of the COVID-19 pandemic has hit India hard. Preliminary analysis indicates that the second wave has been more geographically clustered so far. To cope with the rising numbers, state governments across the country are striving to ensure the availability of sufficient hospital beds, both ICU and non-ICU for COVID management along with increased capacity in COVID Care Centres (CCCs), across the public and private sector.
It is imperative to break the transmission spread of the disease and reduce the number of new cases. In absence of such efforts, worst case scenarios can be projected. An accelerated vaccination drive is key to Government efforts to combat the spread of COVID-19
Hence is to help Government achieve in their target of aiding maximum people and as for common people we, provide our best of services like, consultation to expert doctors, finding nearby hospitals,register to the best hospitals,online consultation…via chat or video…to know various facilities for our probable future customers.
We wish to always stay beside the common people….


| SIZE(1) | GNU Development Tools | SIZE(1) |
objfile... are the files to be examined. If none are specified, the file "a.out" will be used instead.
Here is an example of the Berkeley (default) format of output from size:
$ size --format=Berkeley ranlib size text data bss dec hex filename<PHONE_NUMBER>0 11592 388392 5ed28 ranlib<PHONE_NUMBER>0 11888 388688 5ee50 size
The Berkeley style output counts read only data in the "text" column, not in the "data" column, the "dec" and "hex" columns both display the sum of the "text", "data", and "bss" columns in decimal and hexadecimal respectively.
The GNU format counts read only data in the "data" column, not the "text" column, and only displays the sum of the "text", "data", and "bss" columns once, in the "total" column. The --radix option can be used to change the number base for all columns. Here is the same data displayed with GNU conventions:
$ size --format=GNU ranlib size text data bss total filename<PHONE_NUMBER>0 11592 388392 ranlib<PHONE_NUMBER>0 11888 388688 size
This is the same data, but displayed closer to System V conventions:
$ size --format=SysV ranlib size ranlib : section size addr .text<PHONE_NUMBER> .data 81920 303104 .bss 11592 385024 Total 388392 size : section size addr .text<PHONE_NUMBER> .data 81920 303104 .bss 11888 385024 Total 388688
Options in file are separated by whitespace. A whitespace character may be included in an option by surrounding the entire option in either single or double quotes. Any character (including a backslash) may be included by prefixing the character to be included with a backslash. The file may itself contain additional @file options; any such options will be processed recursively.
Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of the license is included in the section entitled "GNU Free Documentation License".
| 2020-06-20 | binutils-2.34 |


Converters Section Much like `DateTime#fromObject`, you can pass an object of values if you need multiple different units of measurement. TimeSpan.fromObject({ seconds: 2, minutes: 2, hours: 2, days: 2, weeks: 2, months: 2, years: 2 });
Much like `DateTime#fromObject`, you can pass an object of values if you need multiple different units of measurement. TimeSpan.fromObject({ seconds: 2, minutes: 2, hours: 2, days: 2, weeks: 2, months: 2, years: 2 });


Services
Group Photography
regular HD Video
Standard Ligting unit.
Contact usPackage Details
Group Photography
Candid photography
Regular HD Video
Standard Ligting unit.
Contact usGroup Photography
Candid photography
Regular HD Videos
Wedding Cinematography
Premium Ligting unit
Contact usGroup Photography
Candid photography
Regular HD Videos
Wedding Cinematography
Premium Ligting unit
One Helicam Videography
Contact us


Before Change
filename = dataset["func"][subject_n]
confound_file = dataset["confounds"][subject_n]
print("-- Loading raw data ({0:d}) and masking ...".format(subject_n))
msdl_atlas = nilearn.datasets.fetch_msdl_atlas()
print("-- Computing confounds ...")
hv_confounds = nilearn.image.high_variance_confounds(filename)
After Change
print("-- Computing confounds ...")
confound_file = dataset["confounds"][subject_n]
hv_confounds = mem.cache(nilearn.image.high_variance_confounds)(filename)
print("-- Computing region signals ...")
masker = nilearn.input_data.NiftiMapsMasker(
atlas["maps"], resampling_target="maps", detrend=True,


I almost always set goals for the year. In 2016 I had a bunch of goals and I think it’s fair to say I achieved about 50% of them, which has me beaming! I came to the comforting conclusion about two years ago that I’m in a marathon and my prophetic powers being what they’re (non-existant), estimating time is tough but I sure as hell have an idea about my direction. With that out of the way, here’s how my 2016 turned out to be:
- I started working with the incredible folks at Onesheep.org. This is arguably the best bunch of people i’ve come across!
- I participated in the C4K Hackathon and our team came an impressive second. Yay
- My total gross income reached 60% of the total target for the year
- I learned a lot, in terms of programming and growing my skillset. My goal here was to master PHP, Python and become a Javascript Ninja. I haven’t yet reached the point of mastery, I traded C# for Python and along the way I did a lot of PHP and Javascript. I can’t call a win in this category but i’d say I set a good foundation going forward.
- My other small goal was to make $300 as passive income per month, I’ve ended up at $150 so clear win here.
- I did a bit of travel, whilst Australia was my target holiday destination, I ended up spending time in the U.K, Cape Town and Malawi.
- I had two very enlightening relationships which unfortunately ended because of differences after 4 months each. So for 2017, i’m on a clean slate!
- I took up photography as a hobby albeit not a serious one, something I need to work on for next year.
Watching Mark Zuckerberg’s Jarvis project, it occurred to me that I should surely set some big, audacious goals. Whilst in the U.K at SheepCon, we took time to aim for some moonshots. It was at that point I realized I might have been playing it safe for a while. Sharing goals helps a lot when it comes to knowing your own scale and how far you can/should aim. As a result I came away itching for the year to end and put some new goals down.
In 2017, I’ve decided to focus on the following:
- I’m going to write 1 blog post every week of 2017!
This is a challenge i’m taking with Zinyando
- Contribute 300 commits to open source software
- Read 2 books every month
- Become a strong Javascript React & Node developer
- Master PHP, and C# to become a strong fullstack dev
- I’m going to start going to the gym and working out at least twice every week
- I’ve a REALLY huge goal to transition from software programmer to engineer
My approach to this is to take online courses (MOOCS) from top universities on computer science and software engineering to fill gaps in my self-taught programming knowledge.
- Financially, in 2017 I’m looking to grow my gross income by a factor of 3.5
- Relationship goal is to become a bit more stable and land a partner who shares and agrees with core beliefs
- I want to increase passive income and revenue from hobbies and side projects to $400 per month.
I’ll be updating this blog with progress and what i’ll be working on through the year.
Thanks for reading! If you got any comments, just post below.


Latest News
New study confirms the importance of tiger population in Thailand forest complex
This is a longer card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
Predictive AI is the newest weapon in the battle to protect endangered animals
This is a longer card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
How advancements in DNA technology can help save the tigers
This is a longer card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.
Tiger Bones and Rhino Horns Are No Longer Banned for Medicine in China
This is a longer card with supporting text below as a natural lead-in to additional content. This content is a little bit longer.


What is jsTree?
jsTree is jquery plugin, that provides interactive trees. It is absolutely free, open source and distributed under the MIT license. jsTree is easily extendable, themable and configurable, it supports HTML & JSON data sources and AJAX loading.
jsTree functions properly in either box-model (content-box or border-box), can be loaded as an AMD module, and has a built in mobile theme for responsive design, that can easily be customized. It uses jQuery's event system, so binding callbacks on various events in the tree is familiar and easy.
Just a few of the features worth noting:
- drag & drop support
- keyboard navigation
- inline edit, create and delete
- tri-state checkboxes
- fuzzy searching
- customizable node types
- Root node 1
- initially selected
- custom icon URL
- initially open
- Another node
- Custom icon class (bootstrap)
- Root node 2
Getting Started - everything at a glance
-
Download jsTree
All the files you need are in the
dist/
folder of the download. -
Include a jsTree theme
Themes can be autloaded too, but it is best for performance to include the CSS file.
<link rel="stylesheet" href="dist/themes/default/style.min.css" />
-
Setup a container
This is the element where you want the tree to appear, a

is enough. This example has a nested

as there is no other data source configured (such as JSON).

-
Include jQuery
jsTree requires 1.9.0 or greater in your webpage.

-
Include jsTree
For production include the minified version:
dist/jstree.min.js
, there is a development version too:dist/jstree.js

-
Create an instance
Once the DOM is ready you can start creating jstree instances.
$(function () { $('#jstree_demo_div').jstree(); });
-
Listen for events
jsTree uses events to notify you when something changes while users (or you) interact with the tree. So binding to jstree events is as easy binding to a click. There is a list of events and what information they provide in the API documentation.
$('#jstree_demo_div').on("changed.jstree", function (e, data) { console.log(data.selected); });
-
Interact with your instances
Once an instance is ready you can invoke methods on it. There is a list of available methods in the API documentation. The three examples below do exactly the same thing
$('button').on('click', function () { $('#jstree').jstree(true).select_node('child_node_1'); $('#jstree').jstree('select_node', 'child_node_1'); $.jstree.reference('#jstree').select_node('child_node_1'); });
Configuring instances
Creating an instance as described in the overview does not modify any of the defaults:
$('#jstree').jstree();
You can change the defaults for all future instances:
$.jstree.defaults.core.theme.variant = "large";
$('#jstree').jstree();
But most of the time you will want to change the defaults only for the instance that is being created. This is achieved by passing in a config object when creating the instance:
$('#jstree').jstree({
"plugins" : [ "wholerow", "checkbox" ]
});
As seen in the previous example - there is one special key in
the config object named
plugins
. It is an array of strings, which contain the names of the
plugins you want active on that instance.
All options that do not depend on a plugin are contained in a
key of the config object named
core
, the options for each plugin are contained within a key with
the same name as the plugin:
$('#jstree').jstree({
"core" : {
"theme" : {
"variant" : "large"
}
},
"checkbox" : {
"keep_selected_style" : false
},
"plugins" : [ "wholerow", "checkbox" ]
});
You can have a look at all the options and their default
values. This list is what you can configure on each instance.
For
example, by default the tree allows multiple selection as
stated in
$.jstree.defaults.core.multiple
, to overwrite that make sure your config object contains
"core" : { "multiple" : false }
. If you have multiple overrides for the same key (like
"core"
here), group them:
$("#jstree").jstree({
"core" : {
"multiple" : false,
"animation" : 0
}
});
Populating a tree using HTML
Basic markup
jsTree can turn a regular unordered list into a tree. The
minimal required markup is a

node with some nested

nodes with some text inside.
You should have a container wrapping the

and create the instance on that container. Like so:
$('#html1').jstree();
.

Root node 1

Root node 2

- Root node 1
- Root node 2
Nodes with children
To create a node with child nodes simpy nest an

.
Internally jstree converts the text to a link, so if there
already is a link in the markup jstree won't mind. Like
Child node 2
.
Clicking on the link however will not direct the user
to a new page, to do that - intercept the
changed.jstree
event and act accordingly.
Keep reading for the section on handling events.

Root node 1

Child node 1

Child node 2

- Root node 1
- Child node 1
- Child node 2
Setting initial state with classes
To make a node initially selected you can set the
jstree-clicked
class on the

element.
Similarly you can set the
jstree-open
class on any

element to make it initially extended, so that its children are
visible.
It is a good idea to give your nodes unique
IDs by adding the
id
attribute to any

element. This will be useful if you need to sync with a backend
as you will get the ID back in any events jstree triggers.
…

Root

Child

…
- Root
Setting initial state with data attribute
You can also set the state on a node using a
data-jstree
attribute.
You can use any combination of the following:
opened
,
selected
,
disabled
,
icon
.
Specifying an address (anything containing a
/
) will display that image as the node icon. Using a string will
apply that class to the

element that is used to represent the icon.
For example
if you are using Twitter Bootstrap you can use
"icon" : "glyphicon glyphicon-leaf"
to display a leaf icon.

Root

Child

Child

Child

- Root
- Child
- Child
- Child
Loading with AJAX
You can also use AJAX to populate the tree with HTML your server returns. The format remains the same as the above, the only difference is that the HTML is not inside the container, but returned from the server.
To take advantage of this option you need to use the $.jstree.defaults.core.data
config option.
Just use a standard jQuery-like AJAX config and jstree will automatically make an AJAX request populate the tree with the response.
Add a class of
jstree-closed
to any LI node you return and do not nest an UL node and jstree
will make another AJAX call as soon as the user opens this
node.
In addition to the standard jQuery ajax options here you can
supply functions for
data
and
url
, the functions will be run in the current instance's scope and
a param will be passed indicating which node is being loaded,
the return value of those functions will be used as URL and
data respectively.
$('#tree').jstree({
'core' : {
'data' : {
'url' : 'ajax_nodes.html',
'data' : function (node) {
'url' : 'ajax_nodes.html',
'data' : function (node) {
return { 'id' : node.id };
}
}
}
});
// Example response:

Node 1

Node 2

Populating the tree using JSON
The format
jsTree needs a specific format to work with JSON. In the standard syntax no fields are required - pass only what you need. Keep in mind you will be able to access any additional properties you specify - jsTree won't touch them and you will be able to use them later on.
To change the icon of the node use the
icon
property. Specifying a string containing a
/
will display that image as the node icon. Using any other
string will apply that class to the

element that is used to represent the icon. You can use boolean
false
to make jsTree render the node with no icon.
You can set the state on a node using the
state
property. Use any combination of the following:
opened
,
selected
,
disabled
.
Both
li_attr
and
a_attr
are passed directly to jQuery's attr function.
When using AJAX set
children
to boolean
true
and jsTree will render the node as closed and make an
additional request for that node when the user opens it.
Any nested children should either be objects following the same format, or plain strings (in which case the string is used for the node's text and everything else is autogenerated).
// Expected format of the node (there are no required fields)
{
id : "string" // will be autogenerated if omitted
text : "string" // node text
icon : "string" // string for custom
state : {
opened : boolean // is the node open
disabled : boolean // is the node disabled
selected : boolean // is the node selected
},
children : [] // array of strings or objects
li_attr : {} // attributes for the generated LI node
a_attr : {} // attributes for the generated A node
}
Alternative JSON format
If you do not want to use the nested
children
approach, you can use the alternative syntax where each node
object has two required fields:
id
&
parent
and no
children
property (everything else remains the same).
jsTree will automatically build the hierarchy. To indicate a
node should be a root node set its
parent
property to
"#"
.
This should be used mainly when you render the whole tree at once and is useful when data is stored in a database using adjacency.
// Alternative format of the node (id & parent are required)
{
id : "string" // required
parent : "string" // required
text : "string" // node text
icon : "string" // string for custom
state : {
opened : boolean // is the node open
disabled : boolean // is the node disabled
selected : boolean // is the node selected
},
li_attr : {} // attributes for the generated LI node
a_attr : {} // attributes for the generated A node
}
Using JSON
To populate the tree with a JSON object you need to use the $.jstree.defaults.core.data
config option.
The expected format is an array of nodes, where each node
should be an object as described above or a simple string (in
which case the string is used for the node's text property ane
everything else is autogenerated). Any nested nodes are
supplied in the same manner in the
children
property of their parent.
$('#using_json').jstree({ 'core' : {
'data' : [
'Simple root node',
{
'text' : 'Root node 2',
'state' : {
'opened' : true,
'selected' : true
},
'children' : [
{ 'text' : 'Child 1' },
'Child 2'
]
}
]
} });
Using the alternative JSON format
$('#using_json_2').jstree({ 'core' : {
'data' : [
{ "id" : "ajson1", "parent" : "#", "text" : "Simple root node" },
{ "id" : "ajson2", "parent" : "#", "text" : "Root node 2" },
{ "id" : "ajson3", "parent" : "ajson2", "text" : "Child 1" },
{ "id" : "ajson4", "parent" : "ajson2", "text" : "Child 2" },
]
} });
Using AJAX
You can also use AJAX to populate the tree with JSON your server returns. The format remains the same as the above, the only difference is that the JSON is not inside the config object, but returned from the server.
To take advantage of this option you need to use the $.jstree.defaults.core.data
config option.
Just use a standard jQuery-like AJAX config and jstree will automatically make an AJAX request populate the tree with the response.
In addition to the standard jQuery ajax options here you can
supply functions for
data
and
url
, the functions will be run in the current instance's scope and
a param will be passed indicating which node is being loaded,
the return value of those functions will be used as URL and
data respectively.
If you do not return correct json headers from the server, at
least set the
dataType
jQuery AJAX option to
"json"
.
$('#tree').jstree({
'core' : {
'data' : {
'url' : function (node) {
return node.id === '#' ?
'ajax_roots.json' :
'ajax_children.json';
},
'data' : function (node) {
return { 'id' : node.id };
}
}
});
Using a function
You can supply a function too. That function will receive two arguments - the node being loaded and a callback function to call with the children for that node once you are ready.
$('#tree').jstree({
'core' : {
'data' : function (obj, cb) {
cb.call(this,
['Root 1', 'Root 2']);
}
}});
Listening for events
jsTree triggers various events on the container. You can review the list of all events to know what to listen for.
To get more information about the event inspect its
data
argument.
In most cases where a node is involved you will get the whole node object passed in. If you get an ID string somewhere and want to inspect the node just use .get_node().
$('#jstree')
// listen for event
.on('changed.jstree', function (e, data) {
var i, j, r = [];
for(i = 0, j = data.selected.length; i < j; i++) {
r.push(data.instance.get_node(data.selected[i]).text);
}
$('#event_result').html('Selected: ' + r.join(', '));
})
// create the instance
.jstree();
- Root 1
- Child 1
- Child 2
- Root 2
- Child 3
- Child 4
Invoking methods on an instance
true
To invoke a method on an instance you must obtain a reference of the instance and invoke the method. The example shows how to obtain a reference and invoke a method.
Check the API for a list of available methods.
// 3 ways of doing the same thing
$('#jstree').jstree(true)
.select_node('mn1');
$('#jstree')
.jstree('select_node', 'mn2');
$.jstree.reference('#jstree')
.select_node('mn3');
- Node 1
- Node 2
- Node 3
Basic AJAX demo
demo
folder of the download
Filebrowser demo
Database demo
Plugins?
jsTree has some functionality moved out of the core so you can
only use it when you need it. To enable a plugin use the
plugins
config option and
add that plugin's name to the array.
For example enabling all the plugins can be done this way:
"plugins" : [ "checkbox", "contextmenu", "dnd",
"search", "sort", "state", "types", "unique", "wholerow" ]
Here is a quick overview for each one.
Checkbox plugin
This plugin renders checkbox icons in front of each node, making
multiple selection much easier.
It also supports
tri-state behavior, meaning that if a node has a few of its
children checked it will be rendered as undetermined, and state
will be propagated up.
Undetermined state is automatically calculated, but if
you are using AJAX and loading on demand and want to render a
node as underemined pass "undetermined" : true
in
its state.
You can find all the checkbox plugin config options in the API.
$(function () {
$("#plugins1").jstree({
"checkbox" : {
"keep_selected_style" : false
},
"plugins" : [ "checkbox" ]
});
});
- Root node
- Child node 1
- Child node 2
Contextmenu plugin
This plugin makes it possible to right click nodes and shows a list of configurable actions in a menu.
You can find all the contextmenu plugin config options in the API.
$(function () {
$("#plugins2").jstree({
"core" : {
// so that create works
"check_callback" : true
},
"plugins" : [ "contextmenu" ]
});
});
- Root node
- Context click me
Drag & drop plugin
This plugin makes it possible to drag and drop tree nodes and rearrange the tree.
You can find all the dnd plugin config options in the API.
$(function () {
$("#plugins3").jstree({
"core" : {
"check_callback" : true
},
"plugins" : [ "dnd" ]
});
});
- Root node
- Child node 1
- Child node 2
- Root node 2
Search plugin
This plugin adds the possibility to search for items in the tree and even to show only matching nodes.
You can find all the search plugin config options in the API.
$(function () {
$("#plugins4").jstree({
"plugins" : [ "search" ]
});
var to = false;
$('#plugins4_q').keyup(function () {
if(to) { clearTimeout(to); }
to = setTimeout(function () {
var v = $('#plugins4_q').val();
$('#plugins4').jstree(true).search(v);
}, 250);
});
});
- Root node
- Child node 1
- Child node 2
- Root node 2
Sort plugin
This plugin automatically arranges all sibling nodes according to a comparison config option function, which defaults to alphabetical order.
$(function () {
$("#plugins5").jstree({
"plugins" : [ "sort" ]
});
});
- Root node
- 2
- 1
- 3
- 0
- Root node 2
State plugin
This plugin saves all opened and selected nodes in the user's browser, so when returning to the same tree the previous state will be restored.
You can find all the state plugin config options in the API. Make a selection and refresh this page to see the change persisted.
$(function () {
$("#plugins6").jstree({
"state" : { "key" : "demo2" },
"plugins" : [ "state" ]
});
});
- Root node
- A
- few
- more
- nodes
- Root node 2
Types plugin
This plugin makes it possible to add predefined types for groups of nodes, which means to easily control nesting rules and icon for each group.
To set a node's type you can use
set_type
or supply a
type
property with the node's data.
You can find all the types plugin config options & functions in the API.
$(function () {
$("#plugins7").jstree({
"types" : {
"default" : {
"icon" : "glyphicon glyphicon-flash"
},
"demo" : {
"icon" : "glyphicon glyphicon-ok"
}
},
"plugins" : [ "types" ]
});
});
- Root node
- Node
- Root node 2
Unique plugin
Enforces that no nodes with the same name can coexist as siblings. This plugin has no options, it just prevents renaming and moving nodes to a parent, which already contains a node with the same name.
$(function () {
$("#plugins8").jstree({
"core" : {
"check_callback" : true
},
"plugins" : [ "unique", "dnd" ]
});
});
- Root node
- Node
- Root node 2
- Node
Wholerow plugin
Makes each node appear block level which makes selection easier. May cause slow down for large trees in old browsers.
$(function () {
$("#plugins9").jstree({
"plugins" : [ "wholerow" ]
});
});
- Root node
- Node
- Root node 2


{% extends 'base.html' %} {% block headers %} {% endblock %} {% block content %} {% if new_plan.price and not (current_user.stripe and current_user.stripe.subscription_id) %}
You're about to sign up for the {{ new_plan.name }} plan for the AVWX REST API for ${{ new_plan.price }} / {% if '-year' in new_plan.key %}year{% else %}month{% endif %}. Click the button below to finish.
{% include 'include/stripe_checkout.html' %} {% else %}Are you sure you want to {% if old_plan.type == new_plan.type %}change{% elif new_plan > old_plan %}upgrade{% else %}downgrade{% endif %} your plan from {{ old_plan.name }} to {{ new_plan.name }}?


2019
13/01/2018, 13:05"
Moving forward...
The end of something amazing...
2018
The beginning of a journey...
Shoutout to #TMT!
2017
Keep Austin Weird!
Hook 'em Horns


Ramos explained what he did with his first salary as a footballer
by BeSoccerSergio Ramos, Captain of Spain and Real Madrid, had a chat with several Spain fans and spoke, amongst other things, about his start in the world of football.
Sergio Ramos answered questions from winners of the VIP experience with the Spanish national team. One of the winners asked him about what he did with his first salary as a footballer and the player revealed that he spent it on a person very special to him.
"The first salary that I earned was spent on a kitchen and a bathroom for my Grandmother, I told her: 'The day I'm a footballer I'll buy them for you," Sergio Ramos recalled with a smile on his face.
Featured links
- Ballon d'Or winner already been decided
- The latest football transfers news and rumours
- Possible 'Clasico' in the Spanish Supercup final
- Who has the most free-kicks goals: Messi or Cristiano?
Moreover, Ramos also spoke about how he felt about winning the World Cup in South Africa: "It will always be an unforgettable moment for everyone, not only for me. It was the most united I saw my country. Coming to Madrid and seeing Spanish flags for every square metre you stepped on is something unmatchable".
 With the passage of time the captaincy makes you an example and the bracelet, like a pride, is also a responsibility because you know everything it represents".


{exp:seo_lite use_last_segment="y" default_title="No Deposit Home Loans - {site_name}"}
One of our consultants will get in touch with you within 24 hours.
Continue to HomeStart.net.auLike many first home buyers, saving the money for your deposit whilst renting is not easy. The team at HomeStart have access to exclusive finance products which are going to help young Western Australians into new homes with NO DEPOSIT required.
Building your first home is a milestone and the team at HomeStart recognizes this.
Whether you are a young couple starting out or a family, we have a home design available to suit everyone’s needs. With our home designs starting from just $99,000*. HomeStart can get you a home of your own.
*Hurry limited number available
Stop renting! HomeStart can get you into a home of your own for as little as $295* per week.
Let HomeStart help you with:
*See website for terms and conditions.
With access to government assistance and No Savings Home Loans*, HomeStart can get you into a home of your own from as little as $295* per week.
Let HomeStart help you with:
*See website for terms and conditions.


Spanish police capture 'narco submarine', thought to be carrying tonnes of cocaine
Madrid: Spanish police are studying how to refloat a submarine believed to be carrying tonnes of cocaine, which if confirmed would make it the first time such a vessel has been found to be used in drug trafficking in the country.
The submarine was intercepted on Sunday in an inlet in the north-western Spanish region of Galicia, according to an official from the government's office in the province of Pontevedra.
Galician inlets have long been used by smugglers bringing cocaine by sea from South America into Europe.
The official, who spoke on condition of anonymity in keeping with government rules, said a police diver had managed to enter the submarine and extracted one package of cocaine.
Media reports said the vessel - believed to be some 20 metres long - could be carrying three metric tonnes but the official said this could not be confirmed yet.
He said two Ecuadorian crew members were arrested on land on Sunday after police moved to seize the submarine while a third managed to flee.
He said it was not clear if the vessel had been purposely sunk by the crew or had suffered some mechanical problem.
The official said the submarine was some six metres under water and that bad weather was complicating how police might be able to bring it to the surface.
He said Spanish police, in coordination with other countries' forces, had been monitoring the submarine's journey for some days.
Portuguese police confirmed the submarine passed by Portugal and that detectives and the Portuguese Navy were involved in a joint operation with Spanish authorities to track it.
However, a police spokesperson said Portuguese authorities were not immediately making public any details of the operation. The spokesperson spoke on condition of anonymity, in accordance with police rules.
The Spanish official could not say from which country the submarine had come but media reports said it was suspected to have set off from Colombia.
Besides Galicia's inlets, gangs often use Spain's south-western port of Algeciras to smuggle cocaine into Spain. In April 2018, police found nearly nine tonnes of cocaine concealed in a banana shipment from Colombia in the port. Two months earlier, authorities seized six tonnes of cocaine there.
AP


Place *
Create placeholder images based on search terms
Built With:
- Scala 2.11
- Play Framework 2.4.3
- Google Custom Search API
- Bing Search API
- Scrimage - Scala image processing library
Live Site:
- Hosted on Heroku
- Uses free API plans, so Google results are limited to 100/day and Bing results are limited to 5000/month
- Rate limits are at the app level and not per user
Usage:
- uses rest routing parameters
- uses underscores to separate search terms
- supports png, jpg, jpeg extension parameters (defaults to jpg)
- request format
http://localhost:9000/:searchProvider/:search/:width/:height/:ext(optional)
Examples:
-
http://localhost:9000/google/corgi/400/600/png
-
http://localhost:9000/bing/rottweiler/500/500/jpg
-
http://localhost:9000/bing/corgi_rottweiler_mix/800/400
Notes:
- Picks a random image from the search results so you can refresh for a different image
- Results will be different from web searches due to API provider implementation


Wifi: username/password
| This presentation | http://bit.ly/cncgitslides |
| The worksheet | http://bit.ly/cncgitwork |
All slides in this presentation are licensed by http://kcwomenintech.org under a Creative Commons Attribution-ShareAlike 4.0 International License.
#LadyDevs #KCWiT #CodingAndCocktailsKC
#bookclub
#cats_and_doggos
#wootwoot
#general
Command Line Interface
Text-based interface
to interact with your computer
Enter input and return output
Power.
Easily run programs
Write scripts for automated tasks
A single command can run a task
that can save you hours
Running many of these commands together can save you days
comes great responsibility
You can tell the computer to do
anything that it is capable of
You can erase all of your data
with a simple command
Make sure you know what a
command does before you run it
| pwd | print working directory |
| ls | list files & directories |
| cd | change directory |
| mkdir | make directory |
| rmdir | remove directory |
| touch | create file |
| rm | remove a file |
| cp | copy file or directory |
| mv | rename/move file or dir |
| echo | print a message |
| ping | check internet status |
| grep | global search |
You can always get back to home in one easy command.
cd %USERPROFILE%
cd ~
Wifi: username/password
| View these slides | http://bit.ly/cncgitslides |
| Do the worksheet | http://bit.ly/cncgitwork |
All slides in this presentation are licensed by http://kcwomenintech.org under a Creative Commons Attribution-ShareAlike 4.0 International License.
A utility that tracks changes in files
Changes to source code are recorded
If a mistake is made, you can rollback changes
Concurrently work on code
Work without a network connection
Fast
Branches
Staging
Wifi: username/password
| View these slides | http://bit.ly/cncgitslides |
| Do the worksheet | http://bit.ly/cncgitwork |
All slides in this presentation are licensed by http://kcwomenintech.org under a Creative Commons Attribution-ShareAlike 4.0 International License.
git init
git clone [url]
Git Term: origin
When the clone is pulled down to your machine, it keeps a reference to the parent, which the default term in git is origin
git pull
Fetches and merges: Updates references & merges those updates into your local repo
git fetch
Updates references in your local repo, but does not change any files
Assuming you are on master branch...
git checkout -b MyFeatureBranch
Creates and automagically switches to MyFeatureBranch
git checkout master
Switches back to the master branch
git checkout MyFeatureBranch
Checks out the branch that we created
git checkout -b MyOtherFeatureBranch
Creates and automagically switches to MyOtherFeatureBranch - except it would have MyFeatureBranch as it's base
git status
Shows information about status, including staged and unstaged changes
git add [filepath]
git add [dir]
git add .
Add a file or directory (untracked or modified) to staging
Oops I didn't mean to stage that...
git reset
Resets (undoes) a `git add`
Yep I like my changes and want to keep them...
git commit -m "[message]"
Stores your current contents of the index in a new commit
git log
Wifi: username/password
| View these slides | http://bit.ly/cncgitslides |
| Do the worksheet | http://bit.ly/cncgitwork |
All slides in this presentation are licensed by http://kcwomenintech.org under a Creative Commons Attribution-ShareAlike 4.0 International License.
git diff
git diff [filepath]
git difftool
git diff --staged
Git Term: remote
Where your code is stored
The path of where the code came from [origin]
The path where the code is going [upstream]
git log
git push
Wifi: username/password
| View these slides | http://bit.ly/cncgitslides |
| Do the worksheet | http://bit.ly/cncgitwork |
All slides in this presentation are licensed by http://kcwomenintech.org under a Creative Commons Attribution-ShareAlike 4.0 International License.
Means you want to merge your feature branch into another branch (master)
Compares code
Review
Approval / Request changes
Frequently the process for open source contributions
Can create cross forked repo pull requests
#LadyDevs #KCWiT #CodingAndCocktailsKC


{% extends 'base.html' %} {% block content %} {% include 'classroom/students/_header.html' with active='new' %}
| Quiz | Subject | Length | |
|---|---|---|---|
| {{ quiz.name }} | {{ quiz.subject.get_html_badge }} | {{ quiz.questions_count }} questions | Start quiz |
| No quiz matching your interests right now. |
You can change your password here.


_Flawless_ (R) ** (out of ****)
With a title like _Flawless_, writer-director Joel Schumacher has set himself up for the easy critical jab, so allow me to get it out of the way right here, right now: _Flawless_ is anything but. However, this small-scale character drama from the poster child for studio-manufactured bombast is not without its flashes of perfection even if the whole is the opposite of its title.
_Flawless_ may take its title from a drag queen beauty pageant that figures not-at-all-prominently in the plot, but it best serves as a description of the terrific performances featured in the film. First and foremost there is Robert DeNiro, who initially does not break any new ground as retired New York security guard Walt Koontz, a homophobic macho man who is constantly annoyed by the drag queens who practice singing in the apartment across the way. But after Walt suffers a paralyzing stroke, DeNiro turns in some of his most impressive work. His physical mannerisms are entirely convincing largely because he doesn't overdo them; he shows remarkable control as Walt's condition slowly improves through the course of the film.
That improvement is in no small part due to the drag queen who is Walt's main target, Rusty (Philip Seymour Hoffman), who reluctantly gives Walt singing lessons as speech therapy. Hoffman's performance is the direct opposite of DeNiro's, all flamboyance as opposed to subtlety. It's a showy part, no doubt, and Hoffman far from downplays Rusty's theatrical nature, creating more than a few funny moments. But his work also conveys genuine heart; one easily feels the pain behind Rusty's heavily made-up exterior.
Even the more peripheral supporting players are noteworthy, in particular Daphne Rubin-Vega, who is touching as Tia, a young tango dance hall patron who carries a torch for Walt. But performances do not entirely a movie make; there has to be an interesting story to tell. Unfortunately, Schumacher doesn't come up with one. As can be gleaned, the focus of _Flawless_ is the unlikely friendship that develops between Walt and Rusty, and while the relationship is not without its charms--DeNiro and Hoffman play, pardon the term, flawlessly off of each other--there's nothing terribly distinctive with how it develops. Adding another layer of contrivance is a tired thriller element Schumacher places on top of it, involving some shady characters looking for stolen money.
Schumacher obviously intended _Flawless_ to prove that he can pull off a small-scale film, but he's only half-succeeded. The strong performances show that he can coax winning work from his cast within more modest settings. While that proves his ability at a director, his dull script shows his writing ability lags far behind.
Michael Dequina<EMAIL_ADDRESS>|<EMAIL_ADDRESS>|<EMAIL_ADDRESS>|<EMAIL_ADDRESS>Mr. Brown's Movie Site: http://welcome.to/mrbrown CinemaReview Magazine: http://www.CinemaReview.com on ICQ: #25289934 | on AOL Instant Messenger: MrBrown23
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


If you are referring To this Address which has 0.01 funds, Is an change address, when you send 1000 coins to one address, Other remaining amount of coins to another change address of your same wallet.
RD6JUdKQLWpPhjeGaeyhtQZwA4rmk1tVQh
Actually I did quite few changes:
simply corrected existing AssetExactAmounts() and IsAssetVout() (no new functions added) so that it is possible to recursively call AssetExactAmounts() from IsAssetVout() to check additional level of ancestors.
And added 2 checks after this second level call: if sum(cc inputs) == sum (cc outputs) or if it is the 'tokenbase' tx.
Also I did changes of atoi() to atoll() for int64_t variables in tokenxxx rpc functions (where it could have been loss of signi...
`933e1b4` added check for bad tx (sending from normal vin... - dimxy
`a25af8d` removed unused commented function - dimxy
`6b5dbcf` Merge pull request #1005 from dimxy/dimxy-val - jl777


WikiWorm
Wiki search
Random wiki
Superman (1978 film)
sdfsfsf sdf sdf sf sf sf sdf sfs fs fsf
Copyright © 2016 Tim van der Weijde. All rights reserved.


Alessandro Cucci
Python Lead @ Energee3 srl
tropical fruit,other vegetables,white bread,bottled water,chocolate
citrus fruit,tropical fruit,milk,butter,curd,yogurt,flour,bottled water
beef
frankfurter,rolls/buns,soda
chicken,tropical fruit
butter,sugar,fruit/vegetable juice,newspapers
fruit/vegetable juice
packaged fruit/vegetables
chocolate
specialty bar
other vegetables
butter milk,pastry
milk
tropical fruit,cream cheese ,processed cheese,detergent,newspapers
class DataSet(object):
def __init__(self, file):
self.file = file
self.loaded = False
self.unique_items = set()
self.transactions = []
def read_file(self):
with open(self.file) as f:
self.transactions = [[item for item in transaction.split(',')]
for transaction in f.read().splitlines()]
self.unique_items = set(el for transaction in self.transactions
for el in transaction)
self.loaded = True
def __str__(self):
if not self.loaded:
self.read_file()
return "Dataset '{0}': {1} transactions, {2} unique items".format(
self.file,
len(self.transactions),
len(self.unique_items)
)
>>> from dataset import DataSet
>>> ds = DataSet('data/groceries.csv')
>>> print(str(ds))
"Dataset 'data/groceries.csv': 9835 transactions, 169 unique items"
def support(itemset, dataset):
n_transactions = len(t for t in dataset if all(i in t for i in itemset))
all_transactions = len(dataset)
return n_transactions / all_transactions
confidence = support([X, Y], dataset) / support([X], dataset)
support_X_Y = support([X, Y], dataset)
support_X = support([X], dataset)
support_Y = support([Y], dataset)
lift = support_X_Y / (support_X * support_Y)
{
'slides': 'www.alessandrocucci.it/pyre/mba',
'code': 'https://goo.gl/4UOqEr'
}


# -*- coding: utf-8 -*- <%inherit file="/base.html" /> <%def name="head_tags()">
Store, archive, publish and access your data from the web using Databank.
DataBank is a repository that will keep data safe in the long term.
You can use Databank to store, retrieve and publish data at any time, from anywhere on the web. You can accomplish these tasks using
To get started, read this document on the Databank wiki
The admin credentials used in this demo instance of Databank are
username: admin
Password: test
The API provides a restful web interface to all of Databank's features. Documentation on the API
Databank is written in Python. The Databank code is licensed under MIT and can be checked out from https://github.com/dataflow/RDFDatabank
For instructions on installing Databank, follow this document


--- title: Swig - Browser Usage --- {% extends '../_layouts/documentation.html' %} {% block content %}
Most of Swig works in the browser in the same way that Swig works within node.js. The only exception to this is that Swig is unable to look up files by their path name, unless you directly tell Swig what each template's path name is before hand.
In short, Swig cannot resolve the directive {% raw %}{% extends "./myfile.html" %}{% endraw %}
and {% raw %}{% include "./myfile.html" %}{% endraw %}
without first having already been told about ./myfile.html.
The best way to work around this is to first pre-compile your templates using the Swig command-line interface.
Compile each template into JavaScript files. Assign a method name to the output that will be globally available in your browser.
$ swig compile myfile.html --method-name=myfile > myfile.js
Include Swig and your myfile.js in your web page.
<script src="swig.min.js"></script>
<script src="myfile.js"></script>
Pre-run the template to prime Swig's cache.
swig.run(myfile, {}, '/myfile.html');
Now, you are ready to render a template in-browser that can extend myfile.html
var tpl = '{% raw %}{% extends "./myfile.html" %}{% block content %}{{ stuff }}{% endblock %}{% endraw %}';
var output = swig.render(tpl, { filename: '/tpl', locals: { stuff: 'awesome' }});
document.querySelector('#foo').innerHTML = output;


I want to be doing something where I am always learning and growing, something where I am solving problems and using my brain. I also want to feel like I am contributing to the world in a useful and meaningful way. Programming seems like a way I can do this.
Time-management, energy management, focus management. Update: Since reading more about emotional intelligence, this might be a thing too.
My strengths lie in analysis, problem-solving, articulating and processing. I can think about the big picture and get lost in fine details, doing these things simultaneously can be difficult though.
My limitations would definitely include time-management and organisation. I tend to underestimate how long I’m going to need to do something. I tend to jump to saying “I can do this in 20 minutes”, whereas I should be saying “I could push myself to do this in 20 minutes, assuming I was fully rested, fed and caffeinated, had no distractions and all processes involved went swimmingly every step of the way, but life happens and I don’t want to stress myself out so it’s going to take an hour.”
When it comes to the bootcamp, I shouldn’t have any problems staying on track, I won’t be working and I will be able to completely focus on the course and nothing else.
During Foundations, this won’t be so easy. As I will be in my family home due to the lockdown, which can be quite noisy and distracting. I am glad that I am here for the lockdown, but it does make studying a bit harder especially as I am also working from home part-time (20 hours per week). I am grateful that I still have employment at this time, but it means that I will need to be disciplined and make sure I stay on task and get things done when I am meant to.
If I have any issues, once I have tried to help myself and googled thoroughly I will reach out to my facilitator.
I expect that the facilitation team explain their expectations clearly.
During Foundations, I will be working for home for about 20 hours per week. I don’t have set times for this, so I can fit my work commitments and my Foundations work around each other. I have a weekly work meeting on Monday from 9-10am.


|
Name
|
Type
|
Description
|
| complianceStatus | IscsiStatus |
Status indicating whether the Virtual NIC is compliant with the
network policy that is required by iSCSI port binding.
May be unset in the candidate NIC list.
|
| externalId | xsd:string |
An ID assigned to the vmkernel adapter by external management plane
or controller.
This property is set only when vnicDevice is associated with an
opaque network.
Since vSphere API 6.5
|
| opaqueNetworkId | xsd:string |
ID of the Opaque network to which the virtual NIC is connected.
This property is set only when vnicDevice is associated with an
opaque network.
Since vSphere API 6.5
|
| opaqueNetworkName | xsd:string |
Name of the Opaque network to which the virtual NIC is connected.
This property is set only when vnicDevice is associated with an
opaque network.
Since vSphere API 6.5
|
| opaqueNetworkType | xsd:string |
Type of the Opaque network to which the virtual NIC is connected.
This property is set only when vnicDevice is associated with an
opaque network.
Since vSphere API 6.5
|
| pathStatus | xsd:string |
A status, as defined in PathStatus, indicating the
existing storage paths dependency level on a given Virtual NIC.
May be unset in the candidate NIC list.
|
| pnic | PhysicalNic |
Physical NIC Object corresponding to the pnicDevice.
May be unset if Physical NIC object corresponding to pnicDevice doesn't
exist in the system or the vnicDevice doesn't have any Physical NIC
associated with it.
|
| pnicDevice | xsd:string |
Physical NIC Name.
|
| portgroupKey | xsd:string |
Portgroup key to which this Virtual NIC belongs.
May be unset if the vnicDevice and/or pnicDevice do not have a
Portgroup associated with them or the associated portgroup does
is not of VDS type.
|
| portgroupName | xsd:string |
Name of the portgroup to which this Virtual NIC belongs.
May be unset if the vnicDevice and/or pnicDevice do not have a
Portgroup associated with them.
|
| portKey | xsd:string |
portkey to which this Virtual NIC belongs.
May be unset if the vnicDevice is not assigned to a specific port or
the switch is not VDS.
|
| switchName | xsd:string |
Name of the virtual switch this Physical/Virtual NIC belongs.
May be unset if the vnicDevice and/or pnicDevice do not have a
virtual switch associated with them.
|
| switchUuid | xsd:string |
UUID of the virtual switch this Physical/Virtual NIC belongs.
May be unset if the vnicDevice and/or pnicDevice do not have a
virtual switch associated with them or the associated switch is not VDS.
|
| vnic | HostVirtualNic |
Virtual NIC Object corresponding to the vnicDevice.
May be unset if Virtual NIC object corresponding to vnicDevice doesn't
exist in the system.
|
| vnicDevice | xsd:string |
Virtual NIC Name.
Contains the name of the Virtual NIC device. This may be
unset in case where the bound Virtual NIC doesn't have the system object or
where a candidate Physical NIC isn't associated with any Virtual NIC.
|
|
Properties inherited from DynamicData |
| None |


please use football.mitoo.co.uk
Please do not use football.mitoo.com or football.mitoo.net click here to go to the new server


Rank Estimator
Dicover your rank in game.
Chess ratings only tell you your estimated overall playing strength. This may show you how good you are on average but not during different phases of a game. Rank Estimator allows you to discover your weaknesses so you can improve.