@startuml

    namespace org.apache.wiki.ui {

        class WikiCommand [[WikiCommand.html]] {
            {static} +CREATE_GROUP: Command
            {static} +ERROR: Command
            {static} +FIND: Command
            {static} +INSTALL: Command
            {static} +LOGIN: Command
            {static} +LOGOUT: Command
            {static} +MESSAGE: Command
            {static} +PREFS: Command
            {static} +WORKFLOW: Command
            {static} +ADMIN: Command
            +targetedCommand(Object): Command
            +getName(): String
            +requiredPermission(): Permission
        }

        class DefaultCommandResolver [[DefaultCommandResolver.html]] {
            +DefaultCommandResolver(Engine, Properties)
            +findCommand(HttpServletRequest, String): Command
            +getFinalPageName(String): String
            +getSpecialPageReference(String): String
            #extractCommandFromPath(HttpServletRequest): Command
            +extractPageFromParameter(String, HttpServletRequest): String
            +resolvePage(HttpServletRequest, String): WikiPage
            #simplePageExists(String): boolean
        }

        interface GenericHTTPHandler [[GenericHTTPHandler.html]] {
            {abstract} +getId(): String
            {abstract} +doGet(WikiContext): String
            {abstract} +doPost(WikiContext): String
        }

        interface CommandResolver [[CommandResolver.html]] {
            {static} +PROP_SPECIALPAGE: String
            {static} +findCommand(String): Command
            {abstract} +findCommand(HttpServletRequest, String): Command
            {abstract} +getFinalPageName(String): String
            {abstract} +getSpecialPageReference(String): String
            {abstract} +extractPageFromParameter(String, HttpServletRequest): String
            {abstract} +resolvePage(HttpServletRequest, String): WikiPage
        }

        class RedirectCommand [[RedirectCommand.html]] {
            {static} +REDIRECT: Command
            +targetedCommand(Object): Command
            +getName(): String
            +requiredPermission(): Permission
        }

        class WikiJSPFilter [[WikiJSPFilter.html]] {
            +init(FilterConfig): void
            +doFilter(ServletRequest, ServletResponse, FilterChain): void
            #fireEvent(int, String): void
        }

        interface TemplateManager [[TemplateManager.html]] {
            {static} +SKIN_DIRECTORY: String
            {static} +RESOURCE_JSFUNCTION: String
            {static} +RESOURCE_JSLOCALIZEDSTRINGS: String
            {static} +RESOURCE_STYLESHEET: String
            {static} +RESOURCE_SCRIPT: String
            {static} +RESOURCE_INLINECSS: String
            {static} +DIRECTORY: String
            {static} +DEFAULT_TEMPLATE: String
            {static} +PROPERTYFILE: String
            {static} +I18NRESOURCE_PREFIX: String
            {static} +I18NRESOURCE_SUFFIX: String
            {static} +I18NRESOURCE_EN: String
            {static} +I18NRESOURCE_EN_ID: String
            {static} +I18NDEFAULT_LOCALE: String
            {static} +I18NSERVER_TIMEZONE: String
            {static} +TIMEFORMATPROPERTIES: String
            {static} +RESOURCE_INCLUDES: String
            {static} +RESOURCE_HTTPHEADER: String
            +listLanguages(PageContext): Map<String, String>
            +listTimeZones(PageContext): Map<String, String>
            {static} +getMarker(WikiContext, String): String
            {static} +getJSLocalizedStrings(WikiContext): String
            {static} +addResourceRequest(WikiContext, String, String): void
            {static} +getResourceRequests(WikiContext, String): String[]
            {static} +getResourceTypes(WikiContext): String[]
            {abstract} +templateExists(String): boolean
            {abstract} +findJSP(PageContext, String): String
            {abstract} +findJSP(PageContext, String, String): String
            {abstract} +findResource(WikiContext, String, String): String
            {abstract} +listSkins(PageContext, String): Set<String>
            {abstract} +listTimeFormats(PageContext): Map<String, String>
        }

        class GroupCommand [[GroupCommand.html]] {
            {static} +DELETE_GROUP: Command
            {static} +EDIT_GROUP: Command
            {static} +VIEW_GROUP: Command
            +targetedCommand(Object): Command
            +getName(): String
            +requiredPermission(): Permission
        }

        class Installer [[Installer.html]] {
            {static} +ADMIN_ID: String
            {static} +ADMIN_NAME: String
            {static} +INSTALL_INFO: String
            {static} +INSTALL_ERROR: String
            {static} +INSTALL_WARNING: String
            {static} +APP_NAME: String
            {static} +STORAGE_DIR: String
            {static} +PAGE_DIR: String
            {static} +WORK_DIR: String
            {static} +ADMIN_GROUP: String
            {static} +PROPFILENAME: String
            {static} +TMP_DIR: String
            +Installer(HttpServletRequest, ServletConfig)
            +adminExists(): boolean
            +createAdministrator(): String
            +getPropertiesList(): String
            +getPropertiesPath(): String
            +getProperty(String): String
            +parseProperties(): void
            +saveProperties(): void
            +validateProperties(): boolean
        }

        class InputValidator [[InputValidator.html]] {
            {static} +STANDARD: int
            {static} +EMAIL: int
            {static} +ID: int
            {static} #EMAIL_PATTERN: Pattern
            {static} #UNSAFE_PATTERN: Pattern
            {static} #ID_PATTERN: Pattern
            +InputValidator(String, WikiContext)
            +validateNotNull(String, String): boolean
            +validateNotNull(String, String, int): boolean
            +validate(String, String, int): boolean
            {static} +isBlank(String): boolean
        }

        class Editor [[Editor.html]] {
            +Editor(WikiContext, String)
            +getName(): String
            +isSelected(): String
            +isSelected(String): String
            +isSelected(String, String): String
        }

        class PageCommand [[PageCommand.html]] {
            {static} +ATTACH: Command
            {static} +COMMENT: Command
            {static} +CONFLICT: Command
            {static} +DELETE: Command
            {static} +DIFF: Command
            {static} +EDIT: Command
            {static} +INFO: Command
            {static} +PREVIEW: Command
            {static} +RENAME: Command
            {static} +RSS: Command
            {static} +UPLOAD: Command
            {static} +VIEW: Command
            {static} +NONE: Command
            {static} +OTHER: Command
            +targetedCommand(Object): Command
            +getName(): String
            +requiredPermission(): Permission
        }

        interface EditorManager [[EditorManager.html]] {
            {static} +PROP_EDITORTYPE: String
            {static} +PARA_EDITOR: String
            {static} +EDITOR_PLAIN: String
            {static} +EDITOR_PREVIEW: String
            {static} +REQ_EDITEDTEXT: String
            {static} +ATTR_EDITEDTEXT: String
            {static} +getEditedText(PageContext): String
            {abstract} +initialize(Properties): void
            {abstract} +getEditorName(WikiContext): String
            {abstract} +getEditorList(): String[]
            {abstract} +getEditorPath(WikiContext): String
        }

        class DefaultEditorManager [[DefaultEditorManager.html]] {
            +DefaultEditorManager(Engine)
            +initialize(Properties): void
            +getEditorName(WikiContext): String
            +getEditorList(): String[]
            +getEditorPath(WikiContext): String
            +modules(): Collection<WikiModuleInfo>
            +getModuleInfo(String): DefaultEditorManager.WikiEditorInfo
        }

        abstract class AbstractCommand [[AbstractCommand.html]] {
            #AbstractCommand(String, String, String, Object)
            {static} +allCommands(): Command[]
            +getContentTemplate(): String
            +getJSP(): String
            +getRequestContext(): String
            +getTarget(): Object
            +getURLPattern(): String
            #getJSPFriendlyName(): String
            {abstract} +targetedCommand(Object): Command
            {abstract} +getName(): String
        }

        class WikiServletFilter [[WikiServletFilter.html]] {
            #m_engine: Engine
            +init(FilterConfig): void
            +destroy(): void
            +doFilter(ServletRequest, ServletResponse, FilterChain): void
            #getWikiContext(ServletRequest): WikiContext
        }

        class DefaultTemplateManager [[DefaultTemplateManager.html]] {
            +DefaultTemplateManager(Engine, Properties)
            +templateExists(String): boolean
            +findJSP(PageContext, String): String
            +findJSP(PageContext, String, String): String
            +findResource(WikiContext, String, String): String
            +listSkins(PageContext, String): Set<String>
            +listTimeFormats(PageContext): Map<String, String>
            +modules(): Collection<WikiModuleInfo>
            +getModuleInfo(String): WikiModuleInfo
        }

        class WikiRequestWrapper [[WikiRequestWrapper.html]] {
            +WikiRequestWrapper(Engine, HttpServletRequest)
            +getRemoteUser(): String
            +getUserPrincipal(): Principal
            +isUserInRole(String): boolean
        }

        interface Command [[Command.html]] {
            {abstract} +targetedCommand(Object): Command
            {abstract} +getContentTemplate(): String
            {abstract} +getJSP(): String
            {abstract} +getName(): String
            {abstract} +getRequestContext(): String
            {abstract} +requiredPermission(): Permission
            {abstract} +getTarget(): Object
            {abstract} +getURLPattern(): String
        }

        AbstractCommand <|-- WikiCommand

        CommandResolver <|.. DefaultCommandResolver

        AbstractCommand <|-- RedirectCommand

        WikiServletFilter <|-- WikiJSPFilter

        interface org.apache.wiki.modules.ModuleManager {
            {abstract} +checkCompatibility(WikiModuleInfo): boolean
            {abstract} +getModuleInfo(String): WikiModuleInfo
            {abstract} +modules(): Collection<WikiModuleInfo>
        }
        org.apache.wiki.modules.ModuleManager <|.. TemplateManager

        AbstractCommand <|-- GroupCommand

        AbstractCommand <|-- PageCommand

        org.apache.wiki.modules.ModuleManager <|.. EditorManager

        abstract class org.apache.wiki.modules.BaseModuleManager
        org.apache.wiki.modules.BaseModuleManager <|-- DefaultEditorManager

        EditorManager <|.. DefaultEditorManager

        Command <|.. AbstractCommand

        interface javax.servlet.Filter {
            {abstract} +init(FilterConfig): void
            {abstract} +doFilter(ServletRequest, ServletResponse, FilterChain): void
            {abstract} +destroy(): void
        }
        javax.servlet.Filter <|.. WikiServletFilter

        org.apache.wiki.modules.BaseModuleManager <|-- DefaultTemplateManager

        TemplateManager <|.. DefaultTemplateManager

        class javax.servlet.http.HttpServletRequestWrapper
        javax.servlet.http.HttpServletRequestWrapper <|-- WikiRequestWrapper

    }


    center footer UMLDoclet 1.1.4, PlantUML 1.2019.05
@enduml
