Uses of Interface
org.inria.ns.reflex.structures.Presentable

Packages that use Presentable
org.inria.ns.reflex.modules.io Provides I/O features. 
org.inria.ns.reflex.modules.rdbms Provides RDBMS features. 
org.inria.ns.reflex.modules.web Provides Web features. 
org.inria.ns.reflex.processor.asl The Active Schema Language implementation. 
org.inria.ns.reflex.processor.asl.types Provides type support for ASL. 
org.inria.ns.reflex.processor.catalog The Active Catalog implementation. 
org.inria.ns.reflex.processor.core The implementation of the core module ; provides also basic classes used by actions. 
org.inria.ns.reflex.processor.exp The Extensible XML Processor implementation. 
org.inria.ns.reflex.processor.xcl The XML Control Language implementation. 
org.inria.ns.reflex.processor.xcl.xml Actions related to XML content. 
org.inria.ns.reflex.util.wunit Module for WUnit testing. 
org.inria.ns.reflex.xml Core XML features. 
 

Uses of Presentable in org.inria.ns.reflex.modules.io
 

Classes in org.inria.ns.reflex.modules.io that implement Presentable
 class CloseAction
          At runtime, the <io:close> element, closes the file specified by the stream attribute.
 class CopyAction
          At runtime, the <io:copy> element, copies the file, directory, or input specified by the source attribute, in the file, directory or output specified by the dest attribute.
 class CreateDirAction
          At runtime, the <io:create-dir> element creates a directory whose name is specified in the uri attribute.
 class DeleteAction
          At runtime, the <io:delete> element, deletes the file or directory specified in the uri attribute.
 class FileAction
          At runtime, the <io:file> element represent a file specified by the uri attribute.
 class OpenAction
          At runtime, the <io:open> element opens the file specified by the uri attribute, in the mode specified by the mode attribute.
 class ReadAction
          At runtime, the <io:read> element, reads datas in the input stream specified by the input attribute.
 class RenameAction
          At runtime, the <io:rename> element, renames the file or the directory specified by the source attribute, to the name specified by the new-name attribute.
 class RequestAction
          <io:request> is an action that submit requests to an XML Native Database.
 class SaveAction
          At runtime, the <io:save> element, saves the content specified by the content attribute, in the file specified by the file attribute.
 class WriteAction
          At runtime, the <io:write> element, writes the content specified by the content attribute, in the stream specified by the output attribute.
 

Uses of Presentable in org.inria.ns.reflex.modules.rdbms
 

Classes in org.inria.ns.reflex.modules.rdbms that implement Presentable
 class CommitAction
          At runtime, the <rdbms:commit> element validates transactions done using the connection specified by the connection attribute.
 class ConnectAction
          At runtime, the <rdbms:connect> element opens a connection with the database.
 class DisconnectAction
          At runtime, <rdbms:disconnect> element closes the connection with the database.
 class QueryAction
          QueryAction
 class RollbackAction
          At runtime, the <rdbms:rollback> element cancels operations done during the transaction.
 class SelectAction
          At runtime, the <rdbms:select> element perform a SQL SELECT statement.
 class UpdateAction
          At runtime, the <rdbms:update> element perform an SQL INSERT, UPDATE or DELETE statement.
 

Uses of Presentable in org.inria.ns.reflex.modules.web
 

Classes in org.inria.ns.reflex.modules.web that implement Presentable
 class ClearAction
          The <web:clear> element clears any data that exists in the buffer and eventually the status code and headers.
 class CookieAction
          The <web:cookie> element creates a new #web:x-cookie item and stores it in the current context.
 class FlushAction
          The <web:flush> element forces any content in the buffer to be written to the client.
 class InvokeAction
          The <web:invoke> element is used for invoking another service.
 class MappingAction
          The <web:mapping> element defines mapping between URLs and procedures.
 class ServiceAction
          The <web:service> element is the root element of an Active Sheet XML document that handles HTTP requests.
 

Uses of Presentable in org.inria.ns.reflex.processor.asl
 

Classes in org.inria.ns.reflex.processor.asl that implement Presentable
 class AbstractPrimitiveModelAction
          At runtime, the AbstractPrimitiveModelAction defines a selection list.
 class AbstractStepAction
          An abstract representation common to most ASL elements.
 class ActiveSchemaAction
          The <asl:active-shema> element is the root element of an Active Shema.
 class AssertAction
          The <asl:assert> element defines an assertion.
 class AttributeAction
          At runtime, the <asl:attribute> element defines or refer to an attribute.
static class AttributeAction.NameRef
          Refers to an attribute by its name.
static class AttributeAction.NamespaceRef
          Refers to an attribute set by its namespace URI.
 class AttributeDefinitionAction
          At runtime, the <asl:attribute> element with its name attribute defines an attribute.
 class BlockAction
          The <asl:block> element defines an identifiable block.
 class ChoiceAction
          The <asl:choice> defines a choice list.
 class ContainerStepAction
          The <asl:step> element defines a step.
 class ElementAction
          The <asl:element> element refers to an element.
static class ElementAction.NameRef
          Refers to an element by its name.
static class ElementAction.NamespaceRef
          Refers to an element by its namespace URI.
 class ElementDefinitionAction
          The <asl:element> element defines an element.
 class InterimStepAction
          An interim step has two facets : this STEP action, and a context-feeder (the InterimStepAction.InterimAction inner class).
 class InterimStepAction.InterimAction
          An interim step has two facets : this context-feeder, and a STEP action (the InterimStepAction outer class).
 class ParseSchemaAction
          The <asl:parse-schema> element.
 class SequenceAction
          The <asl:sequence> element defines a sequence.
 class TextAction
          At runtime, the <asl:text> element defines a text value, refers to a text type, or matches a pattern.
static class TextAction.InlineType
          Defines a text action that refers to a data type which is defined inline.
static class TextAction.Pattern
          Defines a text action that matches a pattern.
static class TextAction.TypeNameRef
          Defines a text action that refers to a data type by its name.
static class TextAction.Value
          Defines a text action that matches a value.
 class UseAction
          The <asl:use> element indicates to use an identifiable element.
 class ValidateAction
          The <asl:validate> element validates an XML document or an XML element.
 

Uses of Presentable in org.inria.ns.reflex.processor.asl.types
 

Classes in org.inria.ns.reflex.processor.asl.types that implement Presentable
 class TypeAction
          TypeAction defines a data type exposed with the <asl:type> element.
 

Uses of Presentable in org.inria.ns.reflex.processor.catalog
 

Classes in org.inria.ns.reflex.processor.catalog that implement Presentable
 class AbstractIdentifierAction
          A support to match a URI, a system ID, a public ID, or even a qualified name ; also deal with selectors.
 class CatalogAction
          The <oasis:catalog> and <cat:catalog> elements are the root elements of an Oasis Catalog or an Active Catalog.
 class GroupAction
          At runtime, the <cat:group> element wraps a set of actions.
 class NextCatalogAction
          The <cat:next-catalog> action.
 class PublicAction
          At runtime, the <cat:public> element is used to test if an identifier matches a public identifier.
 class ResourceAction
          At runtime, the <cat:resource> element is used to test if an identifier matches a resource identifier.
 class SystemAction
          At runtime, the <cat:system> element is used to test if an identifier matches a system identifier.
 class URIAction
          At runtime, the <cat:uri> element is used to test if an identifier matches an URI.
 

Uses of Presentable in org.inria.ns.reflex.processor.core
 

Classes in org.inria.ns.reflex.processor.core that implement Presentable
 class AbstractAction
          Base support for all active tags.
static class AbstractAction.UselessAction
          An action that does nothing except trying to reorganize the set of actions that is depending from.
 class AbstractFeedAction
          An action that produces a data that feeds the current context.
 class AbstractSetAction
          Provides basic infrastructure for actions that will set a property to the data set at runtime.
 class LiteralElementAction
          A LiteralElementAction is an XML element which appears as is in an Active Sheet (and which is not active) ; each of its attributes can be an expression evaluated at runtime.
 class LiteralTextAction
          A LiteralTextAction is an XML text inside an Active Sheet that is evaluated at runtime to produce an XML text or other objects.
 class LogicAction
          This class defines a named logic procedure.
 class MainAction
          A convenient action object used as the main logic procedure.
 class NoAction
          At runtime, the NoAction does nothing.
 

Uses of Presentable in org.inria.ns.reflex.processor.exp
 

Classes in org.inria.ns.reflex.processor.exp that implement Presentable
 class AbstractDefinitionAction
          The parent class for all active material, that provides convenient methods.
static class ElementAction.Macro
          A macro element action.
static class ElementAction.Predefined
          A predefined element action.
 class ExportAction
          The <exp:export> element adds a parameter to the current parameter context.
 class ExportsAction
          The <exp:exports> element is a simple container for <exp:export> elements.
 class ExtendedFunctionAction
          The <exp:function> element populates a module with the definition of an XPath function.
static class ExtendedFunctionAction.Macro
          A macro function action.
static class ExtendedFunctionAction.Predefined
          A predefined function action.
 class ForeignAttributeAction
          The <exp:attribute> element populates a module with a foreign attribute definition.
 class InactiveTagsAction
          At runtime, the InactiveTagsAction does nothing.
 class InitAction
          The <exp:init> element is a simple container for <exp:element> elements.
static class InvokeAction.Async
          An asynchrone invoker.
 class MacroAction
          At runtime, the MacroAction defines an element backed by an inline implementation.
 class MacroInvokerAction
          The MacroInvokerAction can initialize and terminate a macro by exporting the expected return values.
 class ModuleAction
          The <exp:module> element creates a module definition.
 class PredefinedPropertyAction
          The <exp:property> element populates a module with a predefined property definition.
static class PredefinedPropertyAction.Macro
          A macro property action.
static class PredefinedPropertyAction.Predefined
          A predefined property action.
 class UnmarshalAction
          The <exp:unmarshal> element parses an Active Sheet to a compiled #exp:x-processor-instance.
 

Uses of Presentable in org.inria.ns.reflex.processor.xcl
 

Classes in org.inria.ns.reflex.processor.xcl that implement Presentable
 class AbstractFilterAction
          Allow to define XML filters.
 class ActiveSheetAction
          The <xcl:active-sheet> element is the root element of an Active Sheet XML document.
 class AlternativeAction
          This class represent the <xcl:then>, <xcl:else>, <xcl:when>, and <xcl:otherwise> elements.
 class ApplyRulesAction
          The <xcl:apply-rules> element indicates to apply the rules on the children of the current node after forwarding it.
 class BreakAction
          The <xcl:break> element exits from the current iteration (LoopAction or ForEachAction).
 class CallAction
          The <xcl:call> element calls a logic procedure.
 class ChooseAction
          The <xcl:choose> element selects one among a number of possible alternatives.
 class ComplexOperationAction
          At runtime, a complex operation is performed or registered if it is deferred.
 class ContinueAction
          The <xcl:continue> element continue the execution at the beginning of the current iteration (LoopAction or ForEachAction).
 class EchoAction
          The <xcl:echo> element prints a string to the standard output.
 class ExitAction
          The <xcl:exit> element exits from the current procedure.
 class FallbackAction
          The <xcl:fallback> element recovers its parent action when it fails to run.
 class FilterAction
          A <xcl:filter> element filters XML input with rules (XPath patterns).
 class ForEachAction
          At runtime, the <xcl:for-each> element processes the execution of dependant actions for each item of the collection given by the select attribute.
 class ForwardAction
          When filtering, the <xcl:forward> element indicates to forward the node that matches to the next step (that can be a filter).
 class IfAction
          The <xcl:if> element selects one alternative depending on the evaluation given by the expression specified in the test attribute.
 class KeepAction
          The <xcl:keep> element keeps a property after calling a logic procedure.
 class LoopAction
          At runtime, the <xcl:loop> element repeat the execution of dependant actions while the expression given by the test attribute is true.
 class NopAction
          The <xcl:nop> element does nothing
 class OperationsAction
          At runtime, the <xcl:operations> element set the boundaries of a group of operations to perform on X-operable objects, such as XML documents.
static class OperationsAction.Deferred
          A deferred update action doesn't perform updates immediatly, but registers them.
 class ParseAction
          The <xcl:parse> element parses the XML data source specified in the source attribute.
 class ParseFilterAction
          The <xcl:parse-filter> element parses the external filter specified in the source attribute.
 class ParseHTMLAction
          The <xcl:parse-html> element parses the HTML data source specified in the source attribute ; after parsing the HTML is exposed as a well-formed XML document (DOM or SAX).
 class ParseStylesheetAction
          The <xcl:parse-stylesheet> element parses the XSLT stylesheet specified in the source attribute to a reusable Templates object.
 class ParseTypeAction
          The <xcl:parse-type> element parses the data specified in the value attribute to a TypedData object.
 class RuleAction
          The <xcl:rule> element defines a pattern or a regular expression on behalf of a filter.
 class RuleSetAction
          A RuleSetAction is made with a union pattern that can be splitted in independant rules.
 class SetAction
          The <xcl:set> element adds a new property to the data set, or replace the property of the data set that have the same name if any.
 class SetItemAction
          The <xcl:item> element adds a value to a multi-valuated property defined on a nested element.
 class SetParameterAction
          The <xcl:param> element adds a parameter to the current parameter context.
 class SimpleOperationAction
          At runtime, a simple operation is performed or registered if it is deferred.
 class SleepAction
          The <xcl:sleep> action pause the current thread during a given time.
 class TransformAction
          The primary usage of the <xcl:transform> element is to perform an XSLT transformation to the document specified in the source attribute, with the stylesheet specified in the stylesheet attribute.
 

Uses of Presentable in org.inria.ns.reflex.processor.xcl.xml
 

Classes in org.inria.ns.reflex.processor.xcl.xml that implement Presentable
 class SetXMLAttribute
          SetXMLAttribute sets an attribute to an X-operable object.
 class XMLAction
          This class is designed to produce XML objects when an XML action is encountered ; an XML object created is used to feed the current context.
 class XMLAttribute
          <xcl:attribute> is an action that creates an XML attribute used to feed the XML context.
 class XMLComment
          <xcl:comment> is an action that creates an XML comment used to feed the XML context.
 class XMLDocument
          <xcl:document> is an action that creates an XML document used to feed the XML context.
 class XMLElement
          <xcl:element> is an action that creates an XML element used to feed the XML context.
 class XMLNamespaceDeclaration
          <xcl:namespace-declaration> is an action that creates an XML namespace declaration used to feed the XML context.
 class XMLProcessingInstruction
          <xcl:processing-instruction> is an action that creates an XML processing instruction used to feed the XML context.
 class XMLText
          <xcl:text> is an action that creates an XML text used to feed the XML context.
 

Uses of Presentable in org.inria.ns.reflex.util.wunit
 

Classes in org.inria.ns.reflex.util.wunit that implement Presentable
 class ConversationAction
          A <wunit:conversation> between non-visual Web client and an HTTP server or eventually an emulated servlet container.
 class EventAction
          Fire an event : "click", "change", "focus", etc...
 class FillFormAction
          <wunit:fill-form> allow to fill a form in a frame.
 class HtmlAction
          Submit an action through an HTML element (link, button, form).
 class SubmitAction
          <wunit:submit> either a click or an HTTP request or a form to a servlet container.
 class UrlAction
          Submit an URL to the client.
 

Uses of Presentable in org.inria.ns.reflex.xml
 

Classes in org.inria.ns.reflex.xml that implement Presentable
 class CanonicalPath
          Represent the canonical path of a node.
 class QName
          A QName (qualified name) is an XML name built either with a prefix bound to a namespace URI and a local part, separated by a colon, or a non-colonned name that may be bound to a namespace URI.