This page lists names and abstracts of all patterns that are on external websites, listed alphabetically.
Click on the names to see more details.
From the article "Command is a behavioral pattern used to encapsulate actions in objects. This is highly useful when
you want to keep track of changes made to a model, for example in supporting multi-level 'do/undo.'"
From the pattern: "Wherever possible, define the format using existing standards, referencing their
elements by namespace rather than rolling your own. For example, add metadata to your metadata using
RDF and the Dublin Core extensions rather than inventing your own <author> and <description> tags.
Allows for independent evolution of markup by parties who know the business domain best."
From the pattern: "This pattern contains XML untyped by DTD or schema, but follows accessors for underlying
program objects. It allows for unlimited extension by multiple, uncoordinated parties at the cost of lack
of type-checking; and is simple to implement, with supporting libraries abounding
(e.g. Apache Commons for Java; .NET's XML marshalling for C#)."
From the pattern: "adds outsourcing to the process of generating an
HTML page from an XML document and XSL stylesheet. With a model that transforms
XML data while keeping it completely separated from the processing instructions, External
Assistant solves the problem of how to add external computation.
Here XML data on one side and the instructions in the XSL stylesheet on the other
feed a transformation process that generates output in the form of an HTML file. In this
context, External Assistant explains how to call an external process whose results are
incorporated to the output, always keeping high modularity and clear distinction of the
responsibilities of each component."
From the article "Flyweight is a structural pattern used to support a large number of small objects
efficiently. Several instances of an object may share some properties: Flyweight factors these common properties
into a single object, thus saving considerable space and time otherwise consumed by the creation and maintenance
of duplicate instances."
From the pattern: "The Footnote Pattern is used when running text refers to an external note or annotation
that is displayed in a separate flow and linked by a symbol such as a number."
From the pattern: "The Generated Text Pattern is used when text must be rendered but is not itself included
in the XML document. The markup must support the generation of the correct text at the correct place,
and may allow the text to be supplied in the document in order to override the automatic generation algorithm."
From the pattern: "solves the problem of grouping and presenting
XML data in an HTML page. Any opaque application running on any platform can to
provide XML input. An XSL stylesheet then takes this and generates HTML. This process
resembles what SQL's Group By does on database tables."
From the article: "Iterator is a behavioral pattern used to access the elements of an aggregate sequentially,
without exposing the aggregate's underlying representation. It is particularly useful when you want to
encapsulate special logic for the traversal of a structure like a DOM tree."
From the article: "The Marker Attribute Pattern is used when certain elements need to be marked via an
attribute so they can be processed in a different way by a style sheet/program that recognizes the mark."
From the pattern: "Define an explicit mechanism for splitting content into multiple files: a primary
document and satellite ones that represent faster changing components or sections of content shared
with other primary documents."
From the pattern: "The Running Text Pattern is used for general textual content that may contain markup
at the phrase, word or symbol level but not at the block level."
From the pattern: "Include as part of the document format elements that annotate the content."
From the pattern: "The Text Blocks Pattern is used for contexts that stand alone, and normally contain
Running Text. Examples include paragraphs, headings and lists; a list contains list items and not
usually Running Text directly, but it stands alone, with a clear break before and after.
Text Blocks are normally themselves contained in Container elements such as Chapter, Section, ListItem, and so forth."
From the article: "Wrapper is a structural pattern used to allow an existing piece of software to
interact in an environment different from its originally intended one. Wrapper is very similar to the famous
Adapter pattern. The difference between the patterns is not predominantly structural, but rather in their
intentions: Adapter seeks to make an existing object work with other known objects that expect something,
while Wrapper is focused on providing a different interface (without knowing in advance its clients) and solving
The XML-Acceptor pattern describes sending distributed messages via an XML string. Sending a all messages as
a single string allows for the interface of the service to remain the same even if the contents of the
XML In Out Tray
From the pattern: "solves the problem of getting, processing and
showing data. In this pattern, XML holds the place of the in and out trays that a worker uses
to receive petitions. This pattern solves the problem of getting and giving data from and to
applications where the internal processes are hidden."
From the pattern: "a pattern that solves the problem of transferring
data between foreign applications by automatically collecting data from those applications
on behalf of a working client collector. It uses a process that collects XML data from data
providers. This process takes the different feeds and builds a compilation of the data in an
XML document, even when foreign applications run on different platforms. Through this
pattern, a thin client receives distributed information that it requires. Furthermore, the
process of collecting information is transparent to the user (usually a person at a browser,
but potentially an automated process) except when he declares what data he requires."
From the article: "The XMLable pattern defines a solution to managing information that is persisted as
XML data, but must also be managed as meaningful objects (i.e., not as a general data structure such as the DOM)
inside an application."