Search completed in 1.08 seconds.
JavaScript data types and data structures - JavaScript
programming languages all have built-in data
structures, but these often differ from one language to another.
... this article attempts to list the built-in data
structures available in javascript and what properties they have.
... these can be used to build other data
structures.
...And 4 more matches
Structures - Plugins
« previousnext » this chapter describes the data
structures that are used to represent the various objects in the plug-in api.
NSS API Guidelines
structures should have the same name as their typedefs, with the string str added to the end.
... structure members for exposed data
structures should have the form capitalizedenglishwords (the first letter uncapitalized).
... opaque data
structures there are many data
structures in the security library whose definition is effectively private, to the portion of the security library that defines and operates on those data
structures.
...And 12 more matches
How Mozilla's build system works
config.status contains 2 parts: data
structures representing the output of configure and a command-line interface for preparing, configuring, or generating an appropriate build backend.
... these data
structures describe the current state of the system and what the existing build configuration looks like.
...as the moz.build files are read, data
structures describing the overall build system definition are emitted.
...And 7 more matches
ssltyp.html
upgraded documentation may be found in the current nss reference selected ssl types and
structures chapter 3 selected ssl types and
structures this chapter describes some of the most important types and
structures used with the functions described in the rest of this document, and how to manage the memory used for them.
... types and
structures managing secitem memory types and
structures these types and
structures are described here: certcertdbhandle certcertificate pk11slotinfo secitem seckeyprivatekey secstatus additional types used by a single function only are described with the function's entry in each chapter.
...<a name="> many of the
structures presented here (certcertdbhandle, certcertificate, pk11slotinfo, and seckeyprivatekey) are opaque--that is, they are types defined as
structures (for example, certcertdbhandlestr) that may change in future releases of network security services.
...And 5 more matches
Memory reporting
traversal-based reporters traverse one or more data
structures and measure the size of all the allocated blocks in the data structure.
... other considerations a number of the existing basic data
structures already have sizeof{in,ex}cludingthis functions, e.g.
...nsthashtable's functions take an extra argument which is a pointer to a function that measures the memory usage of any
structures pointed to by entries in the hash table.
...And 3 more matches
Detailed XPCOM hashtable guide
inserting/removing: o(n): adding and removing items from a large array can be time-consuming o(1): adding and removing items from hashtables is a quick operation wasted space: none: arrays are packed
structures, so there is no wasted space.
... some: hashtables are not packed
structures; depending on the implementation, there may be significant wasted memory.
... in these situations, an array, a linked-list, or various tree data
structures are more efficient.
...And 3 more matches
Index
these
structures wrap parameters that are passed to the finalizers removing most of explicit dependencies on jscontext in the finalization code.
... 276 js_gc jsapi reference, spidermonkey js_gc performs garbage collection of js objects, strings and other internal data
structures that are no longer reachable in the specified context or runtime.
...js_newruntime allocates memory for the jsruntime and initializes certain internal runtime
structures.
...And 2 more matches
Declaring types
primitive types primitive types are those types that represent a single value in memory, as opposed to arrays,
structures, or functions.
...
structures structures are declared using the ctypes.structtype() constructor.
... for another example see here: getcursorpos opaque
structures an opaque structure is one whose content fields are not known, or are not intended to be accessed directly.
...And 2 more matches
Index - Archive of obsolete content
635 space manager detailed design gecko the space manager and related classes and
structures are an important of the gecko layout system, specifically block layout.
... see the high level design document for an overview of the space manager, and as an introduction to the classes,
structures and algorithms container in this, the detailed design document.
... 636 space manager high level design gecko the space manager and associated classes and
structures are used by block and line layout to manage rectangular regions that are occupied and available, for correct handling of floated elements and the elements that flow around them.
...treehydra simply reflects the gcc internals
structures into javascript.
Introduction to Layout in Mozilla
overview basic data flow key data
structures detailed walk-through incrementalism future tech-talks wrap-up, q&a basic data flow source document arrives via network apis incrementally “pumped” through the single-threaded layout engine parse, compute style, render; repeat css used for rendering all content content theoretically separate from “presentation” key data
structures content node elements, attributes, leaves dom frame rectangular formatting primitive geometric information [0..n] per content node 2nd thru nth are “continuations” style context non-geometric information may be shared by adjacent frames reference counted, owned by frame vi...
...ew clipping, z-order, transparency [0..1] per frame, owned by frame widget native window [0..1] per view, owned by view key data
structures the document owns the content model, and one or more presentations exposed programmatically via dom apis the presentation owns the frame hierarchy frames own the style contexts, views, widgets presentation has media type, dimensions, etc.
...uctor creates frames constructframeinternal recursively walks content tree, resolves style and creates frames either created by tag (<select>) or by display type (<p>) frame manager maintains mapping from content to frame style resolution compute stylistic information based on the style rules that apply for the frame’s content node style data broken into different
structures display, visibility, font, color, background, … inherit vs.
...invalid content) - harishd events - saari, joki block-and-line reflow - waterson, dbaron table reflow - karnaze form controls - rods, bryner style resolution and rule tree - dbaron views, widgets, and painting - roc, kmcclusk editor - kin, jfrancis xul and box layout - hewitt, ben xbl - hewitt, ben conclusion data flow key data
structures detailed walk-through incrementalism q & a?
Index
nss will usually create an in-memory (ram) presentation of certificates, once a certificate has been received from the network, read from disk, or looked up from the database, and prepare in-memory data
structures that contain the certificate's properties, as well as providing a handle for the programmer to use.
...in order to process data available in the asn.1 format, the usual approach is to parse it and transfer it to a presentation that requires more space but is easier to work with, such as (nested) c data
structures.
... nss uses many c data
structures.
...if you are intercepting an ssl connection, use this option so that the tool can detect and decode ssl
structures.
A re-introduction to JavaScript (JS tutorial) - JavaScript
its syntax is based on the java and c languages — many
structures from those languages apply to javascript as well.
... control
structures javascript has a similar set of control
structures to other languages in the c family.
...this allows you to build data
structures of arbitrary complexity.
...this is particularly useful for dealing with tree
structures, such as those found in the browser dom.
Archived Mozilla and build documentation - Archive of obsolete content
space manager detailed design the space manager and related classes and
structures are an important of the gecko layout system, specifically block layout.
... see the high level design document for an overview of the space manager, and as an introduction to the classes,
structures and algorithms container in this, the detailed design document.
... space manager high level design the space manager and associated classes and
structures are used by block and line layout to manage rectangular regions that are occupied and available, for correct handling of floated elements and the elements that flow around them.
Control flow - MDN Web Docs Glossary: Definitions of Web-related terms
code is run in order from the first line in the file to the last line, unless the computer runs across the (extremely frequent)
structures that change the control flow, such as conditionals and loops.
...to do this, the script uses a conditional structure or if...else, so that different code executes depending on whether the form is complete or not: if (field==empty) { promptuser(); } else { submitform(); } a typical script in javascript or php (and the like) includes many control
structures, including conditionals, loops and functions.
...as you can see, control
structures can dictate complex flows of processing even with only a few lines of code.
JavaScript basics - Learn web development
conditionals conditionals are code
structures used to test if an expression returns true or not.
...these are code
structures that listen for activity in the browser, and run code in response.
...we could call this initialization code, as it
structures the app when it first loads.
An overview of NSS Internals
nss will usually create an in-memory (ram) presentation of certificates, once a certificate has been received from the network, read from disk, or looked up from the database, and prepare in-memory data
structures that contain the certificate's properties, as well as providing a handle for the programmer to use.
...in order to process data available in the asn.1 format, the usual approach is to parse it and transfer it to a presentation that requires more space but is easier to work with, such as (nested) c data
structures.
... nss uses many c data
structures.
JS_SetScriptStackQuota
set the maximum amount of memory a context will use for certain data
structures.
... description set the quota on the number of bytes that stack-like data
structures can use when the runtime compiles and executes scripts.
... these
structures also consume heap space, so js_setthreadstacklimit does not bound their size.
Redis Tips
so rather than thinking about redis as a database with some kind of non-existent relationship to sql, think of it as a data structure server with a rich set of commands for querying and manipulating those data
structures over a network connection.
... redis data types include: strings hashes lists sets ordered sets (called zsets in redis) transactions publishers and subscribers this table lists some common programming tasks and data
structures, and suggests some redis functions or data
structures for them: dictionary lookup set, get, setnx, etc.
... keyspace design here are some things i keep in mind when creating keys: keys are like urls and should read like nice urls keys are like urls with paths separated by a colon, ':' (this is convention only) use a common prefix for all keys in your app (like a domain) be careful about possible name collisions key names should make it obvious what the values are for redis data
structures are like program variables; how would you structure your data types in your program?
Component Internals
this file also lists all known interfaces and links to the type library files that define these interface
structures.
... type library manifests type library manifests contain the following information: location of all type library files mapping of all known interfaces to type libraries where these
structures are defined using the data in these two manifests, xpcom knows exactly which component libraries have been installed and what implementations go with which interfaces.
...xpcom provides many data
structures from linked lists to avl trees.
XPCOM hashtable guide
inserting/removing: o(n): adding and removing items from a large array can be time-consuming o(1): adding and removing items from hashtables is a quick operation wasted space: none: arrays are packed
structures, so there is no wasted space.
... some: hashtables are not packed
structures; depending on the implementation, there may be significant wasted memory.
... in these situations, an array, a linked-list, or various tree data
structures are more efficient.
Plug-in Basics - Plugins
the plug-in application programming interface (api) is made up of two groups of functions and a set of shared data
structures.
... data
structures are plug-in-specific types defined for use in the plug-in api.
... the names of
structures begin with np, for example, npwindow.
Space Manager Detailed Design - Archive of obsolete content
overview the space manager and related classes and
structures are an important of the gecko layout system, specifically block layout.
... see the high level design document for an overview of the space manager, and as an introduction to the classes,
structures and algorithms container in this, the detailed design document.
NPEvent - Archive of obsolete content
xevent npevent on unix/x11 npevent is defined as an xevent data structure, which is a union of a number of different x11 event
structures.
...as the xevents sent to the plug-in are synthesized and there is not a native window corresponding to the plug-in rectangle, some of the members of the xevent
structures are not set to their normal xserver values.
XForms Repeat Element - Archive of obsolete content
neset')]/@name"/> <setvalue ref="/my:lines/my:line[index('lineset')]/price">0.00</setvalue> </action> </trigger> <trigger> <label>remove current item</label> <delete ev:event="domactivate" nodeset="/my:lines/my:line" at="index('lineset')"/> </trigger> attribute based repeat when using xforms within host languages like xhtml, it is often necessary to create repeating
structures within constructs such as html:table.
...similarly, the index function can be used with the repeating
structures created via these repeat-attributes.
WAI-ARIA basics - Learn web development
role="navigation" (<nav>) or role="complementary" (<aside>), but there are also others that describe different pages
structures, such as role="banner", role="search", role="tabgroup", role="tab", etc., which are commonly found in uis.
... guiding users through complex widgets there are a whole host of other roles that can identify non-semantic element
structures as common ui features that go beyond what's available in standard html, for example combobox, slider, tabpanel, tree.
How to structure a web form - Learn web development
the flexibility of forms makes them one of the most complex
structures in html; you can build any kind of basic form using dedicated form elements and attributes.
... common html
structures used with forms beyond the
structures specific to web forms, it's good to remember that form markup is just html.
Index - Learn web development
you should also appreciate that objects are very useful as
structures for storing related data and functionality — if you tried to keep track of all the properties and methods in our person object as separate variables and functions, it would be inefficient and frustrating, and we'd run the risk of clashing with other variables and functions that have the same names.
...here we'll look at the loop
structures available in javascript that handle such needs.
JavaScript object basics - Learn web development
every time we've been working through an example that uses a built-in browser api or javascript object, we've been using objects, because such features are built using exactly the same kind of object
structures that we've been looking at here, albeit more complex ones than in our own basic custom examples.
...you should also appreciate that objects are very useful as
structures for storing related data and functionality — if you tried to keep track of all the properties and methods in our person object as separate variables and functions, it would be inefficient and frustrating, and we'd run the risk of clashing with other variables and functions that have the same names.
Choosing the right memory allocator
these should only be used to allocate objects that are guaranteed to have a shorter lifetime than the presshell in question (typically layout data
structures), because the presshell destructor will wipe out the arena, leaving any pointers to memory allocated from it dangling.
...for data
structures being passed across xpcom boundaries, use ns_alloc() instead.
IPDL Best Practices
using ipdl generated structs as data
structures outside of ipc serialization/deserialization ipdl generated
structures are meant to facilitate serialization/deserialization and message passing.
... do not use them as data
structures outside of ipdl, or wou will eventually find yourself in bad situations to implement proper memory management.
IPDL Tutorial
tructs can be created and used like so: namevaluepair entry(astring, anotherstring); foo(entry.name(), entry.value()); // named accessor functions return references to the members arrays ipdl has simple syntax for arrays: invokemethod(nscstring[] args); in c++ this is translated into a nstarray reference: virtual bool recvinvokemethod(nstarray<nscstring>& args); ipdl's generated data
structures can be used in several protocols if they are defined in a separate .ipdlh file.
...to use the
structures defined in foo.ipdlh, include it as follows.
Localization content best practices
create localizable strings don't assume grammar
structures you need to consider the need for different grammar
structures in different locales, and add switching mechanisms to present them appropriately.
... you shouldn't make assumptions as to what those
structures will be: instead, let locales/localizers decide.
Mozilla Framework Based on Templates (MFBT)
the mozilla framework based on templates ("mfbt") is the central repository for macros, functions, and data
structures used throughout mozilla code, including in the javascript engine.
...(an unnamed temporary lives for a shorter period of time than the scope where it's found, so it usually isn't what was desired.) data
structures linkedlist.h implements a type-safe doubly-linked list class.
Mozilla Style System
the barrier between these two halves consists of three abstract interfaces, plus some smaller
structures associated with some methods on each: nsistylesheet nsistylesheet represents what one would think of as a style sheet: the in-memory representation of a css file or other source of style data.
... rule tree style data computation css style sheet backend loading parsing data
structures cascading html mapped attribute backend css style attribute backend handling of dynamic changes see also mozilla style system documentation (2002) style system tech talk (2002) ...
I/O Types
this chapter describes the most common nspr types, enumerations, and
structures used with the functions described in i/o functions and network addresses.
...each layer is represented by a prfiledesc structure, and the prfiledesc
structures for the layers are chained together.
PR_AcceptRead
this buffer must be large enough to receive amount bytes of data and two prnetaddr
structures (thus allowing the runtime to align the addresses as needed).
...does not include the size of the prnetaddr
structures.
PR_Poll
syntax #include <prio.h> print32 pr_poll( prpolldesc *pds, printn npds, printervaltime timeout); parameters the function has the following parameters: pds a pointer to the first element of an array of prpolldesc
structures.
... returns the function returns one of these values: if successful, the function returns a positive number indicating the number of prpolldesc
structures in pds that have events.
PR_Writev
iov an array of priovec
structures that describe the buffers to write from.
... size number of priovec
structures in the iov array.
NSS 3.15.5 release notes
notable changes in nss 3.15.5 bug 950129: improve the ocsp fetching policy when verifying ocsp responses bug 949060: validate the iov input argument (an array of priovec
structures) of ssl_writev (called via pr_writev).
... applications should still take care when converting struct iov to priovec because the iov_len members of the two
structures have different types (size_t vs.
OLD SSL Reference
and the default security databases setting up the certificate and key databases setting up the ca db and certificate setting up the server db and certificate setting up the client db and certificate verifying the server and client certificates building nss programs chapter 3 selected ssl types and
structures this chapter describes some of the most important types and
structures used with the functions described in the rest of this document, and how to manage the memory used for them.
... types and
structures certcertdbhandle certcertificate pk11slotinfo secitem seckeyprivatekey secstatus managing secitem memory secitem_freeitem secitem_zfreeitem chapter 4 ssl functions this chapter describes the core ssl functions.
sslfnc.html
ssl makes and keeps internal copies (or increments the reference counts, as appropriate) of certificate and key
structures.
... ssl makes and keeps internal copies (or increments the reference counts, as appropriate) of certificate and key
structures.
GC Rooting Guide
in this case, separate
structures must be created for the stack and the heap.
... general classes/
structures for a regular struct or class, tracing must be triggered manually.
Garbage collection
principal data
structures cell a cell is the unit of memory that is allocated and collected by the gc, as used externally.
... gc/heap.h defines chunk, chunkinfo, chunkbitmap, arena, arenaheader, cell, and freespan
structures that define the heart of the gc heap's
structures.
JSTraceOp
it must not change state of the object or corresponding native
structures.
...in that case the embedding can check if the traversal is a part of the marking phase through calling js_isgcmarkingtracer and apply a special code like emptying caches or marking its native
structures.
JS_THREADSAFE
sharing native functions and private data among threads in a js_threadsafe build, spidermonkey's internal data
structures that represent javascript values are single-thread-only.
... however, spidermonkey does not protect the application's data
structures.
Web Replay
replaying processes preserve all the same js behavior, dom
structures, graphical updates, and most other behaviors that occurred while recording.
... as with the devtools js code, this debugger lives in the middleman process, and instead of wrapping things from another compartment the debug objects hold heap
structures with information about some thing in the child process.
Mork
the file is a collection of top-level
structures, of which there exists four: dictionaries, tables, rows, and groups (changesets).
... dictionaries, tables, and rows all have corresponding meta
structures.
StructType
structtype represents c
structures.
...see opaque
structures for further explanation and an example.
Migrating from Firebug - Firefox Developer Tools
view json and xml
structures to view json and xml responses of ajax requests, firebug has special tabs when expanding the request within the console panel.
... the devtools web console shows those
structures directly under the "response" tab.
Using HTML sections and outlines - Developer guides
semantic sectioning elements clarify the larger-scale
structures within a document.
...by contrast, the <nav> sectioning element more clearly describes to browsers and other devices the content contained: links or other navigational
structures to help users move through and understand where they are in a site's or page's content.
Grammar and types - JavaScript
const my_array = ['html','css']; my_array.push('javascript'); console.log(my_array); //logs ['html','css','javascript']; data
structures and types data types the latest ecmascript standard defines eight data types: seven data types that are primitives: boolean.
...(this is similar to string interpolation features in perl, python, and more.) optionally, a tag can be added to allow the string construction to be customized, avoiding injection attacks, or constructing higher-level data
structures from string contents.
JavaScript typed arrays - JavaScript
working with complex data
structures by combining a single buffer with multiple views of different types, starting at different offsets into the buffer, you can interact with data objects containing multiple data types.
... this lets you, for example, interact with complex data
structures from webgl, data files, or c
structures you need to use while using js-ctypes.
Authoring MathML - MathML
html becomes verbose when your document contains advanced
structures like lists or tables but fortunately there are many generators from simple notations, wysiwyg editors and other content management systems to help writing web pages.
... mathematical notations are even more complex with
structures like fractions, square roots or matrices that are likely to require their own tags.
Web Components
this has traditionally not been so easy for custom markup
structures — think of the complex html (and associated style and script) you've sometimes had to write to render custom ui controls, and how using them multiple times can turn your page into a mess if you are not careful.
... html templates <template> contains an html fragment that is not rendered when a containing document is initially loaded, but can be displayed at runtime using javascript, mainly used as the basis of custom element
structures.
package.json - Archive of obsolete content
others, such as lib, permissions, and preferences, represent instructions to the jpm tool itself to generate and include particular code and data
structures in your add-on.
Enhanced Extension Installation - Archive of obsolete content
needs-install, needs-upgrade, needs-uninstall, needs-enable, needs-disable, needs-install when the extension manager starts, this dataset is read into two data
structures: the startup cache - a hashtable keyed off install location name and then guid, each entry having persistentdescriptor, mtime and id properties.
Style System Overview - Archive of obsolete content
text-align: right; text-indent: 0; } cssstyleruleimpl cssstyleruleimpl ↓ ↓ ↓ ↓ h1 nscssdeclaration h2 ↙ ↘ nscsscolor — color: green nscsstext — text-align: right text-indent: 0 css style rule representation problem: the rule
structures use too much memory (a few hundred kilobytes for all our chrome), and require large numbers of allocations to construct.
RDF Query Syntax - Archive of obsolete content
internally, this isn't quite true; the builder actually maintains only one copy of the similar data but uses data
structures in such a way which make it appear as if it were duplicated.
Tree View Details - Archive of obsolete content
first we'll define two
structures to hold the data for the tree, the first will hold a map between parents and the children they contain, and the second will hold an array of the visible items.
XML - Archive of obsolete content
gecko reads xul and makes interfaces just as our specially created memo is nothing but text unless there is an application for making use of the structure in some way, so too our xul widgets are just marked-up text unless there is software to interpret the
structures and render the xul as actual widgets.
NPP_Destroy - Archive of obsolete content
to ensure that the browser does not crash or leak memory when the saved data is discarded, npsaveddata's buf field should be a flat structure (a simple structure with no allocated sub
structures) allocated with npn_memalloc.
E4X for templating - Archive of obsolete content
with the above), e4x content using such functions can also be easily serialized inline (and then perhaps converted to the dom) as needed: var list = <>{_if(elems.length(), function () <> <markup/> <markup/> </>)}</>.toxmlstring(); iterating functions such as the following foreach (which can work with arrays, objects, or e4x objects) are quite convenient in iterating over complex
structures such as e4x would not normally allow.
Implementation Status - Archive of obsolete content
026; 9.3.2 nested repeats supported 9.3.3 repeat processing partial we currently obey the 1.0 rules for repeat 9.3.4 user interface interaction partial we currently obey the 1.0 rules for repeat, no support for @number 302026; 9.3.5 creating repeating
structures via attributes partial does not work for html:tr, html:td, or xf:group elements 340515; 350617; 9.3.6 itemset supported performance problem with large itemsets 372197; 9.3.7 copy supported 10.
Index - MDN Web Docs Glossary: Definitions of Web-related terms
an object can be immutable for various reasons, for example: 229 index glossary, index, mdn meta, navigation found 528 pages: 230 indexeddb api, codingscripting, database, glossary, sql indexeddb is a web api for storing large data
structures within browsers and indexing them for high-performance searching.
Symbol - MDN Web Docs Glossary: Definitions of Web-related terms
the method symbol.for(tokenstring) returns a symbol value from the registry, and symbol.keyfor(symbolvalue) returns a token string from the registry; each is the other's inverse, so the following is true: symbol.keyfor(symbol.for("tokenstring")) === "tokenstring" // true learn more general knowledge symbol (programming) on wikipedia javascript data types and data
structures symbols in ecmascript 6 symbol in the mdn js reference object.getownpropertysymbols() ...
Accessible multimedia - Learn web development
multimedia and accessibility so far in this module we have looked at a variety of content and what needs to be done to ensure its accessibility, ranging from simple text content to data tables, images, native controls such as form elements and buttons, and even more complex markup
structures (with wai-aria attributes).
What is accessibility? - Learn web development
our advice is to familiarize yourself with the basic areas in which you need to take care, as well as understanding the high-level
structures of the guidelines that are most relevant to you.
Use HTML to solve common problems - Learn web development
it's one of the most complex html
structures, and mastering it is not easy: how to create a data table how to make html tables accessible data representation how to represent numeric and code values with html — see superscript and subscript, and representing computer code.
HTML text fundamentals - Learn web development
you just need to bear in mind a few best practices as you create such
structures: preferably, you should use a single <h1> per page—this is the top level heading, and all others sit below this in the hierarchy.
React interactivity: Editing, filtering, conditional rendering - Learn web development
lassname="btn"> edit <span classname="visually-hidden">{props.name}</span> </button> <button type="button" classname="btn btn__danger" onclick={() => props.deletetask(props.id)} > delete <span classname="visually-hidden">{props.name}</span> </button> </div> </div> ); we've now got the two different template
structures — "edit" and "view" — defined inside two separate constants.
Introducing a complete toolchain - Learn web development
tools used in our toolchain in this article we're going to use the following tools and features: jsx, a react-related set of syntax extensions that allow you to do things like defining component
structures inside javascript.
Adding a new CSS property
the data
structures in gecko that store the computed value must correspond to this concept, or inheritance won't work as described by the specification.
Experimental features in Firefox
nightly 55 no developer edition 55 no beta 55 no release 55 no preference name dom.payments.request.enabled and dom.payments.request.supportedregions basic card api extends the payment request api with dictionaries that define data
structures describing card payment types and payment responses.
HTML parser threading
mtokenizermutex protects most data
structures on nshtml5streamparser from concurrent access.
HTTP Cache
a particular app cache version in a group) in hands, this storage will provide read and write access to entries in that application cache; when the app cache is not specified, this storage will operate over all existing app caches the service also provides methods to clear the whole disk and memory cache content or purge any intermediate memory
structures: clear – after it returns, all entries are no longer accessible through the cache apis; the method is fast to execute and non-blocking in any way; the actual erase happens in background purgefrommemory – removes (schedules to remove) any intermediate cache data held in memory for faster access (more about the intermediate cache below) nsiloadcontextinfo ...
IPDL Type Serialization
most
structures can be serialized in this manner: struct examplestruct { int i; nscstring j; int k[4]; }; namespace ipc { template <> struct paramtraits<examplestruct> { typedef examplestruct paramtype; static void write(message* amsg, const paramtype& aparam) { writeparam(amsg, aparam.i); writeparam(amsg, aparam.j); for (int i = 0; i < 4; ++i) writeparam(amsg, aparam.k[i]); }...
Following the Android Toasts Tutorial from a JNI Perspective
ast!'; var text = 'hello toast!'; // int duration = toast.length_short; var duration = toast.length_short; // toast toast = toast.maketext(context, text, duration); var toast = toast.maketext(context, text, duration); // toast.show(); toast.show(); } finally { if (my_jenv) { jni.unloadclasses(my_jenv); } } references oracle :: jni types and data
structures and determine the signature of a method - these articles are crucial because it tells us how to create our jni signatures.
WebRequest.jsm
it also documents two data
structures that vary from one event to another: the opt_extrainfospec argument to addlistener() the properties of the argument passed to the listener.
About NSPR
to that end it is possible to perform translations of ascii strings (dns names) into nspr's network address
structures, with no regard to whether the addressing technology is ipv4 or ipv6.
Hash Tables
this chapter describes the hash table functions in the plds (portable library — data
structures) library of nspr.
Network Addresses
to facilitate the transition to ipv6, it is recommended that clients treat all
structures containing network addresses as transparent objects and use the functions documented here to manipulate the information.
PRAddrInfo
a structure containing an array of prnetaddr
structures.
PRCList
it can be used as the anchor of a list and can be embedded in data
structures that are maintained in a linked list.
PRFileDesc
for more details about the use of prfiledesc and related
structures, see file descriptor types.
PRFileType
type for enumerators used in the type field of the prfileinfo and prfileinfo64
structures.
PRNetAddr
prnetaddr is binary-compatible with the socket address
structures in the familiar berkeley socket interface, although this fact should not be relied upon.
PRPackedBool
syntax #include <prtypes.h> typedef pruint8 prpackedbool; description use prpackedbool within
structures.
PR_Sleep
if you have already created such
structures, it is more efficient to use them directly.
NSS 3.19.2.3 release notes
security fixes in nss 3.19.2.3 bug 1245528 / cve-2016-1950 - fixed a heap-based buffer overflow related to the parsing of certain asn.1
structures.
NSS 3.21.1 release notes
security fixes in nss 3.21.1 bug 1245528 / cve-2016-1950 - fixed a heap-based buffer overflow related to the parsing of certain asn.1
structures.
NSS 3.22.2 release notes
security fixes in nss 3.22.2 bug 1245528 / cve-2016-1950 - fixed a heap-based buffer overflow related to the parsing of certain asn.1
structures.
NSS 3.23 release notes
the following ca certificate had the email trust bit turned on cn = actalis authentication root ca sha-256 fingerprint: 55:92:60:84:ec:96:3a:64:b9:6e:2a:be:01:ce:0b:a8:6a:64:fb:fe:bc:c7:aa:b5:af:c1:55:b3:7f:d7:60:66 security fixes in nss 3.23 bug 1245528 / cve-2016-1950 - fixed a heap-based buffer overflow related to the parsing of certain asn.1
structures.
NSS 3.28.3 release notes
that size increase caused crashes or malfunctioning with applications that use that data structure directly, or indirectly through ecpublickey, ecprivatekey, nsslowkeypublickey, nsslowkeyprivatekey, or potentially other data
structures that reference ecparams.
NSS 3.29.1 release notes
that size increase caused crashes or malfunctioning with applications that use that data structure directly, or indirectly through ecpublickey, ecprivatekey, nsslowkeypublickey, nsslowkeyprivatekey, or potentially other data
structures that reference ecparams.
NSS 3.30 release notes
new functions in cert.h cert_compareava - performs a comparison of two certava
structures, and returns a seccomparison result.
nss tech note7
these data types should be used as if they were opaque
structures, that is, they should only be created by some nss functions and you always pass pointers to these data types to nss functions and never examine the members of these
structures.
PKCS #11 Module Specs
manufacturerid override the default manufactureid value for the module returned in the ck_info, ck_slot_info, and ck_token_info
structures with an internationalize string (utf8).
FC_Initialize
in addition to creating the internal data
structures, it performs the fips software integrity test and power-up self-tests.
NSS tools : ssltab
if you are intercepting an ssl connection, use this option so that the tool can detect and decode ssl
structures.
NSS tools : ssltap
if you are intercepting an ssl connection, use this option so that the tool can detect and decode ssl
structures.
troubleshoot.html
kernel data
structures may remain allocated for these connections for up to two minutes.
NSS reference
data types based on "selected ssl types and
structures" in the ssl reference.
sslcrt.html
description certificate and key
structures are shared objects.
sslkey.html
description certificate and key
structures are shared objects.
NSS Tools ssltap
if you are intercepting an ssl connection, use this option so that the tool can detect and decode ssl
structures.
NSS tools : ssltap
if you are intercepting an ssl connection, use this option so that the tool can detect and decode ssl
structures.
SpiderMonkey Internals: Thread Safety
in a js_threadsafe build, these operations are handled specially: access to jsruntime data
structures garbage collection accesses to jsruntime data
structures are serialized with a few mutexes.
JS::PersistentRooted
these roots can be used in heap-allocated data
structures, so they are not associated with any particular jscontext or stack.
JSFreeOp
these
structures wrap parameters that are passed to the finalizers removing most of explicit dependencies on jscontext in the finalization code.
JS_DefineConstDoubles
cds and cis are pointers to the first element of an array of jsconstdoublespec/jsconstintegerspec
structures.
JS_DefineProperties
ps is a pointer to the first element of an array of jspropertyspec
structures.
JS_GC
obsolete since jsapi 50 description js_gc performs garbage collection of js objects, strings and other internal data
structures that are no longer reachable in the specified context or runtime.
JS_NewRuntime
js_newruntime allocates memory for the jsruntime and initializes certain internal runtime
structures.
JSAPI reference
they have been removed in js 1.8.5, though js_enterlocalrootscope obsolete since javascript 1.8.5 js_leavelocalrootscope obsolete since javascript 1.8.5 js_leavelocalrootscopewithresult obsolete since javascript 1.8.5 js_forgetlocalroot obsolete since javascript 1.8.5 added in spidermonkey 1.8 if an object contains references to other gc things that are not stored in spidermonkey data
structures ("slots"), it must implement the jstraceop hook to enable the garbage collector to traverse those references.
Mozilla Projects
replaying processes preserve all the same js behavior, dom
structures, graphical updates, and most other behaviors that occurred while recording.
XPCOM array guide
when designing public interfaces, enumerators are the preferred mechanism for accessing these
structures because they hide the details of the implementation behind the interface.
nsIIOService
these are provided as a convenience to the programmer and in some cases to improve performance by eliminating intermediate data
structures and interfaces.
nsIThread
warning: calling nsithread.processnextevent allows network and ui events to run which can modify data
structures that your code isn't expecting to be modified during a synchronous method call.
nsIXFormsModelElement
rebuild() signals the xforms processor to rebuild any internal data
structures used to track computational dependencies within the given xforms model.
Reference Manual
prefer destruction to assignment prefer do_queryinterface to calling queryinterface iterating there is a very common idiom for iterating over data-
structures with normal pointers, e.g., // iterating with pointers to non-xpcom objects...
XPCOM
file and memory management, threads, basic data
structures (strings, arrays, variants), etc.
Index
34 mail and rdf mozilla mail exposes many of it's data
structures to rdf through a few datasources.
Mail and RDF
mozilla mail exposes many of it's data
structures to rdf through a few datasources.
Mail composition back end
const struct nsmsgattachmentdata *attachments, - subsequent attachments are provided as urls to load, described in the nsmsgattachmentdata
structures.
WebIDL bindings
the return value is guaranteed to not depend on the state of the js heap or other js engine data
structures, and is guaranteed to not change unless some function with [affects=everything] is executed.
Using COM from js-ctypes
types.unsigned_long; let long = ctypes.long; let lpvoid = ctypes.voidptr_t; let void = ctypes.void_t; let ulong = ctypes.unsigned_long; let ushort = ctypes.unsigned_short; let wchar = ctypes.jschar; // advanced types - based on simple types let hresult = long; let lpcwstr = wchar.ptr; // guess types - these just work i couldnt find a proper defintion for it let lpunknown = ctypes.voidptr_t; //
structures // simple
structures let guid = ctypes.structtype('guid', [ { 'data1': ulong }, { 'data2': ushort }, { 'data3': ushort }, { 'data4': byte.array(8) } ]); // advanced
structures let clsid = guid; let iid = guid; // super advanced
structures let refiid = iid.ptr; let refclsid = clsid.ptr; // vtables let ispvoicevtbl = ctypes.structtype('ispvoicevtbl'); let ispvoice = ctypes.structtype('is...
Examples
lightweight bridge for calling cocoa frameworks from javascript, js-macosx transparently handles definition of cocoa api, both c and objective-c, and provides automatic declarations for framework functions,
structures, constants and enumerations, as well as allows creating and subclassing cocoa classes.
Declaring and Using Callbacks
if you don't, the gc might collect the relevant data
structures, and the browser will crash when native code attempts to invoke your callback.
Declaring and Calling Functions
const asctime = lib.declare("asctime", ctypes.default_abi, ctypes.char.ptr, struct_tm.ptr); for a more complete version of this example (including the implementation of the struct_tm type), see the
structures example.
Using js-ctypes
these can be simple types or more complex types such as
structures.
CType
structtype these represent c
structures.
ctypes
so we look up on msdn what the tb_button
structures is (msdn :: tb_button structure) and it says it is: typedef struct { int ibitmap; int idcommand; byte fsstate; byte fsstyle; #ifdef _win64 byte breserved[6]; #else #if defined(_win32) byte breserved[2]; #endif #endif dword_ptr dwdata; int_ptr istring; } tbbutton, *ptbbutton, *lptbbutton; so now notice that if it's 64-bit process it's different t...
Mozilla
mozilla framework based on templates (mfbt) the mozilla framework based on templates ("mfbt") is the central repository for macros, functions, and data
structures used throughout mozilla code, including in the javascript engine.
Initialization and Destruction - Plugins
to ensure that the browser does not crash or leak memory when the saved data is discarded, the buf field should be a flat structure (a simple structure with no allocated sub
structures) allocated with npn_memalloc, as in this example: char* mydata = "here is some saved data.\n"; int32 mylength = strlen(mydata) + 1; *save = (npsaveddata*) npn_memalloc(sizeof(npsaveddata)); (*save)->len = mylength; (*save)->buf = (void*) npn_memalloc(mylength); strcpy((*save)->buf, mydata); if you allocate saved instance data in npp_destroy, be sure to allocate memory with this function, ...
Memory - Plugins
the browser may be able to deallocate nonessential memory
structures in response to a request.
Gecko Plugin API Reference - Plugins
tidentifier npn_identifierisstring npn_utf8fromidentifier npn_intfromidentifier npobject npn_createobject npn_retainobject npn_releaseobject npn_invoke npn_invokedefault npn_evaluate npn_getproperty npn_setproperty npn_removeproperty npn_hasproperty npn_hasmethod npn_setexception npclass
structures npanycallbackstruct npbyterange npembedprint npevent npfullprint npp np_port npprint npprintcallbackstruct nprect npregion npsaveddata npsetwindowcallbackstruct npstream npwindow constants error codes result codes plug-in version constants version feature constants external resources external projects and articles for plugin creation original document information ...
Introduction to DOM Inspector - Firefox Developer Tools
the dom inspector not only presents all this information about pages in a clear and structured way, it gives you way to find and update those
structures, and it's simple to access via shortcuts and menus already available in the mozilla browser.
WebXR performance guide - Web APIs
while an individual vector or matrix doesn't occupy an inordinate amount of memory, the sheer number of vectors and matrices and other
structures that are used to build each frame of a 3d scene means the memory management becomes a problem eventually if you keep allocating and de-allocating memory objects.
Introduction - Web APIs
however, it has several limitations, such as lack of programming
structures and ability to create complex layout models.
Using the group role - Accessibility
the group role is used to identify a set of user interface objects which, in contrast with a region, are not intended to be included in a table of contents or a page summary (such as the
structures that are dynamically created by a script or assistive technologies); a group should not be considered a major perceivable section on a page.
ARIA Test Cases - Accessibility
markup used: role="listbox", "option" (listitem should only be used with list, which is for static document
structures, could someone please make sure our examples follow this rule) aria-activedescendant notes: results: at firefox ie opera safari jaws 9 - - n/a n/a jaws 10 - - - - voiceover (leopard) n/a n/a - fail window-eyes - - - - nvda - n/a - - zoom (leopard) pass ...
ARIA: application role - Accessibility
any sort of special interpretation of html
structures and widgets should be suspended, and control should be completely handed over to the browser and web application to handle mouse, keyboard, or touch interaction.
:valid - CSS: Cascading Style Sheets
syntax :valid examples indicating valid and invalid form fields in this example, we use
structures like this, which include extra <span>s to generate content on; we'll use these to provide indicators of valid/invalid data: <div> <label for="fname">first name *: </label> <input id="fname" name="fname" type="text" required> <span></span> </div> to provide these indicators, we use the following css: input + span { position: relative; } input + span::before { position: absolute; ri...
Overview of events and handlers - Developer guides
browsers use as the registration method for the function which will handle those data
structures a method called addeventlistener which expects as arguments a string event type name and the handler function.
Constraint validation - Developer guides
not only do most countries allow an optional prefix with the country code (like d- in germany, f- in france or switzerland), but some countries have postal codes with only a fixed number of digits; others, like the uk, have more complex
structures, allowing letters at some specific positions.
Index - Developer guides
it adds metadata and private-use data
structures, including predefined fields allowing foundries and vendors to provide license information if desired.
The Web Open Font Format (WOFF) - Developer guides
it uses a compressed version of the same table-based sfnt structure used by truetype, opentype, and open font format, but adds metadata and private-use data
structures, including predefined fields allowing foundries and vendors to provide license information if desired.
itemscope - HTML: Hypertext Markup Language
itemprop[itemtype] aggregaterating [aggregaterating] itemprop ratingvalue 4.0 itemprop reviewcount 35 itemscope itemprop[itemtype] nutrition [nutritioninformation] itemprop servingsize 1 medium slice itemprop calories 250 cal itemprop fatcontent 12 g note: a handy tool for extracting microdata
structures from html is google's structured data testing tool.
itemtype - HTML: Hypertext Markup Language
price 119.99 itemprop pricevaliduntil 2020-11-05 itemprop itemcondition http://schema.org/usedcondition itemprop availability http://schema.org/instock itemscope itemprop[itemtype] seller [organization] http://schema.org/organization itemprop name executive objects note: a handy tool for extracting microdata
structures from html is google's structured data testing tool.
Microdata - HTML: Hypertext Markup Language
n (http://schema.org/gameapplication) itemscope itemprop[itemtype] aggregaterating [aggregaterating] itemprop ratingvalue 4.6 itemprop ratingcount 8864 itemscope itemprop[itemtype] offers [offer] itemprop price 1.00 itemprop pricecurrency usd result note: a handy tool for extracting microdata
structures from html is google's structured data testing tool.
Introduction - JavaScript
javascript contains a standard library of objects, such as array, date, and math, and a core set of language elements such as operators, control
structures, and statements.
JavaScript Guide - JavaScript
chapters this guide is divided into several chapters: introduction about this guide about javascript javascript and java ecmascript tools hello world grammar and types basic syntax & comments declarations variable scope variable hoisting data
structures and types literals control flow and error handling if...else switch try/catch/throw error objects loops and iteration for while do...while break/continue for..in for..of functions defining functions calling functions function scope closures arguments & parameters arrow functions expressions and operators assignment & comparisons ...
JSON.stringify() - JavaScript
w number(3), new string('false'), new boolean(false)]); // '[3,"false",false]' // string-keyed array elements are not enumerable and make no sense in json let a = ['foo', 'bar']; a['baz'] = 'quux'; // a: [ 0: 'foo', 1: 'bar', baz: 'quux' ] json.stringify(a); // '["foo","bar"]' json.stringify({ x: [10, undefined, function(){}, symbol('')] }); // '{"x":[10,null,null,null]}' // standard data
structures json.stringify([new set([1]), new map([[1, 2]]), new weakset([{a: 1}]), new weakmap([[{a: 1}, 2]])]); // '[{},{},{},{}]' // typedarray json.stringify([new int8array([1]), new int16array([1]), new int32array([1])]); // '[{"0":1},{"0":1},{"0":1}]' json.stringify([new uint8array([1]), new uint8clampedarray([1]), new uint16array([1]), new uint32array([1])]); // '[{"0":1},{"0":1},{"0":1},{"0":1}]' js...
WeakSet - JavaScript
use case: detecting circular references functions that call themselves recursively need a way of guarding against circular data
structures by tracking which objects have already been processed.
WebAssembly.Module.customSections() - JavaScript
(read high level structure for information on section
structures, and how normal sections ("known sections") and custom sections are distinguished.) this provides developers with a way to include custom data inside wasm modules for other purposes, for example the name custom section, which allows developers to provide names for all the functions and locals in the module (like "symbols" in a native build).
Lexical grammar - JavaScript
// 68719476735 0x123456789abcdefn // 81985529216486895 0b11101001010101010101n // 955733 note that legacy octal numbers with just a leading zero won't work for bigint: // 0755n // syntaxerror: invalid bigint syntax for octal bigint numbers, always use zero followed by the letter "o" (uppercase or lowercase): 0o755n for more information about bigint, see also javascript data
structures.
Optional chaining (?.) - JavaScript
for instance: let potentiallynullobj = null; let x = 0; let prop = potentiallynullobj?.[x++]; console.log(x); // 0 as x was not incremented stacking the optional chaining operator with nested
structures, it is possible to use optional chaining multiple times: let customer = { name: "carl", details: { age: 82, location: "paradise falls" // detailed address is unknown } }; let customercity = customer.details?.address?.city; // … this also works with optional chaining function call let duration = vacations.trip?.gettime?.(); combining with the nullish coalescing operator the nu...
try...catch - JavaScript
conditional catch-blocks you can create "conditional catch-blocks" by combining try...catch blocks with if...else if...else
structures, like this: try { myroutine(); // may throw three types of exceptions } catch (e) { if (e instanceof typeerror) { // statements to handle typeerror exceptions } else if (e instanceof rangeerror) { // statements to handle rangeerror exceptions } else if (e instanceof evalerror) { // statements to handle evalerror exceptions } else { // statements to handle any unspecifie...
JavaScript reference - JavaScript
arguments arrow functions default parameters rest parameters additional reference pages lexical grammar data types and data
structures strict mode deprecated features ...
JavaScript
javascript data
structures overview of available data
structures in javascript.
MathML documentation index - MathML
html becomes verbose when your document contains advanced
structures like lists or tables but fortunately there are many generators from simple notations, wysiwyg editors and other content management systems to help writing web pages.
Using templates and slots - Web Components
the truth about templates when you have to reuse the same markup
structures repeatedly on a web page, it makes sense to use some kind of a template rather than repeating the same structure over and over again.
Compiling an Existing C Module to WebAssembly - WebAssembly
webp to start off simple, expose webpgetencoderversion() from encode.h to javascript by writing a c file called webp.c: #include "emscripten.h" #include "src/webp/encode.h" emscripten_keepalive int version() { return webpgetencoderversion(); } this is a good simple program to test whether you can get the source code of libwebp to compile, as it doesn't require any parameters or complex data
structures to invoke this function.