Quelltext der Seite MediaWiki:Classengine-content-documentation-methods

=== Constructor ===
{{ombox|type=delete|text='''Warning''' When you instantiate an object from another object, you have to supply the ''superhandler''. Otherwise you might get categorized or defaultsorted!}}

{{ombox|type=delete|text='''Warning''' If you want to be able to use [[#initMyself(uid)|initMyself()]], then you have to submit the correct uid-value here. 
The method must be able to identify itself by this value!}}

==== new(uid, superhandler) ====
Creates a new Object for the class.
;uid
:variable, suggested
:used to identify the object. defaults to mw.title.getCurrentTitle().prefixedText
;superhandler
:object of childclass of Foundationclass, optional
:supply the superhandler, if you instanciate an object within another object. the instanciated object will pass errors and warnings to the superhandler and forgo adding an object category
;return
:object, of the class

{{Hidden begin
|header=<h3>Abstract Methods</h3>
}}
{{clear}}
{{ombox|type=content|text=<p>'''Warning''' You have to implement (thus overwriting) the following abstract methods in your childclass, otherwise the execution of most of your methods will fail!
<p>'''Take note:''' [[#FoundationClass:mySfDynamicFieldAttribute(fieldname, attribute, value)|FoundationClass:mySfDynamicFieldAttribute(fieldname, attribute, value)]] is a ''static'' method, the rest must be declared ''public''!}}

==== myArgumentProcessing(coreData) ====
Performs the individual argument processing in [[#initFromArgs(args)|initFromArgs(args)]] right before inititializing it.
{{small|
;coreData
:table, mandatory
:the core data of the object. the one to process individually before initialization
;return
:table, the new core data array to be used
}}

==== myDataAdjustments(data) ====
Performs a transformation form data (coming from the datastore) into data used for argument processing. This is called by [[#initFromData(data)|initFromData(data)]] (for smw: after property to parameter conversion)
and is directly passed to [[#initFromArgs(args)|initFromArgs(args)]] and subsequently plausibility test.
{{small|
;data
:table, mandatory
:a data table coming directly from the data store
;return
:table, the new data table suiteable for argument processing
}}

==== myPlausibilityTest(args) ====
Performs the individual plausibility tests in [[#initFromArgs(args)|initFromArgs(args)]] before entering the initialization part.
NOTE: The return value will be ignored. If this finds errors, it must add them to the list of errors via [[#addError(errortext)|addError(errortext)]].
{{small|
;args
:table, mandatory
:arguments passed to the template to be checked
;return
:boolean, whether the object is plausible or not.
}}

==== myStashAdjustments(stash, storeType) ====
Can adjusts the stash in [[#storeData()|storeData()]] right before storing it.
{{small|
;stash
:table, mandatory
:the array of data to be saved (in the form fieldname: value)
;storeType
:string, mandatory
:type of storage method used with the current call (either 'cargo' or 'swm'). In case you use both stores and your stash adjustment differs with each of this methods
;return
:table, the new stash
}}

==== FoundationClass:mySfDynamicFieldAttribute(fieldname, attribute, value) ====
For some semantic form fields there are attribute values, that are not static, thus can not be provided at forehand in the [[#Configuration Data|configuration file]].
This method does the trick to adapt them at runtime shortly before the field is rendered. Essentially: the method checks, if it has a special rule for the pair
fieldname:attribute and if so, calculates the new value. if not, the old value is returned. Note, that you can completely disable a form field with this when you 
return false on attribute "disable".
{{small|
;fieldname
:string, mandatory
:the form field's name, needed to match current paring to an existing special treatment rule
;attribute
:string, mandatory
:the form field's attribute, needed to match current paring to an existing special treatment rule
;value
:variable, mandatory
:the value, that is already provided in the [[#Configuration Data|configuration file]]. this will be adapted by the method, if there is a special rule for the pair fieldname:attribute.
;return
:string, the value to be used forthwith (which can be the old one or a freshly calculated)
}}
{{Hidden end}}

{{Hidden begin
|header=<h3>Public methods</h3>
}}
==== addCategory(category) ====
Prepares to add the page to category ''category''. Note: until you actually call [[#render()|render()]] or [[#renderCategories()|renderCategories()]], this will not be implemented
{{small|
;category
:string, mandatory
:the name of the category, to add the page to
;return
:boolean, true
}}

==== addError(errortext) ====
adds errortext as new error to the list of errors, rendered at a later time.
{{small|
;errortext
:string, mandatory
:text added to list of errors
;return
:boolean, whether adding was successful or not
}}

==== addInfobox() ====
If no errors and data is present, adds an infobox to the object's output.
NOTE: This is a shell method and should be overwritten!
{{small|
;return
:boolean, whether adding was successful or not
}}

==== addOutput(content) ====
Adds something to the page's output. Something can be of type string, int, or table (that needs to have __tostring() implemented)
{{small|
;content
:string, int, or table; mandatory
:content element that is added to page's output
;return
:boolean, whether adding was successful or not
}}

==== addPageBody() ====
Adds a page body (all content besides the infobox) to the object's output: Errors and Warnings, sample configuration, statistics, ... Of course, only if there is data.
NOTE: This is a shell method and should be overwritten!
{{small|
;return
:boolean, whether adding was successful or not
}}

==== addWarning(warning) ====
adds warning as new warning to the list of warnings, to be rendered at a later time (with [[#renderWarnings()|renderWarnings()]]).
{{small|
;warning
:string, mandatory
:text added to list of warnings
;return
:boolean, whether adding was successful or not
}}

==== getCoreData() ====
Returns the table of coreData
{{small|
;return
:table, the value for _private[self].coreData, emtpy if not initialized
}}

==== getUid() ====
Returns the object's uid, nil if not set
{{small|
;return
:variable, the value for _private[self].uid
}}

==== goodToGo() ====
Is this a proper object (with data and no errors)
{{small|
;return
:boolean, whether we are proper initialized
}}

==== initFromArgs(args) ====
Initializes the object with a data table, containing arguments (template parameter). Does plausibility tests and mangling of input and either fills list of errors or adds input to the object's data.
{{small|
;args
:table, mandatory
:array of input data in the form <code>{ paramname = argumentdata }</code>
;return
:boolean, whether initialization was successful or not
}}

==== initFromData(data) ====
Initializes the object with a data table, coming from the datastore. Depending on datastore, that means that the table keys might be different than when using arguments form the template.
Does plausibility tests and mangling of input and either fills list of errors or adds input to the object's data.
{{small|
;data
:table, mandatory
:array of input data in the form <code>{ fieldname = argumentdata }</code>
;return
:boolean, whether initialization was successful or not
}}

==== initMyself(uid) ====
Initializes the object with data from the data store. The method queries for the object's uid in the container defined by Foundationclass.globalConfig.uidFieldName
(can be set to an infividual name in Module:Foundationclass/globalconfig) in either the class's table (in case of datastore cargo) or for objects that have
Foundationclass.globalConfig.smwClassProperty set to class.name (in case of datastore smw). The uid was either passed to the method (priority) or submitted to the constructor.
Does NOT do plausibility tests and mangling of input but assumes the data comes directly from the data store and thus can be trusted (i.e. passes _plausibilityTest())
{{small|
;uid
:string, optional
:the data, the object can use to identify itself. This field can be omitted, in which case the uid that was submitted to the constructor will be used.
;return
:boolean, whether initialization was successful or not
}}

==== render() ====
Renders the object's output
{{small|
;return
:string, the textual representation of the object (which can vary, depending on what add*-methods you called before)
}}

==== renderCategories() ====
Renders the object's categories (if any), thus adding them to the output stream and in turn sorting the page in it, <strong>if and only if</strong> render() is called on the object's page (when self:getUid == {{PAGENAME}}).
{{small|
;return
:object of type mw.html, the wikitext necessary to add the page to the categories
}}

==== renderErrors() ====
Renders the object's errors (if any)
{{small|
;return
:object of type mw.html, the representation of the list of errors
}}

==== renderWarnings() ====
Renders the object's warnings (if any)
{{small|
;return
:object of type mw.html, the representation of the list of warnings
}}

==== setSortkey(sortkey) ====
Sets a default sortkey for this page using the magic word DEFAULTSORT. Only applies, if no superhandler is given.
{{small|
;sortkey
:string, mandatory
:new sortkey for this page
;return
:void
}}

==== setUid(value) ====
Sets my uid to the given value. normally this should be set by constructor
{{small|
;value
:string/integer, mandatory
:new valued for my uid
;return
:boolean, true/false
}}

==== storeData() ====
If this was initialized with outside data and there are no errors, stores the arguments in an appropriate data store (smw or cargo).
In case of cargo, also calls the necessary #cargo_declare parser function if in the template namespace.
{{small|
;return
:boolean, whether store was successful or not
}}
{{Hidden end}}

{{Hidden begin
|header=<h3>Static methods</h3>
}}
==== FoundationClass:categorize() ====
Placed on one to class's pages (usually not on the class object pages), this calculates the necessary (meta-) category, to put the page in, using pagetitle, subpagetitle, namespace, and so on. Your project's categories (defined in [[Module:Foundationclass/globalconfig]]) are used.
{{small|
;return
:string, to be put on page, so that it will be categorized
}}

==== FoundationClass:categoryPage() ====
Procudes the output for our corresponding category page. Including the message box and the display of the data structure.
{{small|
;return
:object of type mw.html, the representation of the category page's content
}}

==== FoundationClass:cargoGenerateTableStructure() ====
Produces a cargo table declaration array (fieldname => declaration of field) that can be used in method [[#storeData()|storeData()]] for cargo_declare.
{{small|
;return
:table, data structure for cargo table
}}

==== FoundationClass:explainDataStore() ====
Produces a textual explanation of the used datastructure (table definition for cargo or property list and types for smw) that can be printed on various dodumentation pages
{{small|
;return
:string, a textual explanation
}}

==== FoundationClass:formRedlink(target, form, linktext, queryString) ====
Takes a pagename (''target'') and a formname (''form'') and then generates a link to that page if the page exists. Otherwise it links to the form to create the page. Linktext is target per default, if you do not provide ''linktext''
{{small|
;target
:string, mandatory
:the pagename (including namespace) to link to
;form
:string, mandatory
:the name of the form (w/o the form namespace!!) to fallback to, if page does not exist
;linktext
:string, optional
:text you want to display instead of ''target''
;queryString
:string, optional
:the query string provided to the form, e.g. {{code snippet|lang=lua|code='Template[page]=' .. mw.title.getCurrentTitle().prefixedText}}
;return
:string, the requested link
}}

==== FoundationClass:gardeningCategoryPage() ====
Procudes the output for the class' gardening category page (if any). Includung the message boxes.
{{small|
;return
:object of type mw.html, the representation of the gardening category page's content
}}

==== FoundationClass:mwLink(object) ====
Takes ''object'' and links it (adding square brackets). If object is a table, it iterates over it with lua's ''mw.text.listToText()''
{{small|
;object
:mixed
:object to return as linked string(s)
;return
:string, with all elements of ''object'' mw-linked
}}

==== FoundationClass:placeInNamespace(pagename, namespace) ====
Makes sure, that (string) ''pagename'' resides in (string) ''namespace''. Returns the pagename w/ new namespace and w/o any namespace
{{small|
;pagename
:string
:name of page to be prepended with new namespace
;namespace
:string
:new namespace for page
;return
:string, full page name in new namespace
:string, base page name without any namespace
}}

==== FoundationClass:sfGenerateForm() ====
Generates all output necessary for a form, that can be used to create or maintain an object of this class.
Note: this output is to be put inside the &lt;includeonly&gt;-tag on the Form page.
{{small|
;return
:object of class mw.html, the representation of the form
}}

==== FoundationClass:sfGenerateFormEntry() ====
Generates the "teaser" text shown on the form page when accessing it to create a form (before you type in the name in the input field)
{{small|
;return
:object of class mw.html, the representation of the form teaser
}}

==== FoundationClass:sfGenerateFormInfoTag() ====
Generates a form's info-tag, together with create and edit title and - if applicable - the query string (in case we have createLinkType formlink).
{{small|
;return
:string, a semantic form info tag
}}

==== FoundationClass:sfGenerateFormLink(params) ====
Generates a form input field or a form link that links to the class's form (essentially calls the parser function #forminput or #formlink respectively).
{{small|
;params
:table, data to pass to the form link/input generator. supported fields are: ''label'' and ''query string''
;return
:string, the input field, that lints to the form
}}

==== FoundationClass:sfGenerateFormTable(fieldlist) ====
Generates a table that can be used in a form inside the {{((}}{for template}{{))}} tag. The table contains all fields, that are named in the table
parameter ''fieldlist'' (which defaults to _CFG.form.fieldOrder) and that are present in _CFG.parameter..
All fields with attribute hidden are placed after the closing /table-tag
{{small|
;fieldlist
:table, optional
:contains a list of fieldnames, to be processed and added to the return node.
;return
:object of class mw.html, the representation of the formtable
}}

==== FoundationClass:sfInitField(fieldname) ====
Creates a field object of Class SFfield and initializes it per myConfiguration.parameters[fieldname] if entry is present
{{small|
;fieldname
:string, mandatory
:contains the name of the field to initialize
;return
:object of Class SFfield, the initialized field object. nil if fieldname is not present in parameter-array
}}

==== FoundationClass:smwGetProperty2ParameterTranslationTable() ====
Returns a translation table property-name => parametername, if data store smw is used.
{{small|
;return
:table, for every property used in the class the corresponding parameter name
}}

==== FoundationClass:templateDocumentation() ====
Generates almost all the output, necessary to have a good documentation page for the corresponding template. Only missing the
{{((}}[[:Template:documentation subpage|documentation subpage]]{{))}} call at the top and the includeonly part at the bottom.
{{small|
;return
:object of class mw.html, the representation of the template documentation
}}

==== FoundationClass:usesDataStore(store) ====
Returs true, if class uses store as datastore. Available stores are 'cargo' and 'smw'
{{small|
;store
:string, mandatory
:store type to check against
;return
:bool, whether store ''store'' is used as data store
}}
{{Hidden end}}