Modul:Foundationclass

Module documentation

This module is subject to page protection. It is a highly visible module in use by a very large number of pages, or is substituted very frequently. Because vandalism or mistakes would affect many pages, and even trivial editing might cause substantial load on the servers, it is protected from editing.

This module depends on the following other modules:

This is a Template for Class Modules. It implements a class in Lua using Module:Middleclass and provides serveral static and public methods, commonly used in the typical form>page>store process.

Usage

This is in a way an abstract class. It provides some static and public methods for resuse, and also maintains a store of private properties. If can be used to fast and easily create a typical class module that can handle:

creating an appropriate form
supplying your respective template with functionalities for
- object initialization via template parameters, arguments, and datastore (self initialization)
- general data assesment (basic plausibility tests)
- data storage (supported are cargo and semantic media wiki)
- error and warnings management
- output and rendering
creating a template documentation

You can and should adjust the module in this methods:

individual attribute adjustment for the semantic forms fields
individual plausibility testing
individual data initialization
individual data store adjustments before stashing

You can access the objects core data store with getCoreData() and its uid with getUid().

How-To

This is, what you have to do (see Useful templates for content of the corresponding pages):

create your base module Module:Name
create your class module Module:Name/class. For this, copy lua sample code below this list and apply the following changes:
1. change all occurences of className into your class name
2. change the highlighted lines and replace 'Name' with the Name of your module
3. implement the abstract methods:
  1. myAgumentProcessing(coreData)
  2. myDataAdjustments(data)
  3. myPlausibilityTest(args)
  4. myStashAdjustments(stash)
  5. static:mySfDynamicFieldAttribute(fieldname, attribute, value)
4. for the usual output generation, implement (shells given in sample code)
  1. addInfobox()
  2. addPageBody()
create and fill your configuration Module:Name/config
create your template Template:Name
create your form Form:Name
if applicable, create your category page Category:Name
fill in documentation:
1. of your base module (place one invoke below the first comment and before the includeonly)
2. of your class module (new docu for your own public, static and private methods (which you can probably copy from other classes) and one invoke to show the inheritance. Sample code provided in Useful templates
3. of your class module's configuration (just copy content)
4. of your template (one invoke below the first comment and before the includeonly)

Useful templates

base module:

local p = {}
local Class = require('Module:Name/class')
local getArgs = require('Module:Arguments').getArgs

function p.categorize(frame)
	return tostring(Class:categorize())
end

function p.categoryPage(frame)
	return tostring(Class:categoryPage())
end

function p.explainDataStore(frame)
	return tostring(Class:explainDataStore())
end

function p.gardeningCategoryPage(frame)
	return tostring(Class:gardeningCategoryPage())
end

function p.sfGenerateForm(frame)
	return tostring(Class:sfGenerateForm())
end

function p.sfGenerateFormEntry(frame)
	return tostring(Class:sfGenerateFormEntry())
end

function p.sfGenerateFormLink(frame)
	return tostring(Class:sfGenerateFormLink())
end

function p.templateDocumentation(frame)
	return tostring(Class:templateDocumentation())
end

function p.main(frame)
	local args = getArgs(frame)
	local me = Class:new(mw.title.getCurrentTitle().prefixedText)
	me:initFromArgs(args)
	me:storeData()
	me:addInfobox()
	me:addPageBody()
 	return me:render()
end

return p

base module's documentation page:

{{documentation subpage}}
{{module rating|protected}}{{lua|Module:Arguments|Module:Name/class}}
<!-- Categories go at the bottom of this page and interwikis go in Wikidata. -->

This module implements template {{tl|Name}}.

== Usage ==
{{pre|
{{tli|Name|''main''}}
}}

It also provides some additional "gateways" to some of [[Module:Name/class]]'s static methods:
{{pre|
{{tli|Name|''categorize''}}
{{tli|Name|''categoryPage''}}
{{tli|Name|''explainDataStore''}}
{{tli|Name|''gardeningCategoryPage''}}
{{tli|Name|''sfGenerateForm''}}
{{tli|Name|''sfGenerateFormEntry''}}
{{tli|Name|''sfGenerateFormLink''}}
{{tli|Name|''templateDocumentation''}}
}}

{{#invoke:Name|categorize}}<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||
<!-- Note: The class engine sets the category "CamNet modules" automatically in function categorize -->
<!-- Categories go here if you wish an additional category to that set in {{module rating}} above automatically. -->

}}</includeonly>

class module:

local FoundationClass = require('Module:Foundationclass')
local ClassDebug = require('Module:Debug/class')

-- ****************************************************************
-- *                         inheritance                          *
-- ****************************************************************
local ClassName = FoundationClass:subclass('Name')
-- setting class's configuration data
ClassName.static.myConfiguration = mw.loadData('Module:Name/config')	-- this means, modules on subpages have a / in their names
--   being in a static method, use self.myConfiguration
--   being in a private method, that knows self or in a public method, use self.class.myConfiguration

-- ****************************************************************
-- *                          properties                          *
-- ****************************************************************

-- **************** initialization of table for private properties
local _private = setmetatable({}, {__mode = 'k'})   -- weak table storing all private attributes

-- **************** declaration of public static properties
-- ClassName.static.myPropertyModule = require('Module:extern')
-- ClassName.static.staticProperty = ' '

-- remember the static classes provided by Foundationclass:
-- ClassName.globalConfig
-- ClassName.myCargoUtil
-- ClassName.mySmwUtil
-- ClassName.myTableTools
-- ClassName.myYesno

-- **************** declaration of (global) private properties
-- for properties you should rather use constructor and _private[self]. this only, if you need a private class property
-- you should, however predeclare private methods here
local _debug	-- private method declared later
local _privateMethodAhead	-- declaration ahead, so this private method can be used in the constructor and in other private methods

-- ***************************************************************
-- *                           methods                           *
-- ***************************************************************
 
-- **************** declaration of static methods
function ClassName:initialize(uid, superhandler)
	local _CFG = self.class.myConfiguration
	FoundationClass.initialize(self, uid, superhandler)
	_private[self] = {
		dbg = ClassDebug:new(tostring(self.class) .. ': id ' .. uid),
	}
	_debug(self, 1, ' ClassName: done initializing object "' .. uid ..'", from ' .. tostring(self))
end

-- use use self.myConfiguration to access your configuration in a static method
function ClassName.static:aStaticMethod(var)
	_debug(self, 1, 'entering ClassName.static:aStaticMethod() to do something, from ' .. tostring(self))
end

function ClassName.static:mySfDynamicFieldAttribute(fieldname, attribute, value)
	_debug(self, 1, 'entering ClassName.static:mySfDynamicFieldAttribute(fieldname, attribute, value), from ' .. tostring(self))
	_debug(self, 2, ' with parameters "' .. fieldname .. '", "' .. attribute .. '" and a ' .. type(value) .. ' value')
	-- function that can process any attribute/value pair just before rendering the semantic forms field
	-- usually done, to generate a dynamic 'default' value
	-- keep in mind: you can completely disable a form field, if you return true on attribute "disable".
	-- 	however, this causes the parameter to not show at all, neither in the form, nor in processing
	local val = value
	if fieldname == 'this' and attribute == 'that' then
		val = 'whatever ' .. val
	end
	return val	-- this value will be used as new value for field's attribute
end

-- **************** declaration of private methods
-- use self.class.myConfiguration to access your configuration in a public or a private method that is called by a public method
_debug = function (self, level, text)
	if _private[self] and _private[self].dbg then
		local debugLevel = FoundationClass.globalConfig.debugLevel or self.class.myConfiguration.global.debugLevel
		if debugLevel and level <= debugLevel then
			_private[self].dbg:log(level, text)
		end
	else
		local debugLevel = FoundationClass.globalConfig.debugLevel or self.myConfiguration.global.debugLevel
		if debugLevel and level <= debugLevel then
			ClassDebug:log(level, text, tostring(self) .. '.static')
		end
	end
end

local _privateMethod = function (self)
	_debug(self, 1, 'entering private _privateMethod() to do something, from ' .. tostring(self))
end

-- **************** declaration of public methods
-- use self.class.myConfiguration to access your configuration in a public method
function ClassName:addInfobox()
	_debug(self, 1, 'entering ClassName:addInfobox(), from ' .. tostring(self))
	if self:goodToGo() then
		local _CFG = self.class.myConfiguration
		local coreData = self:getCoreData()
		local ib_args = {
			bodyclass = 'infobox_name',
			aboveclass = 'objtitle titletext',
			headerclass = 'headertext',
			labelstyle = 'width: 30%;',
			datastyle = 'width: 70%;',
			title = self:getUid(),
            above = _CFG.global.entityTitle,
			subheader = nil,
			label1 = _CFG.parameter.name.label,
			data1 = coreData.name and coreData.name or nil,
			header1 = nil,
		}
		self:addOutput(require('Module:Infobox').infobox(ib_args))
		return true
	end
	return false
end

function ClassName:addPageBody()
	_debug(self, 1, 'entering ClassName:addPageBody(), from ' .. tostring(self))
	_debug(self, 2, ' rendering errors and warnings and adding them to output')
	local frame = mw.getCurrentFrame()
	self:addOutput(self:renderErrors())
	self:addOutput(self:renderWarnings())
	if self:goodToGo() then
		self:addOutput('No output yet')
		return true
	end
	return false
end

function ClassName:myArgumentProcessing(coreData)
	_debug(self, 1, 'entering ClassName:myArgumentProcessing(args) to process coreData, from ' .. tostring(self))
	-- function that performs some individual transformation args --> coreData
	-- remember: you can add warnings to your output with self:addWarning(warning). the page, however, will not be put in any gardening category. for that, use self:addError()
	-- hint: for conversion bool values, this is useful: FoundationClass.myYesno
	local coreData = coreData
	return coreData	-- this is your new coreData.
end

function ClassName:myDataAdjustments(data)
	_debug(self, 1, 'entering ClassName:myDataAdjustments(data) to convert data from data store into data suitable for argument processing, from ' .. tostring(self))
	-- function that performs some individual transformation datastore data into argument data
	-- keep in mind, when using smw data store, that data is indexed by parameter names, not properties
	-- hint: for conversion bool values, this is useful: FoundationClass.myYesno
	local data = data
	return data	-- this is your new data table, being passed on to initFromArgs and subsequently to plausibility testing
end

function ClassName:myPlausibilityTest(args)
	_debug(self, 1, 'entering ClassName:myPlausibilityTest(args) to test arguments, from ' .. tostring(self))
	-- function that performs the individual plausibility tests
	-- note: before you access a field args.fieldname you should check for existance
	-- use self:addError(text); this also puts the page in its class's gardening category
	return false	-- return value will be ignored. but if you add any error, the object's initialization will fail with the error
end

function ClassName:myStashAdjustments(stash, storeType)
	_debug(self, 1, 'entering ClassName:myStashAdjustments(stash) to do some minor adjustments on data before storing, from ' .. tostring(self))
	-- function that alters the stash before storing the data. if necessary, you can complate skip storing this stash, if you return false or the empty table {}
	-- storeType is the actual method of storage for this call. either 'cargo', or 'smw'
	-- hint: for conversion bool values, this is useful: FoundationClass.myYesno
	local stash = stash
	return stash	-- this is your new stash. this will be stored. it has format (fieldname: value)
end

function ClassName:method()
	_debug(self, 1, 'entering ClassName:method() to do something, from ' .. tostring(self))
	return true
end

return ClassName

class module's documentation page:

{{documentation subpage}}
{{module rating|protected}}{{lua|Module:Debug/class|Module:Foundationclass|Module:Name/config}}
<!-- Categories go at the bottom of this page and interwikis go in Wikidata. -->

This is a Class Module. It implements a class in Lua using [[Module:Middleclass]] and the template class [[Module:Foundationclass]]. This class provides methods for PURPOSE.

== Usage ==
{{code|lang=lua|code=
local name = args[1] or args.name or mw.title.getCurrentTitle().rootText
local Class = require('Module:Name/class')
local me = Class:new(mw.title.getCurrentTitle().prefixedText)
me:initFromArgs(args)
me:storeData()
me:addInfobox()
me:addPageBody()
return me:render()
}}

{{#invoke:Name|explainDataStore}}

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

=== public methods ===
==== addInfobox() ====
If no errors and data is present, adds an infobox to the object's output.
{{small|
;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.
{{small|
;return
:boolean, whether adding was successful or not
}}

==== 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) ====
Performs the 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
:boolean, the new stash
}}

=== static methods ===
==== ClassName: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)
}}

=== private methods ===
==== _debug(self, level, text) ====
Adds output to the internal debug log.
{{small|
;self
:object, me
;level
:int; mandatory
:debug level for the message
;text
:string; mandatory
:debug message text
;return
:void
}}

== Properties ==
=== static ===
See also [[#Static Properties|Static Properties]]
;ClassName.myConfiguration
:this is your configuration. It is devided in several section, each a
:table, holds configuration data found in Module:Name/config
::'''WARNING:''' This is a read only table and besides functions ''pairs()'' and ''ipairs()'' nothing else will work on it, especially not the functions of the table library!
<ul>
* form, table, holds data used to create the form. here are some of them:
** formButtons, table, which buttons should be printed at the bottom
** fieldOrder, table, in which order the form fields should appear (note: only fields listed here will be added to the form)
* global, table, holds some global configuration data
* parameter, table, holds all data about all parameter used in the module (be they form only, data store only or normal). The table has the form ''paramname = { table of paramdata }''. The tables for the parameter have data as follows:
** cardinality, string, mandatory, one of singe or list
** cargo_type, string, optional, if the parameter is to be stored in cargo, add the field type here (one of Page, Text, Integer, Float, Date, Datetime, Boolean (which should be provided as 1 or 0), Coordinates, Wikitext, File, String, URL, or Email)
** description, string, mandatory, a description of this parameter
** label, string, mandatory, the label used in the form and the template documentation
** property_name, string, optional, if the parameter is to be stored in smw, add the property name here
** property_type, string, optional, if the parameter is to be stored in smw, add the property type here (defaults to page)
** severity, string, optional, if provided one of mandatory, suggested
** sf, table, optional, used to add more attributes to the semantic forms field. ref [[Module:SFfield/config]] for all possible attributes. Note that the table is of type attribute_name : value. Value can be of type string, integer, boolean, and (in case of 'show on select') a table. Please note, that the attribute name cannot contain a " " (space). Use the underscore instead.
** td_default, string, optional, if you want a default value to be indicated in the template data section on the documentation page, add it here
** td_type, string, optional, if the parameter should be present in the template documentation page, fill this field. all possible values are listed [https://www.mediawiki.org/wiki/Extension:TemplateData#Format here]
** values, table, optional, if you want the possible values to be restricted to a specific set, fill this table
* template, table, holds some data used only in the template
</ul>
;ClassName.publicStaticProperty
:type, explanation
;_privateStaticProperty
:type, explanation

=== private ===
Note: all private properties are stored in table ''_private[self]''. _private is a static array that is indexed by ''self'', so the table ''_private[self]'' holds all properties for instance ''self''.
;dbg
:object, my instance of [[Module:Debug/class]] for debugging purposes. only present afer first call of [[#_debug(self, level, text)|_debug(self, level, text)]]

== Configuration Data ==
This class holds its control data in [[Module:{{ROOTPAGENAME}}/config]]. 

== Inheritance ==
'''Note:''' You still reference those either by self:publicMethod() or ClassName:staticMethod() and ClassName.staticProperty respectively!
=== Methods ===
{{MediaWiki:Classengine-content-documentation-methods}}
=== Static Properties ===
{{MediaWiki:Classengine-content-documentation-properties}}

{{#invoke:Name|categorize}}<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||
<!-- Note: the class engine sets the categories "CamNet modules" and "Lua class modules" automatically in categorize -->
<!-- Categories go here if you wish an additional category to that set in {{module rating}} above automatically. -->

}}</includeonly>

class configuration (sample file):

local superglobal = mw.loadData( 'Module:Foundationclass/globalconfig' )

local form = {
	enable = true, -- Do you want to create a form for this class? Note: When you don't want to have a form _page_, but need this to be a part of another form (as a holds-template form), set this to true!
	name = '',	-- The name of the form, i.e. the form will be placed an page [[Form:Formname]]. If you don't need an actual form page, leave this empty (e.g. if this is a prot of another form as holds-template or such).
	teaserText = '',	-- This is the text displayed on the form:name page (before you see the actual form))
	typeCreateLink = 'none',	-- This field lets you choose, what kind of object create link is provided to the user on the form page: is there none, a formlink, or a forminput field? possible values are: 'none' (default), 'forminput', 'formlink'
	createInfotext = '', -- This is the short text that appears right above the input field. Short being the important part. Please limit yourself to a short sentence.
	createInputPlaceholder = '',	-- Placeholder text that is shwon in the form create input field
	createInputQueryString = '',	-- You can use this option to pass information to the form; this information generally takes the form of ''templateName[fieldName]=value''. It should look like a typical URL query string; an example would be "query string=namespace=User&User[Is_employee]=yes".
	createLinkPageName = '',	-- With this, you can have the name of the page created by the form to be set automatically. You can use any of the parameters ''<template-name[field-name]>'' or ''<unique number>''. The latter takes options start=x, unique, random, and a number (length of id string, default 6).
		-- IMPORTANT: If you want to use the one step process with a createLinkPageName, you have to add the output if your class's sfGenerateFormInfoTag() in comments to your form page!!!
			-- this is a workaround for a semantic forms bug. see https://phabricator.wikimedia.org/T123230 for more information
	createLinkQueryString = '',	-- You can use this option to pass information to the form; this information generally takes the form of ''templateName[fieldName]=value''. It should look like a typical URL query string; an example would be "query string=namespace=User&User[Is_employee]=yes".
	createLinkType = 'plain', -- This field lets you choose, what kind of form link is used to link to the form page: is it a plain link or a button (with parameter submission via get or post), possible values are nil, 'plain', 'button', 'post button'
	labelCreate = '',	-- label for create entity
	labelEdit = '',	-- label for edit entity
	headerText = '',	-- this is the text displayed above the form
	notification = '',	-- this notification will be displayed above your form
	sectionList = {},	-- if you want to have hl2 sections of text after the datafields and before the freetext, name them here. Use strings for names of section headlines
	allowsFreeText = false,	-- will the form have a free text field?
	freeTextPreload = nil,	-- when this is set your free text will have a preload=<freeTextPreload> statement. of course only when allowsFreeText is set to true
	buttons = {'save', 'preview', 'changes', 'cancel'},	-- which buttons should appera below the form
	fieldSize = 80,	-- what is the default size= for the form fields
	textareaAttributes = {	-- the defaults for your textarea fields
		cols = 80,
		rows = 4,
		autogrow = true,
		editor = 'wikieditor',	-- other values would be false or 'none'...
	},
	fieldOrder = {
		-- the order in which the form fields appear. NOTE: a parameter not in this list, will not appear in the form!!
		-- YOU HAVE TO FILL THIS TABLE! Put in here all parameters, that are used in the form, even if you have your own sfGenerateForm() implemented using a different table.
		-- Reason: This is also be used in plausibility tests
		'',
	},
}

local global = {
	cargoTable = '',	-- if you use dataStore cargo, name the table here. if you do not name a table, no persistant cargo data will be stored for that class
	category = '',	-- the mediawiki category, the entity is placed into
	delimiter = ',',	-- see to it, that the delimiter is not a character, that will be encoded by mw.text.encode. CargoUtil.store encodes the data for security reasons
	description = '',	-- a short description of the entity. will be displayed on the template documentation page for example
	entityTitle = '',	-- generic title for the entity
	gardeningCategory = superglobal.gardeningCategory,	-- the category, objects with erroneous/inplausible data will be put into
	namespace = '',	-- if you put this entity on a special namespace, name it here. NOTE: You have to be precise. This is case sensitive. But omit the colon.
	smwIsSubobject = false, -- when using datastore smw: is this stored as subobject (and not as normal data)?
	smwUseStorage = true,	-- if you use dataStore smw, set this to true if you actually want persistant smw data to be stored for that class
}

local parameter = {
	-- this is your list of parameters. you put all data here, that you would like to handle
	--	* parameters of your form (and thus your template)
	--		* when you fill td_type, your parameter will be shown on the template documentation page
	--		* when you add the parameter name to form.fieldOrder, it will be added to the form and processed in plausibility tests
	--	* add also data, that you only want to store (omit these from form.fieldOrder and leave the sf table, probably best, to leave td_type unset, too).
	--  * hint: if you need a row in your table as information, add pseudo parameter w/o entry in fieldOrder, w/o sf table, w/o td_type, and w/o cargo/property entries
	name = {
		cardinality = 'single|list',
		cargo_hidden = false, -- takes no value. If set, the field is not listed in either Special:ViewTable or Special:Drilldown, although it is still queriable.
		cargo_size = nil, -- for fields of type "Text", sets the size of this field, i.e. the number of characters; default is 300
		cargo_type = '',
		description = '',
		label = '',
		property_name = '',	-- please use underscores (_) instead of spaces
		property_type = '', -- possible values are: Annotation URI, Boolean, Code, Date, Email, Number, Page (default), Quantity, Telephone Number, Temperature, Text, URL
		severity = 'mandatory|suggested',
		sf = {
			--	note: this list is incomplete. see [[Module:SFfield/config]] for a complete list of supported attributes
			--	note also: mandatory, list, property and values are derived form fields "above" this table
			--  IMPORTANT: If you want this to be a regular form parameter, you have to add this table. even, if you leave it empty.
			--  also: keep in mind that a parameter appears in the form only if you add its name to form.fieldOrder above
			cargo_field = '',
			cargo_table = '',
			class = '',
			default = '',
			default_filename = '',
			existing_values_only = true,
			hidden = true,
			image_preview = true,
			input_type = '',
			mapping_cargo_field = '',
			mapping_cargo_table = '',
			mapping_template = '',
			max_values = 0,
			maxlength = 0,
			placeholder = '',
			restricted = '',	-- e.g.: restricted = superglobal.restrictionRole,
			show_on_select = {}, -- takes either a string (in case of input type checkbox) or a table. table must be of format "selected value" : "field shown"
			size = 0,
			unique = true,
			unique_for_category = true,
			unique_for_namespace = true,
			uploadable = true,
			values_dependent_on = '',
			values_from_category = '',
			values_from_namespace = '',
		},
		td_default = '',
		td_type = '',
		values = {},
	},
}

local template = {
	name = 'nameOfYourTemplate',	-- the name of your template. e.g.: your template can be found on the page [[Template:nameOfYourTemplate]]
	templateDocumentationSeeAlso = {'List', 'of', 'similar', 'or', 'related', 'templates'}	-- used in the see also-section of your template documentation
}

return {
	form = form,
	global = global,
	parameter = parameter,
	template = template,
}

configuration documentation page:

{{documentation subpage}}
{{module rating|protected}}{{lua|Module:Foundationclass/globalconfig}}

<!-- Categories go at the bottom of this page and interwikis go in Wikidata. -->

This module provides data for [[Module:Name/class]]

== Usage ==

{{code|lang=lua|code=local cfg = mw.loadData('Module:Name/config')}}

{{#invoke:Name|categorize}}<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox||
<!-- Note: The class engine sets the categories "CamNet modules" and "Lua class modules" automatically in function categorize -->
<!-- Categories go here if you wish an additional category to that set in {{module rating}} above automatically. -->

}}</includeonly>

template:
{{#invoke:Name\|main\|{{BASEPAGENAME}}}}<noinclude> {{documentation}} </noinclude>

template documentation page:

{{Documentation subpage}}
<!-- Categories go at the bottom of this page. -->

{{#invoke:Name|templateDocumentation}}

{{#invoke:Name|categorize}}<includeonly>{{#ifeq:{{SUBPAGENAME}}|sandbox | |
<!-- Note: The class engine sets the category "CamNet templates" automatically in function categorize -->
<!-- ADD CATEGORIES AFTER THIS LINE -->

}}</includeonly>

form:

Note: If you have a display error on your form in a way that your fieldset and your label (the blue box) does not include your form but instead is displayed above it, add a line break before and after the #invoke-statement, having it stand alone in line.

<noinclude>{{#invoke:Name|sfGenerateFormEntry}}{{#invoke:Name|categorize}}</noinclude>
<includeonly>{{#invoke:Name|sfGenerateForm}}</includeonly>
<!-- Note: The class engine sets category "CamNet forms" automatically in function categorize -->

category:
{{#invoke:Name\|categoryPage}}{{#invoke:Name\|categorize}} <!-- Note: The class engine sets category "CamNet" automatically in function categorize -->

gardening category:
{{#invoke:Name\|gardeningCategoryPage}}{{#invoke:Name\|categorize}} <!-- Note: The class engine sets category "CamNet entities with erroneous input" automatically in function categorize -->

private, public, class or instance

Zugriffsmatrix

-

public

private

instance

function MyClass:publicMethod()
MyClass.publicProperty

local _privateMethod = function (self, var)
_private[self]._privateProperty

class

function MyClass.static:staticMethod()
MyClass.static.staticProperty
-- accessing
MyClass.staticProperty
-- being "outside":
MyClass:staticMethod()
-- being inside a static method
self:staticMethod()
-- being inside a public method
self.class:staticMethod()

local _privateMethod = function (self, var)
local _privateProperty

private

property

you can declare a property private in one of two ways:

anywhere, preferably before your constructor, declare a local var to have a private propery, this is not recommended, but it allows you to declare a private property, that can be used by your static methods. thus being somewhat private static
for your instances, you can use the table _private[self] as a private store. it is available after your construrctor has been called (since this is an instance attribute)

method

a private method is declared thus: local _privateMethod = function(self, var). If you want to use the method in an public/static/other private method before it is declared (aka: the calling method is on a lower line number than your private method's declaration), decare it ahead and define it later:

local _privateImportantMethod
..
privateImportantMethod = function(self, var)

private class and instance methods are basically the same.

public

property

can be dclared via class.property. DONT DO THIS. It is bad style!

method

Declare them class:publicMethod(var). They are, after all, public

NOTE: public methods can be called by an instance, but also as static method:

function Class:public()
	return 'public: ' .. tostring(self)
end

local me = Class:new()
me.public()	-- returns "public: Instance of class Class"
Class:public()	-- returns "public: class Class"

static

property

Declare a static property like this: class.static.myProperty = 'Hello World'. This produces a public property, that can be accessed by the class, childclasses or instances via *.myProperty (replace * with class, object, childclass, ...)

method

Much the same as static properties, but you should use the colon operator: function Class.static:staticMethod() when definig the method. On accessig this method, you should use the dot-notation: function Class.staticMethod(self)

NOTE: Other than public methods, they can only be called by the class, but not by an instance:

function Class.static:static()
	return 'static: ' .. tostring(self)
end

local me = Class:new()
me.static()	-- returns "error:  attempt to call method 'static' (a nil value)"
Class:static()	-- returns "static: class Class"
Class.static(self)	-- this is not called via colon (:) operator as to preserve the childClass's scope when inheriting from this class

Methods

Constructor

Warning When you instantiate an object from another object, you have to supply the superhandler. Otherwise you might get categorized or defaultsorted!

Warning If you want to be able to use 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

Abstract Methods

Warning You have to implement (thus overwriting) the following abstract methods in your childclass, otherwise the execution of most of your methods will fail!

Take note: 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) right before inititializing it.

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) (for smw: after property to parameter conversion) and is directly passed to initFromArgs(args) and subsequently plausibility test.

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) 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).

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() right before storing it.

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 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".

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 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)

Public methods

addCategory(category)

Prepares to add the page to category category. Note: until you actually call render() or renderCategories(), this will not be implemented

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.

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!

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)

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!

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()).

warning: string, mandatory; text added to list of warnings
return: boolean, whether adding was successful or not

getCoreData()

Returns the table of coreData

return: table, the value for _private[self].coreData, emtpy if not initialized

getUid()

Returns the object's uid, nil if not set

return: variable, the value for _private[self].uid

goodToGo()

Is this a proper object (with data and no errors)

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. {{{1}}}

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. {{{1}}}

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())

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

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, if and only if render() is called on the object's page (when self:getUid == Foundationclass).

return: object of type mw.html, the wikitext necessary to add the page to the categories

renderErrors()

Renders the object's errors (if any)

return: object of type mw.html, the representation of the list of errors

renderWarnings()

Renders the object's warnings (if any)

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.

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

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.

return: boolean, whether store was successful or not

Static methods

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.

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.

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() for cargo_declare.

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

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

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. '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.

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()

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

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 <includeonly>-tag on the Form page.

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)

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).

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).

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

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

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.

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 {{documentation subpage}} call at the top and the includeonly part at the bottom.

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'

store: string, mandatory; store type to check against
return: bool, whether store store is used as data store

private methods

These private Methods can not be used by child classes!

_amIPlausible(self)

Returs true or false, whether the object is plausible or not (i.e. has no errors or 1+)

self: object, me
return: boolean, whether the object is plausible or not

_debug(self, level, text)

Adds output to the internal debug log.

self: object, me
level: int; mandatory; debug level for the message
text: string; mandatory; debug message text
return: void

_plausibilityTest(self, args)

Checks, if input provided via template is plausible enough, to represent the object (to be stored and displayed). Also fills the list of errors and does some argument preparation.

self: object, me
args: table, mandatory; arguments passed to the template to be checked
return: boolean, whether the object is plausible or not

Properties

static

FoundationClass.globalConfig: table, holds some global configuration (data, that applies to all classes the same way). See Module:Foundationclass/globalconfig for details.
FoundationClass.myCargoUtil: table, instance of Module:CargoUtil
FoundationClass.mySwmUtil: table, instance of Module:SmwUtil
FoundationClass.myTableTools: table, instance of Module:TableTools
FoundationClass.myYesno: table, instance of Module:Yesno

private

Note: all private properties are stored in table _private[self]. _private is a static array that is indexed by self, so the table _private[self] holds all properties for instance self.

categories: table, holds the objects categories
coreData: table, holds the objects data ofter initializing
dbg: object, my instance of Module:Debug/class for debugging purposes
errors: table, a list of errors that occurred
fullpagename: string, name of currentpage including namespace
initialized: boolean, is this object properly initialized
loadedDataFromDataStore: boolean, did this object get its data from the data store
output: object of type mw.html, holds all output to be rendered()
pagename: string, name of current page (or current page's super page) w/o namespace
uid: string, uinique identifier ('NIL' if unset)
warnings: table, a list of warnings that came up

Configuration Data

This class holds gets its control data from the child class. Also, there is some global configuration data in Module:Foundationclass/globalconfig, that applies to all classes.

Dependencies

If you want to use Module:Foundationclass, you also need the following items (and their doc pages!):

Module:Middleclass
Module:Foundationclass/config
Module:Foundationclass/classDoc
Module:Foundationclass/globalconfig
Module:CargoUtil and Extension:Cargo if you want to use it as a data store
Module:SmwUtil and Extension:Semantic MediaWiki if you want to use it as a data store

also

and of course Extension:Semantic Forms

Also, have a look at the extended functionality of the Class engine.

Interface messages

To generate the Useful_templates, Foundationclass makes use of the following interface messages:

Next in dev queue

have foundation class try to detect integer inputs (by td_type or cargo_type) and run a regexp in _plausibilityTest
have foundationclass use mw message system for printouts instead of hardcoded text
a template or page, that #autogenerates all categories, defined in Module:Foundationclass/globalconfig

local Class = require('Module:Middleclass').class
local FoundationClass = Class('FoundationClass')
local ClassDebug = require('Module:Debug/class')
local ClassSFfield = require('Module:SFfield/class')

-- ****************************************************************
-- *                          properties                          *
-- ****************************************************************

-- **************** initialization of table for private properties
local _private = setmetatable({}, {__mode = "k"})   -- weak table, storing all private attributes

-- **************** declaration of static properties
FoundationClass.static.globalConfig = mw.loadData( 'Module:Foundationclass/globalconfig' )
FoundationClass.static.myCargoUtil = require('Module:CargoUtil')
FoundationClass.static.mySmwUtil = require('Module:SmwUtil')
FoundationClass.static.myTableTools = require('Module:TableTools')
FoundationClass.static.myYesno = require('Module:Yesno')
-- these are later set by my child class:
local _debug	-- function for debugging, declared later

-- ***************************************************************
-- *                           methods                           *
-- ***************************************************************

-- **************** declaration of static methods
function FoundationClass:initialize(user_uid, superHandler)	-- constructor
	local user_uid = user_uid or mw.title.getCurrentTitle().prefixedText
	local shs = superHandler
	local superHandler = (superHandler and type(superHandler) == 'table' and superHandler.addError and type(superHandler.addError) == 'function') and superHandler or nil
	local _CFG = self.class.myConfiguration
	local idString = user_uid and ('myUid_' ..user_uid)  or ('NIL_' .. mw.title.getCurrentTitle().prefixedText)
	-- initialize all private properties
	_private[self] = {
		categories = {},
		coreData = {},
		dbg = ClassDebug:new('class FoundationClass: ' .. idString),
		errors = {},
		initialized = false,
		loadedDataFromDataStore = false,
		loadedDataMyself = false,
		output = mw.html.create(''),
		superHandler = superHandler,
		uid = user_uid,
		warnings = {},
	}
	if _CFG.global.category and mw.title.getCurrentTitle().namespace ~= 10 then
		self:addCategory(_CFG.global.category)
	end
	_debug(self, 1, 'Initializing object "' .. idString ..'", from ' .. tostring(self))
	_debug(self, 1, ' my superhandler was ' .. tostring(shs))
	_debug(self, 1, ' my superhandler is ' .. tostring(superHandler))
end

function FoundationClass.static:cargoGenerateTableStructure()
	_debug(self, 1, 'entering FoundationClass.static:cargoGenerateTableStructure(), from ' .. tostring(self))
	local _CFG = self.myConfiguration
	-- warning: calling FoundationClass:cargoGenerateTableStructure() gives us no access to our configuration, use Class.cargoGenerateTableStructure(self) instead
	local declaration = {}
	-- first, add the uid field
	declaration[FoundationClass.globalConfig.uidFieldName] = 'Text (hidden)'
	for param, paramData in pairs(_CFG.parameter) do
		if paramData.cargo_type and mw.ustring.len(paramData.cargo_type) > 0 then
			if paramData.cardinality and paramData.cardinality == 'list' then
				declaration[param] = 'List (' .. (_CFG.parameter[param].sf and _CFG.parameter[param].sf.delimiter or _CFG.global.delimiter) .. ') of ' .. paramData.cargo_type
			else
				declaration[param] = paramData.cargo_type
			end
			local additional_field_parameters = {}
			if paramData.cargo_hidden then
				table.insert(additional_field_parameters, 'hidden')
			end
			if paramData.cargo_size and (type(paramData.cargo_size) == 'number' or mw.ustring.match(paramData.cargo_size, '^[0-9]+$')) and
					FoundationClass.myTableTools.inTable(FoundationClass.globalConfig.cargoTypesElegibleForSize, mw.ustring.lower(paramData.cargo_type)) then
				table.insert(additional_field_parameters, 'size=' .. tostring(paramData.cargo_size))
			end
			if paramData.values and FoundationClass.myTableTools.size(paramData.values) > 0 and
					FoundationClass.myTableTools.inTable(FoundationClass.globalConfig.cargoTypesElegibleForValue, mw.ustring.lower(paramData.cargo_type)) then
				local av = 'allowed values='
				for _, v in pairs(paramData.values) do
					av = av .. v .. ','
				end
				table.insert(additional_field_parameters, mw.ustring.sub(av, 1, -2))
			end
			if #additional_field_parameters > 0 then
				declaration[param] = declaration[param] .. ' (' .. table.concat(additional_field_parameters, ';') .. ')'
			end
		end
	end
	return declaration
end

function FoundationClass.static:categorize()
	local thispage = mw.title.getCurrentTitle()
	local _CFG = self.myConfiguration
	local ret = ''
	if self and _private[self] and _private[self].uid then
		error('FoundationClass:categorize() must be called statically. Furthermore, it is not meant for categorizing class\'s objects but rather all pages belonging to the class\'s data pipeline (form, categories, modules, template, ...)')
	elseif thispage.rootText == 'Classgenerator' or thispage.rootText == 'Foundationclass' then
		ret = ret .. '[[Category:Class engine]]'
		if FoundationClass.globalConfig.classCategory and mw.ustring.len(FoundationClass.globalConfig.classCategory) > 0 then
			-- there has been a classCategory configured
			if thispage.text == 'Foundationclass' or (thispage.subpageText and thispage.subpageText == 'class')  then
				-- add class category if on a class page or on foundationclass
				ret = ret .. '[[Category:' .. FoundationClass.globalConfig.classCategory .. ']]'
			end
			if thispage.subpageText and (thispage.subpageText == 'config' or thispage.subpageText == 'globalconfig') then
				-- add class category if on a config page
				local basepage = mw.ustring.match(thispage.fullText, '^[^:]*:(.+)/config.*$')
				local classpage
				if basepage then
					classpage = basepage .. '/class'
				else
					classpage = thispage.rootText .. '/config'
				end
				ret = ret .. '[[Category:' .. FoundationClass.globalConfig.classCategory .. '|' .. classpage .. ']]'
			end
		end
	elseif thispage.namespace == 10 then
		-- template namespace: add category if in correct namespace and there has been a templateCategory configured, also make sure, we are not part of classgenerator
		if FoundationClass.globalConfig.templateCategory and mw.ustring.len(FoundationClass.globalConfig.templateCategory) > 0 then
			ret = ret .. '[[Category:' .. FoundationClass.globalConfig.templateCategory .. ']]'
		end
	elseif thispage.namespace == 14 then
		-- category namespace
		if _CFG and _CFG.global and _CFG.global.gardeningCategory == thispage.text and FoundationClass.globalConfig.gardeningSuperCategory and mw.ustring.len(FoundationClass.globalConfig.gardeningSuperCategory) and thispage.text ~= FoundationClass.globalConfig.gardeningSuperCategory then
			-- if class' gardening category and not the supergardening itself -> set gardening supercategory
			ret = ret .. '[[Category:' .. FoundationClass.globalConfig.gardeningSuperCategory .. ']]'
		elseif FoundationClass.globalConfig.projectSuperCategory and mw.ustring.len(FoundationClass.globalConfig.projectSuperCategory) > 0 then
			-- not a gardening category and not called by a childclass. projectSuperCategory set
			ret = ret .. '[[Category:' .. FoundationClass.globalConfig.projectSuperCategory .. ']]'
		end
	elseif thispage.namespace == mw.title.makeTitle('Form', 'NUL').namespace then
		-- form namespace: add category if in correct namespace and there has been a formCategory configured, also make sure, we are not part of classgenerator
		if FoundationClass.globalConfig.formCategory and #FoundationClass.globalConfig.formCategory > 0 then
			ret = ret .. '[[Category:' .. FoundationClass.globalConfig.formCategory .. ']]'
		end
	elseif thispage.namespace == mw.title.makeTitle('Module', 'NUL').namespace then
		-- module namespace: add category if in correct namespace and there has been a moduleCategory configured, also make sure, we are not part of classgenerator or foundationclass
		if FoundationClass.globalConfig.moduleCategory and #FoundationClass.globalConfig.moduleCategory > 0 then
			ret = ret .. '[[Category:' .. FoundationClass.globalConfig.moduleCategory .. ']]'
		end
		if thispage.subpageText and thispage.subpageText == 'class' and FoundationClass.globalConfig.classCategory and mw.ustring.len(FoundationClass.globalConfig.classCategory) > 0 then
			-- add class category if on a class page and there has been a classCategory configured
			ret = ret .. '[[Category:' .. FoundationClass.globalConfig.classCategory .. ']]'
		end
		if thispage.subpageText and thispage.subpageText == 'config' and FoundationClass.globalConfig.classCategory and mw.ustring.len(FoundationClass.globalConfig.classCategory) > 0 then
			-- add class category if on a config page and there has been a classCategory configured
			local basepage = mw.ustring.match(thispage.fullText, '^[^:]*:(.+)/config.*$')
			local classpage
			if basepage then
				classpage = basepage .. '/class'
			else
				classpage = thispage.rootText .. '/config'
			end
			ret = ret .. '[[Category:' .. FoundationClass.globalConfig.classCategory .. '|' .. classpage .. ']]'
		end
	elseif thispage.namespace == mw.title.makeTitle('Property', 'NUL').namespace then
		-- property namespace: add category if in correct namespace and there has been a propertyCategory configured
		if FoundationClass.globalConfig.propertyCategory and #FoundationClass.globalConfig.propertyCategory > 0 then
			ret = ret .. '[[Category:' .. FoundationClass.globalConfig.propertyCategory .. ']]'
		end
	end
	return ret
end

function FoundationClass.static:categoryPage()
	_debug(self, 1, 'entering FoundationClass.static:categoryPage(), from ' .. tostring(self))
	local html = mw.html.create('')
	if mw.title.getCurrentTitle().namespace == 14 then
		local frame = mw.getCurrentFrame()
		local _CFG = self.myConfiguration
		local form
		if _CFG.form.enable and _CFG.form.name and mw.ustring.len(_CFG.form.name) then
			form = frame:callParserFunction('#default_form:' .. _CFG.form.name)
		else
			form = 'Seiten in dieser Kategorie haben kein Standardformular'
		end
		local mbox = require('Module:Message box').main('cmbox', 
			{
				type = 'notice',
				text = _CFG.global.description .. '\n* ' .. form .. '\n* ' .. 
						'Seiten in  dieser Kategorie nutzen die Vorlage [[Template:' .. _CFG.template.name .. ']]'
			})
		html:wikitext(tostring(mbox))
			:node(self:explainDataStore())	-- remember: self refers to a class, not an object and this method is static
	else
		error('FoundationClass:categoryPage() must be called from namespace category!', 2)
	end
	return html
end

function FoundationClass.static:explainDataStore()
	_debug(self, 1, 'entering FoundationClass.static:explainDataStore(), from ' .. tostring(self))
	local _CFG = self.myConfiguration
	local collapse = require('Module:Collapse').main
	local str = ''
	if FoundationClass.usesDataStore(self, 'cargo') then
		local declaration = self:cargoGenerateTableStructure()	-- remember: self refers to a class, not an object and this method is static
		-- add the default fields
		for field, description in pairs(FoundationClass.globalConfig.cargoSpecialFields) do
			declaration[field] = description
		end
		local fields = {}
		for key, _ in pairs(declaration) do
			table.insert(fields, key)
		end
		table.sort(fields)
		local headline = 'Declaration for CARGO table "' .. (_CFG.global.cargoTable or 'NIL') .. '"'
		local content = '<ul>'
		for _, field in pairs(fields) do
			local text = declaration[field]
			if _CFG.parameter[field] and _CFG.parameter[field].description then
				text = text .. ', <small>' .. _CFG.parameter[field].description .. '</small>'
			elseif field == FoundationClass.globalConfig.uidFieldName then
				text = text .. ', <small>Automatisch hinzugefügt! Wird verwendet, um individuelle Objekte innerhalb der Klasse zu identifizieren.</small>'
			end
			content = content .. '<li> ' .. field .. ': ' .. text .. '</li>'
		end
		content = content .. '</ul>\n[[Spezial:CargoTables/'.. (_CFG.global.cargoTable or 'Instance') .. '|View Data]]'
		str = str ..  collapse{header = headline, content = content, left = true} .. '\n'
	end
	if FoundationClass.usesDataStore(self, 'smw') then	-- smw store
		local property2param = FoundationClass.smwGetProperty2ParameterTranslationTable(self)
		local properties = {}
		local lang = mw.language.getContentLanguage()
		for prop, field in pairs(property2param) do
			local property
			if FoundationClass.globalConfig.ucfirst then
				property = lang:ucfirst(prop)
			else
				property = prop
			end
			properties[property] = {
				individual = true, -- essentially says: no special property
			}
			if _CFG.parameter[field] then
				properties[property].description = _CFG.parameter[field].description
				properties[property].type = (_CFG.parameter[field].property_type and _CFG.parameter[field].property_type or 'Page')
				properties[property].values = (_CFG.parameter[field].values and #_CFG.parameter[field].values > 0) and ' (allowed values=' .. table.concat(_CFG.parameter[field].values, ', ') .. ')' or ''
			elseif field == FoundationClass.globalConfig.smwClassProperty then
				properties[property].description = 'Automatisch hinzugefügt! Wird verwendet, um Mitglieder dieser Klasse zu finden (funktioniert auch, ohne dass eine Kategorie definiert wird und auch fur subobjects)'
				properties[property].type = 'Text'
				properties[property].values = ''
			elseif field == FoundationClass.globalConfig.uidFieldName then
				properties[property].description = 'Automatisch hinzugefügt! Wird verwendet, um individuelle Objekte innerhalb der Klasse zu identifizieren.'
				properties[property].type = 'Text'
				properties[property].values = ''
			else
				-- should never apply
				properties[property].description = 'THIS should not have appeared. Please consult an admin'
				properties[property].type = 'WARNING!'
				properties[property].values = ' (see Module:Foundationclass, FoundationClass.static:explainDataStore() for more information)'
			end
			properties[property].text = ((_CFG.parameter[field] and _CFG.parameter[field].cardinality == 'list') and 'List of ' or '') .. properties[property].type .. properties[property].values ..
				', <small>' .. properties[property].description .. '</small>'
		end
		if _CFG and _CFG.global and not _CFG.global.smwIsSubobject then
			for key, value in pairs(FoundationClass.globalConfig.smwSpecialProperties) do
				local property
				if FoundationClass.globalConfig.ucfirst then
					property = lang:ucfirst(key)
				else
					property = key
				end
				properties[property] = { text = value }
			end
		end
		local propertyList = {}
		for key, _ in pairs(properties) do
			table.insert(propertyList, key)
		end
		table.sort(propertyList)
		local headline = 'Semantic properties used in this class:'
		local content = '<ul>'
		for _, property in pairs(propertyList) do
			content = content .. '<li>[[Property:' .. property .. ']]: ' .. properties[property].text .. '</li>'
		end
		content = content .. '</ul>\n'
		local attributes = {headers='plain', format='table', limit=0, searchlabel='Hier klicken für eine tabellarische Übersicht!'}
		local fields = {}
		for key, _ in pairs(properties) do
			table.insert(fields, key)
		end
		table.sort(fields)
		content = content .. FoundationClass.mySmwUtil.rawask({where='[[' .. FoundationClass.globalConfig.smwClassProperty .. '::' .. self.name .. ']]', fields = fields }, attributes) .. '\n'
		str = str .. collapse{header = headline, content = content, left = true} .. '\n'
	end
	if #mw.text.trim(str) == 0 then
		str = 'This template does not store any persistent data.'
	end
	str = '\n== Data Storage ==\n' .. str
	return str
end

function FoundationClass.static:formRedlink(target, form, linktext, queryString)
	_debug(self, 1, 'entering FoundationClass.static:formRedlink() to create a redlink to a form')
	local target = target
	local form = form
	local linktext = linktext or target
	local str
	if target and form then
		local frame = mw.getCurrentFrame()
		args = { form = form }
		if linktext then
			args['link text'] = linktext
			args['existing page link text'] = linktext
		end
		if queryString then
			args['query string'] = queryString
		end
		str = frame:callParserFunction{ name='#formredlink:target=' .. target, args=args }
	else
		str = 'target or form missing on call to _formredlink()'
	end
	return str
end

function FoundationClass.static:gardeningCategoryPage()
	_debug(self, 1, 'entering FoundationClass.static:gardeningCategoryPage(), from ' .. tostring(self))
	local html = mw.html.create('')
	if mw.title.getCurrentTitle().namespace == 14 then
		local frame = mw.getCurrentFrame()
		local _CFG = self.myConfiguration
		local mbox = require('Module:Message box').main
		html:wikitext(tostring(mbox('cmbox', 
			{
				type = 'notice',
				text = 'This category shows all elements of class ' .. self.name .. ' that have at least one error in their core data. This category must be empty at all times!'
			})))
			:newline()
			:wikitext(tostring(mbox('cmbox', 
			{
				type = 'content',
				text = 'This category should be empty! Please tend to the articles contained herein!'
			})))
		-- add category if in namespace category and there has been a supercategory configured
		if FoundationClass.globalConfig.gardeningCategory and #FoundationClass.globalConfig.gardeningCategory > 0 and FoundationClass.globalConfig.gardeningCategory ~= mw.title.getCurrentTitle().text then
			html:wikitext('[[Category:' .. FoundationClass.globalConfig.gardeningCategory .. ']]')
		end
	else
		error('FoundationClass:gardeningCategoryPage() must be called from namespace category!', 2)
	end
	return html
end

function FoundationClass.static:mwLink(target)
	-- just a util method
	if not target then
		return ''
	elseif type(target) == 'table' then
		return '[[' .. mw.text.listToText(target, ']], [[', ']] und [[') .. ']]'
	else
		return '[[' .. target .. ']]'
	end
end

function FoundationClass.static:sfGenerateForm()
	_debug(self, 1, 'entering FoundationClass.static:sfGenerateForm(), from ' .. tostring(self))
	local _CFG = self.myConfiguration
	if not _CFG.form.enable then
		return require('Module:Error').error{ message = 'Error: This class has no form page. Could not create link to form!', type = 'div' }
	end
	local tagStart = '{{{'
	local tagEnd = '}}}'
	-- create the form header
	local notification = mw.html.create('')
	if _CFG.form.notification and mw.ustring.len(_CFG.form.notification) > 0 then
		local mbox = require('Module:Message box')
		notification:wikitext(mbox.main('ombox', { text = _CFG.form.notification }))
			:newline()
	end
	local formheader = mw.html.create('')
	formheader:wikitext(self:sfGenerateFormInfoTag())
		:addClass('description-box')
		:wikitext('<h2>' .. _CFG.global.entityTitle .. '</h2>')
		:tag('p')
			:wikitext(_CFG.form.headerText)
			:done()
			:newline()
		:node(notification)
		:done()
		:tag('div')
			:attr('id', 'wikiPreview')
			:cssText('display: none; padding-bottom: 25px; margin-bottom: 25px; border-bottom: 1px solid #AAAAAA')
			:done()
			:newline()
	-- deal with sections and free text
	local sections = mw.html.create('')
	local sectionlist = _CFG.form.sectionList and _CFG.form.sectionList or {}
	for _, section in pairs(sectionlist) do
		sections:wikitext('<h2>' .. section .. '</h2>')
			:newline()
			:wikitext(tagStart .. 'section|' .. section .. '|level=2|autogrow=true|cols=' .. _CFG.form.textareaAttributes.cols .. 
							'|rows=' .. math.max(8, 2*_CFG.form.textareaAttributes.rows) .. tagEnd)
			:newline()
	end
	local freetext = mw.html.create('')
	if _CFG.form.allowsFreeText then
		freetext:wikitext(tagStart .. 'standard input|free text|autogrow=true|editor=wikieditor|cols=' .. math.min(200, 2*_CFG.form.textareaAttributes.cols) .. 
							'|rows=' .. math.min(48, 5*_CFG.form.textareaAttributes.rows) .. tagEnd)
			:newline()
	end
	-- create the form buttons
	local formbuttons = mw.html.create('div')	-- we have to use a div here. this somehow helps the includes/SF_FormPrinter.php to correcly place the fieldset (blue box) around the form
	if FoundationClass.myTableTools.inTable(_CFG.form.buttons, 'summary') then
		formbuttons:tag('p')
			:wikitext(tagStart .. 'standard input|summary' .. tagEnd)
			:done()
			:newline()
	end
	for _, button in pairs(_CFG.form.buttons) do
		if button ~= 'summary' then
			formbuttons:wikitext(tagStart .. 'standard input|' .. button .. tagEnd)
		end
	end
	formbuttons:addClass('formbuttons')
		:done()
	-- assemble everything, so start the html object
	local html = mw.html.create('div')
	html:node(formheader)
		:wikitext(tagStart .. 'for template|' .. _CFG.template.name .. '|label=' .. _CFG.global.entityTitle .. tagEnd)
		:newline()
		:node(self:sfGenerateFormTable())
		:newline()
		:wikitext("'''(*) Pflichtfeld'''<br>")
		:newline()
		:wikitext(tagStart .. 'end template' .. tagEnd)
		:newline()
		:node(sections)
		:node(freetext)
		:node(formbuttons)
	local debugLevel = FoundationClass.globalConfig.debugLevel or self.myConfiguration.global.debugLevel
	if debugLevel then
		html:newline()
			:newline()
			:wikitext('<h2>Debug level is ' .. debugLevel .. '</h2>')
			:newline()
			:wikitext(ClassDebug:printLog(debugLevel))
	end
	local getArgs = require('Module:Arguments').getArgs
	local frame = mw.getCurrentFrame()
	local args = getArgs(frame)
	if args.dump == "true" then
		return mw.text.nowiki( tostring(html) )
	end
	return html
end

function FoundationClass.static:sfGenerateFormEntry()
	_debug(self, 1, 'entering FoundationClass.static:sfGenerateFormEntry(), from ' .. tostring(self))
	local _CFG = self.myConfiguration
	local html = mw.html.create('')
	local thispage = mw.title.getCurrentTitle()
	html:wikitext('<h2>' .. _CFG.global.entityTitle .. '</h2>')
		:newline()
		:tag('p')
			:wikitext(_CFG.form.teaserText)
			:done()
		:newline()
	if _CFG.form.typeCreateLink and (mw.ustring.lower(_CFG.form.typeCreateLink) == 'forminput' or mw.ustring.lower(_CFG.form.typeCreateLink) == 'formlink') then
		html:tag('p')
			:wikitext(_CFG.form.createInfotext)
			:wikitext(self:sfGenerateFormLink())	-- remember: self refers to a class, not an object and this method is static
			:done()
			:newline()
	end
	local getArgs = require('Module:Arguments').getArgs
	local frame = mw.getCurrentFrame()
	local args = getArgs(frame)
	if args.dump == "true" then
		return mw.text.nowiki( tostring(html) )
	end
	return html
end

function FoundationClass.static:sfGenerateFormInfoTag()
	_debug(self, 1, 'entering FoundationClass.static:sfGenerateFormInfoTag(), from ' .. tostring(self))
	local _CFG = self.myConfiguration
	local frame = mw.getCurrentFrame()
	if not _CFG.form.enable then
		return require('Module:Error').error{ message = 'Error: This class has no form page. Could not create link to form!', type = 'div' }
	end
	local tagStart = '{{{'
	local tagEnd = '}}}'
	local queryString = ''
	if (not _CFG.form.typeCreateLink or mw.ustring.lower(_CFG.form.typeCreateLink) ~= 'forminput') and _CFG.form.createLinkPageName and #_CFG.form.createLinkPageName > 0 then
		local pageName = _CFG.form.createLinkPageName
		if _CFG.global.namespace and mw.ustring.len(_CFG.global.namespace) > 0 and not mw.ustring.match(pageName, '^' .. _CFG.global.namespace .. ':.+$') then
			pageName = _CFG.global.namespace .. ':' .. pageName
		end
		queryString = '|page name=' .. pageName
	end
	return tagStart .. 'info' .. queryString .. '|add title=' .. _CFG.form.labelCreate .. '|edit title=' .. _CFG.form.labelEdit .. tagEnd
end

function FoundationClass.static:sfGenerateFormLink()
	_debug(self, 1, 'entering FoundationClass.static:sfGenerateFormInput(), from ' .. tostring(self))
	local _CFG = self.myConfiguration
	if not _CFG.form.enable or not _CFG.form.name or #_CFG.form.name == 0 then
		return require('Module:Error').error{ message = 'Error: This class has no form page. Could not create link to form!', type = 'div' }
	end
	local frame = mw.getCurrentFrame()
	local ret = ''
	if _CFG.form.typeCreateLink and (_CFG.form.typeCreateLink == 'forminput' or _CFG.form.typeCreateLink == 'formlink') then
		if _CFG.form.typeCreateLink == 'forminput' then
			local args = { size = 40 }
			if _CFG.form.createInputPlaceholder and mw.ustring.len(_CFG.form.createInputPlaceholder) > 0 then
				args.placeholder = _CFG.form.createInputPlaceholder
			end
			if _CFG.form.InputQueryString and mw.ustring.len(_CFG.form.InputQueryString) > 0 then
				args['query string'] = _CFG.form.InputQueryString
			end
			args['button text'] = _CFG.form.labelCreate
			if _CFG.global.namespace and mw.ustring.len(_CFG.global.namespace) > 0 then
				if args['query string'] then
					args['query string'] = args['query string'] .. '&' .. 'namespace=' .. _CFG.global.namespace
				else
					args['query string'] = 'namespace=' .. _CFG.global.namespace
				end
			end
			ret = frame:callParserFunction{name = '#forminput:form=' .. _CFG.form.name, args = args}
		else
			local args = {
				tooltip = _CFG.form.createInfotext
			}
			if _CFG.form.createLinkQueryString and mw.ustring.len(_CFG.form.createLinkQueryString) > 0 then
				args['query string'] = _CFG.form.createLinkQueryString
			end
			local linkType = _CFG.form.createLinkType
			if linkType then
				linkType = mw.ustring.lower(linkType)
				if linkType ~= 'button' and linkType ~= 'post button' then
					linkType = nil
				end
			end
			args['link text'] = _CFG.form.labelCreate
			args['link type'] = linkType
			ret = frame:callParserFunction{name = '#formlink:form=' .. _CFG.form.name, args = args}
		end
	end
	return ret
end

function FoundationClass.static:sfGenerateFormTable(fieldlist, tableid)
	_debug(self, 1, 'entering FoundationClass.static:sfGenerateFormTable(fieldlist), from ' .. tostring(self))
	local _CFG = self.myConfiguration
	local fieldlist = fieldlist or _CFG.form.fieldOrder
	-- set some form defaults
	ClassSFfield:setDefaultSize(_CFG.form.fieldSize)
	ClassSFfield:setDefaultTextAreaCols(_CFG.form.textareaAttributes.cols)
	ClassSFfield:setDefaultTextAreaEditor(_CFG.form.textareaAttributes.editor)
	ClassSFfield:setDefaultTextAreaRows(_CFG.form.textareaAttributes.rows)
	-- now create the form table
	local hidden = mw.html.create('')
	local formtable = mw.html.create('table')
	for _, fieldname in pairs(fieldlist) do
		if _CFG.parameter[fieldname] and not self:mySfDynamicFieldAttribute(fieldname, 'disable', false)  then
			local field = self:sfInitField(fieldname)
			if field then
				if field:get('hidden') then
					hidden:wikitext(field:render())
				else
					formtable:node(field:createTr(_CFG.parameter[fieldname].label, _CFG.parameter[fieldname].description))
				end
			elseif _CFG.parameter[fieldname].label and _CFG.parameter[fieldname].description and (not _CFG.parameter[fieldname].td_type or mw.ustring.len(_CFG.parameter[fieldname].td_type) == 0) then
				local mbox = require('Module:Message box').main('cmbox', { type = 'notice', text = "'''" .. _CFG.parameter[fieldname].label .. ":''' " .._CFG.parameter[fieldname].description})
				formtable:tag('tr')
					:attr('id', ClassSFfield:getShowOnSelectIdPrefix() .. mw.uri.encode(fieldname, 'WIKI'))
					:tag('td')
						:attr('colspan', 2)
						:wikitext(tostring(mbox))
						:done()
			end
		end
	end
	formtable:addClass(FoundationClass.globalConfig.formTableClass)
		:css('width', 'auto')
	if tableid then
		formtable:attr('id', tableid)
	end
	formtable:done()
		:node(hidden)
	return formtable
end

function FoundationClass.static:sfInitField(fieldname)
	_debug(self, 1, 'entering FoundationClass.static:sfInitField(fieldname) to initialize field ' .. fieldname or 'NOT SET' .. ', from ' .. tostring(self))
	local _CFG = self.myConfiguration
	local field
	if _CFG.parameter[fieldname] and _CFG.parameter[fieldname].sf and not self:mySfDynamicFieldAttribute(fieldname, 'disable', false) then
		field = ClassSFfield:new(fieldname)
		if _CFG.parameter[fieldname].cardinality and _CFG.parameter[fieldname].cardinality == 'list' then
			field:set('list', self:mySfDynamicFieldAttribute(fieldname, 'list', true))
			local delimiter = _CFG.parameter[fieldname].sf and _CFG.parameter[fieldname].sf.delimiter or _CFG.global.delimiter
			-- if we have a global or local delimiter set which is not the comma (','), provide it here automatically
			if delimiter ~= ',' then
				field:set('delimiter', self:mySfDynamicFieldAttribute(fieldname, 'delimiter', delimiter))
			end
		end
		if _CFG.parameter[fieldname].severity and _CFG.parameter[fieldname].severity == 'mandatory' then
			field:set('mandatory', self:mySfDynamicFieldAttribute(fieldname, 'mandatory', true))
		end
		if _CFG.parameter[fieldname].values then
			field:set('values', self:mySfDynamicFieldAttribute(fieldname, 'values', _CFG.parameter[fieldname].values))
		end
		if _CFG.parameter[fieldname].sf then
			for attr, val in pairs(_CFG.parameter[fieldname].sf) do
				field:set(mw.ustring.gsub(attr, '_', ' '),
						self:mySfDynamicFieldAttribute(fieldname, attr, val)	-- remember: self refers to a class, not an object and this method is static
					)
			end
		end
	end
	return field
end

function FoundationClass.static:smwGetProperty2ParameterTranslationTable()
	_debug(self, 1, 'entering FoundationClass.static:smwGetProperty2ParameterTranslationTable(), from ' .. tostring(self))
	if not FoundationClass.usesDataStore(self, 'smw') then
		return nil
	end
	if not self.smwProperty2ParameterTranslationTable or FoundationClass.myTableTools.size(self.smwProperty2ParameterTranslationTable) == 0 then
		local _CFG = self.myConfiguration
		local translation = {}
		translation[mw.ustring.gsub(FoundationClass.globalConfig.smwClassProperty, ' ', '_')] = mw.ustring.gsub(FoundationClass.globalConfig.smwClassProperty, ' ', '_')
		translation[mw.ustring.gsub(FoundationClass.globalConfig.uidFieldName, ' ', '_')] = mw.ustring.gsub(FoundationClass.globalConfig.uidFieldName, ' ', '_')
		for param, data in pairs(_CFG.parameter) do
			if data.property_name and data.property_name:len() > 0 then
				translation[mw.ustring.gsub(data.property_name, ' ', '_')] = param
			end
		end
		self.smwProperty2ParameterTranslationTable = translation
	end
	return self.smwProperty2ParameterTranslationTable
end

function FoundationClass.static:templateDocumentation(arg)
	_debug(self, 1, 'entering FoundationClass.static:templateDocumentation(), from ' .. tostring(self))
	local _CFG = self.myConfiguration
	local frame = mw.getCurrentFrame()
	local arg = arg
	local debugLevel = FoundationClass.globalConfig.debugLevel or self.myConfiguration.global.debugLevel
	local thispage = mw.title.getCurrentTitle()
	local luaBanner = require('Module:Lua banner')
	-- first generate the template data for the "parameters"-section
	local parameter = {}
	for _, param in pairs(_CFG.form.fieldOrder) do
		if _CFG.parameter[param] and _CFG.parameter[param].td_type then
			table.insert(parameter, param)
		end
	end
	local templateData = ''
	if #parameter > 0 then
		local globalDescription = mw.ustring.gsub(mw.ustring.gsub(_CFG.global.description, '\t', ' '), '\n', ' ')
		local jsonData = '{\n\t"description": "' .. globalDescription .. '",\n' ..
			'\t"params": {\n'
		for _, param in pairs(parameter) do
			local paramdata = _CFG.parameter[param]
			jsonData = jsonData .. '\t\t"' .. param .. '": {\n'
			jsonData = jsonData .. '\t\t\t"type": "' .. mw.ustring.lower(paramdata.td_type) .. '",\n'
			if paramdata.td_default then
				jsonData = jsonData .. '\t\t\t"default": "' .. paramdata.td_default .. '",\n'
			end
			if paramdata.description then
				--jsonData = jsonData .. '\t\t\t"description": "' .. mw.ustring.gsub(paramdata.description, '"', '\'\'') .. '",\n'
				--since 1.31 \n and \t are not allowed in json string, so replace them with a space
				local paramDescription = mw.ustring.gsub(paramdata.description, '"', '\'\'')
				paramDescription = mw.ustring.gsub(mw.ustring.gsub(paramDescription, '\t', ' '), '\n', ' ')
				jsonData = jsonData .. '\t\t\t"description": "' .. paramDescription .. '",\n'
			end
			if paramdata.label then
				jsonData = jsonData .. '\t\t\t"label": "' .. paramdata.label .. '",\n'
			end
			if paramdata.severity then
				jsonData = jsonData .. '\t\t\t"suggested": ' .. ((paramdata.severity == 'suggested' or paramdata.severity == 'optional') and 'true,\n' or 'false,\n')
				jsonData = jsonData .. '\t\t\t"required": ' .. ((paramdata.severity == 'mandatory' or paramdata.severity == 'required') and 'true,\n' or 'false,\n')
			end
			jsonData = mw.ustring.sub(jsonData, 1, -3) .. '\n\t\t},\n'
		end
		jsonData = mw.ustring.sub(jsonData, 1, -3) .. '\n\t}\n}'
		if debugLevel then
			templateData = '<pre>' .. jsonData .. '</pre>'
		else
			templateData = frame:extensionTag('templatedata', jsonData)
		end
	else
		templateData = 'Dieses Template verfügt über keine nutzbaren (statischen) parameter.'
	end
	-- then assemble the code for the usage section
	local code = '{{' .. thispage.rootText .. '\n'
	for _, param in pairs(parameter) do
		code = code .. '|' .. param .. '=\n'
	end
	code = code .. '}}\n'
	-- the 'see also' links
	local seeAlso = mw.html.create('')
	local seeAlsoList = mw.html.create('')
	if _CFG.template.templateDocumentationSeeAlso then
		if type(_CFG.template.templateDocumentationSeeAlso) == 'table' then
			for _, link in pairs(_CFG.template.templateDocumentationSeeAlso) do
				if mw.ustring.find(link, ':', 1, true) then
					link = mw.ustring.match(link, '^[^:]*:(.+)$')
				end
				seeAlsoList:tag('li')
					:wikitext('{{[[:Template:' .. link .. '|' .. link .. ']]}}')
					:done()
					:newline()
			end
		else
			local link = _CFG.global.templateDocumentationSeeAlso
			if mw.ustring.find(link, ':', 1, true) then
				link = mw.ustring.match(link, '^[^:]*:(.+)$')
			end
			seeAlsoList:tag('li')
				:wikitext('{{[[:Template:' .. link .. '|' .. link .. ']]}}')
				:done()
				:newline()
		end
		seeAlso:wikitext('<h2>See also</h2>')
			:newline()
			:tag('ul')
				:node(seeAlsoList)
				:done()
				:newline()
	end
	-- assemble
	local html = mw.html.create('')
	html:wikitext('<h2>Description</h2>')
		:newline()
		:wikitext(luaBanner._main({'Module:' .. thispage.rootText, 'Module:' .. thispage.rootText .. '/class',
					'Module:' .. thispage.rootText .. '/config', 'Module:Foundationclass', 'Module:Middleclass'}))
		:newline()
		:wikitext(_CFG.global.description .. ((_CFG.global.category and mw.ustring.len(_CFG.global.category) > 0) and ('\n\n' .. mw.site.namespaces[14].name .. ': [[:Category:' .. _CFG.global.category .. ']]\n') or ''))
		:newline()
		:node(self:explainDataStore())	-- remember: self refers to a class, not an object and this method is static
		:newline()
		:newline()
		:wikitext('<h2>Parameters</h2>')
		:wikitext(templateData)
		:newline()
		:newline()
		:wikitext('<h2>Usage</h2>')
		:wikitext(frame:expandTemplate{ title = 'Code', args = {'html+handlebars', code} })
		:newline()
		:node(seeAlso)
		:done()
	if debugLevel then
		html:newline()
			:newline()
			:wikitext('<h2>Debug level is ' .. debugLevel .. '</h2>')
			:newline()
			:wikitext(ClassDebug:printLog(debugLevel))
	end
	return html
end

function FoundationClass.static:usesDataStore(storeType)
	_debug(self, 1, 'entering FoundationClass.static:usesDataStore(storeType) to do assertain, if store "' .. storeType .. '" is used, from ' .. tostring(self))
	local _CFG = self.myConfiguration
	return (FoundationClass.globalConfig.dataStore == 'both' or FoundationClass.globalConfig.dataStore == mw.ustring.lower(storeType)) and 
		(mw.ustring.lower(storeType) == 'smw' and _CFG.global.smwUseStorage) or (mw.ustring.lower(storeType) == 'cargo' and _CFG.global.cargoTable and #_CFG.global.cargoTable > 0)
end

function FoundationClass.static:staticMethod(var)
	_debug(self, 1, 'entering FoundationClass.static:staticMethod() to do something, from ' .. tostring(self))
end

-- **************** declaration of private methods
local _amIPlausible = function (self)
	return (#_private[self].errors == 0)
end

_debug = function (self, level, text)
	if _private[self] and _private[self].dbg then
		local debugLevel = FoundationClass.globalConfig.debugLevel or self.class.myConfiguration.global.debugLevel
		if debugLevel and level <= debugLevel then
			_private[self].dbg:log(level, text)
		end
	else
		local debugLevel = FoundationClass.globalConfig.debugLevel or self.myConfiguration.global.debugLevel
		if debugLevel and level <= debugLevel then
			ClassDebug:log(level, text, tostring(self) .. '.static')
		end
	end
end

local _plausibilityTest = function (self, args)
	_debug(self, 1, 'entering FoundationClass._plausibilityTest(self, args)')
	local _CFG = self.class.myConfiguration
	local args = args
	-- first see, whether we are in the correct namespace (that is, if we are not initialzed from a datastore)
	if not _private[self].superHandler and not _private[self].loadedDataFromDataStore and _CFG.global.namespace and #_CFG.global.namespace > 0 and (_CFG.global.namespace ~= mw.title.getCurrentTitle().nsText) then
		self:addError("Diese Seite befindet sich in einem ungültigen Namesraum. Eingestellt ist ''" .. _CFG.global.namespace .. "'',  festgestellt wurde: " .. ((mw.title.getCurrentTitle().nsText and #mw.title.getCurrentTitle().nsText > 0) and mw.title.getCurrentTitle().nsText or 'keiner'))
	end
	-- prepare for the "show on select"-complex
	-- motivation:
	-- when you have a selector with a show on select field, sf shows some fields dynamically. sf even lets you set these dynamically shown fields
	-- to mandatory but checks for this only, if the field is shown.
	-- problem: so with this in mind, it is possible, that we have a mandatory field in our configuration with no value, but still be pausible
	-- since it only has to submit a value, if it is shown. but in the case it is shown, it has to submit a value
	-- what we do: build a table fieldnameToCheck : { showSelectorFieldname : valuetoshow }
	-- btw: this table fieldnameToCheck should only containe one element. if the programmer has the field "fieldnameToCheck" put in more than
	-- one show on select, the resulting form is erratic.
	local showOnSelectComplex = {}
	for param, paramdata in pairs(_CFG.parameter) do
		if not self.class.mySfDynamicFieldAttribute(self.class, param, 'disable', false) and paramdata.sf and paramdata.sf.show_on_select then
			local sos = self.class.mySfDynamicFieldAttribute(self.class, param, 'show_on_select', paramdata.sf.show_on_select)
			_debug(self, 3, '  got this in return: ' .. (type(sos) == 'string' and tostring(sos) or type(sos)))
			if type(sos) ~= 'table' then
				sos = tostring(sos)
				if not showOnSelectComplex[sos] then
					showOnSelectComplex[sos] = {}
				end
				-- this being a string makes sense only if input type is checkbox. we leave the responsibility to the programmer, though
				showOnSelectComplex[sos][param] = FoundationClass.globalConfig.selectedCheckboxSubmitValue
			else
				-- assume type table
				for selectedValue, showFields in pairs(sos) do
					if type(showFields) ~= 'table' then
						showFields = tostring(showFields)
						if not showOnSelectComplex[showFields] then
							showOnSelectComplex[showFields] = {}
						end
						showOnSelectComplex[showFields][param] = selectedValue
					else
						-- one last iteration
						for _, showField in pairs(showFields) do
							showFields = tostring(showFields)
							if not showOnSelectComplex[showField] then
								showOnSelectComplex[showField] = {}
							end
							showOnSelectComplex[showField][param] = selectedValue
						end
					end
				end
			end
		end
	end
	_debug(self, 3, '  have this showOnSelectComplex: ' .. FoundationClass.myTableTools.printTable(showOnSelectComplex))
	-- now do the plausibility test
	for param, paramdata in pairs(_CFG.parameter) do
		if not self.class.mySfDynamicFieldAttribute(self.class, param, 'disable', false) and paramdata.sf then
			if not self.class.mySfDynamicFieldAttribute(self.class, param, 'hidden', false) then
				-- it is not set to hidden, so evaluate
				if args[param] and (type(args[param]) ~= 'string' or mw.ustring.len(args[param]) > 0) then
				-- first, see if it's there
					local value = args[param]
					local values
					if paramdata.values then
						values = self.class.mySfDynamicFieldAttribute(self.class, param, 'values', paramdata.values)
					end
					if type(value) == 'string' and mw.ustring.match(value, '^[0-9]+$') then
						-- because argument data coming form a parameter and not from database means a number is displayed as a string
						-- problem: if we store an only numbers containing entry in values, this will fail, i.e. paramdate.values = {'0', '123'} can never work
						value = tonumber(value)
					end
					if paramdata.cardinality == 'single' then
						if values and not FoundationClass.myTableTools.inTable(values, value) and ((paramdata.sf.input_type ~= 'combobox' and paramdata.sf.input_type ~= 'tokens') or paramdata.sf.existing_values_only) then
							-- 'values'-restriction given but value given not in values
							-- only loophole being tokens or combobox and NOT existring_values_only
							self:addError("Ungültiger Wert für parameter ''" .. param .. "'' festgestellt: " .. mw.text.encode(tostring(value)))
						end
					elseif values and ((paramdata.sf.input_type ~= 'combobox' and paramdata.sf.input_type ~= 'tokens') or paramdata.sf.existing_values_only) then
						-- multivaluefield and 'values'-restriction given
						-- only loophole being tokens or combobox and NOT existring_values_only
						local vals = {}
						if type(args[param]) == 'table' then
							-- which can be, if we are initializing by data
							vals = args[param]
						else
							for fragment in mw.text.gsplit(args[param], _CFG.parameter[param].sf and _CFG.parameter[param].sf.delimiter or _CFG.global.delimiter, true) do
								if fragment and mw.ustring.len(mw.text.trim(fragment)) > 0 then
									fragment = mw.text.trim(fragment)
									if mw.ustring.match(fragment, '^[0-9]+$') then
										fragment = tonumber(fragment)
									end
									table.insert(vals, fragment)
								end
							end
						end
						for _, v in pairs(vals) do
							if not FoundationClass.myTableTools.inTable(values, v) then
								self:addError("Ungültiger Wert für parameter ''" .. param .. "'' festgestellt: " .. mw.text.encode(v))
							end
						end
					end
				elseif FoundationClass.myTableTools.inTable(_CFG.form.fieldOrder, param) and paramdata.severity == 'mandatory' then
					-- param not found but should be (since it is a form param) and it is also marked as mandatory and not set to hidden --> 
					-- before we assume error lets check for the one loophole: field could be part of a "show on select", thus being mandatory but not shown
					local issueError = true
					if showOnSelectComplex[param] then
						-- yeah, the field is part of a "show on select". we only issue an error, if its selector indicates a show
						issueError = false
						for fieldname, showValue in pairs(showOnSelectComplex[param]) do
							if tostring(args[fieldname]) == tostring(showValue) then
								-- so it is shown and therefore should contain a value
								issueError = true
							end
						end
					end
					if issueError then
						self:addError("Pflichtfeld ''" .. param .. "'' fehlt!")
					end
				end
			else
				_debug(self, 1, '  field ' .. param .. ' is set to hidden. Not processing!')
			end
		else
			_debug(self, 1, '  field ' .. param .. ' is disabled or no sf-table given. Not processing!')
		end
	end
	return _amIPlausible(self)
end

local _privateMethod = function (self)
	_debug(self, 1, 'entering FoundationClass._privateMethod() to do something')
end

-- **************** declaration of public methods
function FoundationClass:addCategory(category)
	_debug(self, 1, 'entering FoundationClass:addCategory(category) with category ' .. (category and tostring(category) or 'EMPTY') .. ', from ' .. tostring(self))
	local category = category
	if category and mw.ustring.len(category) > 0 then
		if _private[self].superHandler then
			_debug(self, 3, '  found handler ' .. tostring(_private[self].superHandler) .. ', so we are probably not on the right page to lease a category. omitting categorizing into category "' .. category .. '"')
			--_debug(self, 3, '  refering category to handler ' .. tostring(_private[self].superHandler))
			--_private[self].superHandler:addCategory(category)
		else
			table.insert(_private[self].categories, category)
		end
	end
	return true
end

function FoundationClass:addError(errortext)
	_debug(self, 1, 'entering FoundationClass:addError(errortext), from ' .. tostring(self))
	_debug(self, 3, '  with errortext ' .. tostring(errortext))
	local errortext = errortext
	if errortext and mw.ustring.len(errortext) > 0 then
		if _private[self].superHandler then
			_debug(self, 3, '  refering error to handler ' .. tostring(_private[self].superHandler))
			errortext = (self:getUid() and (self:getUid() .. ': ') or '') .. errortext
			_private[self].superHandler:addError(errortext)
		end
		-- have to store it myself, too. otherwise, I would always be plausible...
		table.insert(_private[self].errors, errortext)
	end
	return true
end

function FoundationClass:addInfobox()
	_debug(self, 1, 'entering FoundationClass:addInfobox(), from ' .. tostring(self))
	return false
end

function FoundationClass:addOutput(content)
	_debug(self, 1, 'entering FoundationClass:addOutput(), from ' .. tostring(self))
	if type(content) == 'table' then
		_private[self].output:node(content)
		return true
	elseif mw.ustring.len(tostring(content)) > 0 then
		_private[self].output:wikitext(content)
		return true
	end
	return false
end

function FoundationClass:addPageBody()
	_debug(self, 1, 'entering FoundationClass:addPageBody(), from ' .. tostring(self))
	_debug(self, 2, ' rendering errors and warnings and adding them to output')
	local frame = mw.getCurrentFrame()
	_private[self].output:node(self:renderErrors())
			:node(self:renderWarnings())
	if self:goodToGo() then
		_private[self].output:wikitext('Please implement method <code>addPageBody()</code> to display page content!')
		return true
	end
	return false
end

function FoundationClass:addError(errortext)
	_debug(self, 1, 'entering FoundationClass:addError(errortext), from ' .. tostring(self))
	_debug(self, 3, '  with errortext ' .. tostring(errortext))
	local errortext = errortext
	if errortext and mw.ustring.len(errortext) > 0 then
		if _private[self].superHandler then
			_debug(self, 3, '  refering error to handler ' .. tostring(_private[self].superHandler))
			errortext = (self:getUid() and (self:getUid() .. ': ') or '') .. errortext
			_private[self].superHandler:addError(errortext)
		end
		-- have to store it myself, too. otherwise, I would always be plausible...
		table.insert(_private[self].errors, errortext)
	end
	return true
end

function FoundationClass:addWarning(warning)
	_debug(self, 1, 'entering FoundationClass:addWarning(errortext), from ' .. tostring(self))
	_debug(self, 3, '  with warning ' .. tostring(warning))
	local warning = warning
	if warning and mw.ustring.len(warning) > 0 then
		if _private[self].superHandler then
			_debug(self, 3, '  refering error to handler ' .. tostring(_private[self].superHandler))
			warning = (self:getUid() and (self:getUid() .. ': ') or '') .. warning
			_private[self].superHandler:addError(warning)
		end
		-- have to store it myself, too. otherwise, I would always be plausible...
		table.insert(_private[self].warnings, warning)
	end
	return true
end

function FoundationClass:getCoreData()
	_debug(self, 1, 'entering FoundationClass:getCoreData(), from ' .. tostring(self))
	return _private[self].coreData
end

function FoundationClass:getUid()
	_debug(self, 1, 'entering FoundationClass:getUid(), from ' .. tostring(self))
	return _private[self].uid
end

function FoundationClass:goodToGo()
	_debug(self, 1, 'entering FoundationClass:goodToGo(), from ' .. tostring(self))
	return _amIPlausible(self) and _private[self].initialized
end

function FoundationClass:initFromArgs(args)
	_debug(self, 1, 'entering FoundationClass:initFromArgs(args), from ' .. tostring(self))
	local _CFG = self.class.myConfiguration
	local args = args
	if not args or type(args) ~= 'table' then
		local getArgs = require('Module:Arguments').getArgs
		local frame = mw.getCurrentFrame()
		args = getArgs(frame)
	end
	if not _private[self].loadedDataMyself then
		-- if we didn't load our data ourselves, assume that it comes from the store and assume, it's plausible
		_plausibilityTest(self, args)
		self:myPlausibilityTest(args)
	end
	if _amIPlausible(self) then
		-- first set my uid
		if not _private[self].coreData[FoundationClass.globalConfig.uidFieldName] then
			_private[self].coreData[FoundationClass.globalConfig.uidFieldName] = self:getUid()
		end
		-- if I use smw as store, also set my class
		if FoundationClass.usesDataStore(self.class, 'smw') and not _private[self].coreData[FoundationClass.globalConfig.smwClassProperty] then
			_private[self].coreData[FoundationClass.globalConfig.smwClassProperty] = self.class.name
		end
		-- get the data from args into _private[self].coreData
		for param, paramdata in pairs(_CFG.parameter) do
			if paramdata.cardinality == 'single' then
				_private[self].coreData[param] = args[param]
			else
				-- multivaluefield and given
				if type(args[param]) == 'table' then
					_private[self].coreData[param] = args[param]
				else
					local values
					if args[param] then
						values = {}
						for fragment in mw.text.gsplit(args[param], _CFG.parameter[param].sf and _CFG.parameter[param].sf.delimiter or _CFG.global.delimiter, true) do
							if fragment and mw.ustring.len(mw.text.trim(fragment)) > 0 then
								table.insert(values, mw.text.trim(fragment))
							end
						end
					end
					_private[self].coreData[param] = values
				end
			end
		end
		-- here we do some individual argument processing
		_debug(self, 3, ' calling self:myArgumentProcessing(_private[self].coreData)')
		_private[self].coreData = self:myArgumentProcessing(_private[self].coreData)
		_debug(self, 3, ' object initialized with data:<pre>' .. FoundationClass.myTableTools.printTable(_private[self].coreData) .. '</pre>')
		--this can cause fatal error, if coreData contains to much data, for instance references to title-objects
		_private[self].initialized = true
	end
	return _private[self].initialized
end

function FoundationClass:initFromData(data)
	-- this takes data that comes from a data store and initializes itself with it
	-- if we use data store smw, this makes a conversion from propery indexed data to parameter indexed data
	-- if we use both data stores, data from cargo has precedence
	_debug(self, 1, 'entering FoundationClass:initFromData() to do something, from ' .. tostring(self))
	_debug(self, 3, '  got data:<pre>' .. FoundationClass.myTableTools.printTable(data) .. '</pre>')
	local data = data
	_private[self].loadedDataFromDataStore = true
	if FoundationClass.usesDataStore(self.class, 'smw') then	-- if we have store cargo, we take the dat as is.
		-- transform the data array from { property_name : value } to { paramter : value }
		local properties = FoundationClass.smwGetProperty2ParameterTranslationTable(self.class)
		for property, param in pairs(properties) do
			local property_ = property
			local property = mw.ustring.gsub(property_, '_', ' ')
			if data[property_] and not data[param] then
				data[param] = data[property_]
				data[property_] = nil
			end
			if data[property] and not data[param] then
				data[param] = data[property]
				data[property] = nil
			end
		end
	end
	data = self:myDataAdjustments(data)
	if FoundationClass.myTableTools.size(data) > 0 then
		return self:initFromArgs(data)
	else
		return false
	end
end

function FoundationClass:initMyself(uid)
	_debug(self, 1, 'entering FoundationClass:initMyself() to fetch my own data from datastore, from ' .. tostring(self))
	local _CFG = self.class.myConfiguration
	local uid = uid or self:getUid()
	local myData = {}
	if uid and FoundationClass.usesDataStore(self.class, 'cargo') then
		_debug(self, 2, ' using datastore \'cargo\' with uid: ' .. uid)
		-- build the query
		local query = { tables = _CFG.global.cargoTable, fields = {}, where = ''}
		local wherefield = FoundationClass.globalConfig.uidFieldName
		local wherefor = '"' .. uid .. '"'
		query.where = wherefield .. '=' .. wherefor
		local declaration = FoundationClass.cargoGenerateTableStructure(self.class)
		for field, _ in pairs(declaration) do
			table.insert(query.fields, field)
		end
		local result = FoundationClass.myCargoUtil.query(query, {limit = 1})
		if result and result[1] and type(result[1]) == 'table' and FoundationClass.myTableTools.size(result[1]) > 0 then
			-- now we have data, call initFromData()
			_debug(self, 2, '  Got data from cargo query, storing it')
			myData = result[1]
		elseif not FoundationClass.usesDataStore(self.class, 'smw') then
			_debug(self, 2, '  Could not initialize by myself: Cargo query for \'' .. wherefield .. '=' .. wherefor .. '\' in table \'' .. _CFG.global.cargoTable .. '\' did not yield any result.')
			_debug(self, 3, '  Query was<pre>' .. FoundationClass.myTableTools.printTable(query) .. '</pre>')
			self:addError('Could not initialize by myself: Cargo query for \'' .. wherefield .. '=' .. wherefor .. '\' in table \'' .. _CFG.global.cargoTable .. '\' did not yield any result.')
		end
	end
	if uid and FoundationClass.usesDataStore(self.class, 'smw') then
		_debug(self, 2, ' using datastore \'smw\' with uid: ' .. uid)
		-- build the query
		local query = { select = {}, fields = {}, where = ''}
		query.select[FoundationClass.globalConfig.smwClassProperty] = self.class.name
		local wherefield = FoundationClass.globalConfig.uidFieldName
		local wherefor = '"' .. uid .. '"'
		query.select[wherefield] = wherefor 
		local properties = FoundationClass.smwGetProperty2ParameterTranslationTable(self.class)
		for property, _ in pairs(properties) do
			table.insert(query.fields, property)
		end
		local result = FoundationClass.mySmwUtil.query(query, {limit = 1})
		if result and result[1] and type(result[1]) == 'table' and FoundationClass.myTableTools.size(result[1]) > 0 then
			for property, smwdata in pairs(result[1]) do
				if not myData[property] then
					myData[property] = smwdata
				end
			end
		end
	end
	if not FoundationClass.myTableTools.size(myData) then
		if not uid then
			_debug(self, 2, '  Could not initialize by myself: No valid uid was provided. Was type \'' .. type(uid) .. '.')
			self:addError('Could not initialize by myself: No valid uid was provided. Was type \'' .. type(uid) .. '.')
		elseif FoundationClass.usesDataStore(self.class, 'both') then
			_debug(self, 2, '  Could not initialize by myself: Neither Cargo nor Smw provided any data. Was looking for \'' .. FoundationClass.globalConfig.uidFieldName .. ' with uid ' .. 
				uid .. ' in class ' .. self.class.name .. '.')
			self:addError('Could not initialize by myself: Neither Cargo nor Smw provided any data. Was looking for \'' .. FoundationClass.globalConfig.uidFieldName .. ' with uid ' .. 
				uid .. ' in class ' .. self.class.name .. '.')
		elseif FoundationClass.usesDataStore(self.class, 'cargo') then
			_debug(self, 2, '  Could not initialize by myself: Cargo query for \'' .. FoundationClass.globalConfig.uidFieldName .. '=' .. uid .. '\' did not yield any result.')
			self:addError('Could not initialize by myself: Cargo query for \'' .. FoundationClass.globalConfig.uidFieldName .. '=' .. uid .. '\' did not yield any result.')
		else
			_debug(self, 2, '  Could not initialize by myself: Smw query in class \'' .. self.class.name .. '\' for \'' .. FoundationClass.globalConfig.uidFieldName .. '=' .. uid .. '\' did not yield any result.')
			self:addError('Could not initialize by myself: Smw query in class \'' .. self.class.name .. '\' for \'' .. FoundationClass.globalConfig.uidFieldName .. '=' .. uid .. '\' did not yield any result.')
		end
	else
		-- now we have data, call initFromData()
		_debug(self, 2, '  Got data from query, calling self:initFromData(myData)')
		_private[self].loadedDataMyself = true
		return self:initFromData(myData)
	end
	return false
end

function FoundationClass:render()
	_debug(self, 1, 'entering FoundationClass:render(), from ' .. tostring(self))
	self:addOutput(self:renderCategories())
	local ret = tostring(_private[self].output)
	local debugLevel = FoundationClass.globalConfig.debugLevel or self.class.myConfiguration.global.debugLevel
	if debugLevel then
		ret = ret .. '\n\n' .. '<h2>Debug level is ' .. debugLevel .. '</h2>\n' .. ClassDebug:printLog(debugLevel)
	end
	return ret
end

function FoundationClass:renderCategories()
	_debug(self, 1, 'entering FoundationClass:renderCategories(), from ' .. tostring(self))
	node = mw.html.create('')
	if _private[self].categories and (#_private[self].categories > 0) and (self:getUid() == mw.title.getCurrentTitle().prefixedText) then
		for _, category in pairs(_private[self].categories) do
			node:wikitext('[[Category:' .. category .. ']]')
		end
	end
	return node
end

function FoundationClass:renderErrors()
	_debug(self, 1, 'entering FoundationClass:renderErrors(), from ' .. tostring(self))
	local _CFG = self.class.myConfiguration
	local error = require('Module:Error').error
	node = mw.html.create('')
	if #_private[self].errors > 0 then
		if _CFG.global.gardeningCategory and mw.title.getCurrentTitle().namespace ~= 10 then
			-- we have errors and we are currently not in template namespace. place article in gardening category
			self:addCategory(_CFG.global.gardeningCategory)
		end
		node:wikitext('<h2 style="font-weight:bold;background-color:light-red;color:red">Fehler</h2>')
		for _, str in pairs(_private[self].errors) do
			node:wikitext(error{ message=str, tag='div'})
		end
	end
	return node
end

function FoundationClass:renderWarnings()
	_debug(self, 1, 'entering FoundationClass:renderWarnings(), from ' .. tostring(self))
	node = mw.html.create('')
	if #_private[self].warnings > 0 then
		node:wikitext('<h2>Hinweise</h2>')
		local lis = mw.html.create('')
		for _, str in pairs(_private[self].warnings) do
			lis:tag('li')
				:wikitext(str)
				:done()
		end
		node:tag('ul')
			:node(lis)
	end
	return node
end

function FoundationClass:setSortkey(sortkey)
	_debug(self, 1, 'entering FoundationClass:setSortkey(sortkey) with sortkey ' .. (sortkey and tostring(sortkey) or 'EMPTY') .. ', from ' .. tostring(self))
	local sortkey = sortkey
	if sortkey and mw.ustring.len(sortkey) > 0 then
		if not _private[self].superHandler then
			local frame = mw.getCurrentFrame()
			frame:callParserFunction('DEFAULTSORT:' .. sortkey, 'noerror')
			-- foobar. but viable workarount until new ipso is running
			if mw.ext and mw.ext.displaytitle then
				mw.ext.displaytitle.set(sortkey)
			end
		end
	end
	return true
end

function FoundationClass:setUid(uid)
	_debug(self, 1, 'entering FoundationClass:setUid(uid), from ' .. tostring(self))
	if uid and (type(uid) == 'table' or type(uid) == 'integer') then
		_private[self].uid = uid
		return true
	end
	return false
end

function FoundationClass:storeData()
	_debug(self, 1, 'entering FoundationClass:storeData(), from ' .. tostring(self))
	local _CFG = self.class.myConfiguration
	local thisPage = mw.title.getCurrentTitle()
	local ret = false
	local lang = mw.language.getContentLanguage()
	if FoundationClass.usesDataStore(self.class, 'cargo') and thisPage.namespace == 10 and lang:ucfirst(thisPage.text) == lang:ucfirst(_CFG.template.name) then
		-- we must check for cargo data store first, because declaration must take place on namespace template where we have no data...
		_debug(self, 2, ' proceeding (cargo data store detected, poceeding to declare)')
		-- declaration of the cargo-table
		local declaration = self.class.cargoGenerateTableStructure(self.class)
		-- remember: self refers to an object not an class(!!!!) and this method is a static, so we have to call it directly and not with the colon operator
		local ret = FoundationClass.myCargoUtil.declare(_CFG.global.cargoTable, declaration)
		if mw.ustring.len(ret) > 0 then
			self:addWarning(ret)
		end
	end
	if _amIPlausible(self) and _private[self].initialized and not _private[self].loadedDataMyself then
		_debug(self, 2, ' proceeding (plausible, initialized and got data from extern)')
		if FoundationClass.usesDataStore(self.class, 'cargo') then
			-- now store the cargo data
			local stash = {}
			local declaration = FoundationClass.cargoGenerateTableStructure(self.class)
			for field, _ in pairs(declaration) do
				if _private[self].coreData[field] then
					if type(_private[self].coreData[field]) == 'table' then
						stash[field] = table.concat(_private[self].coreData[field], (_CFG.parameter[field].sf and _CFG.parameter[field].sf.delimiter or _CFG.global.delimiter))
					else
						stash[field] = _private[self].coreData[field]
					end
				end
			end
			-- individual adjustments
			stash = self:myStashAdjustments(stash, 'cargo')
			-- we dont want myStashAdjustments add any fields that is not a cargo field (in case it accidently added a field, that was meant for smw)
			if stash and type(stash) == 'table' then
				for field, _ in pairs(stash) do
					if not declaration[field] then
						stash[field] = nil
					end
				end
			end
			if stash and FoundationClass.myTableTools.size(stash) > 0 then
				local result = FoundationClass.myCargoUtil.store(_CFG.global.cargoTable, stash)
				if mw.ustring.len(result) > 0 then
					self:addWarning(result)
				end
				ret = true
			else
				ret = false
			end
		end	-- of if FoundationClass.usesDataStore(self.class, 'cargo') then
		if FoundationClass.usesDataStore(self.class, 'smw') then
			-- now store smw properties
			local stash = {}
			local properties = FoundationClass.smwGetProperty2ParameterTranslationTable(self.class)
			-- first get all parameter and their data in stash
			for _, parameter in pairs(properties) do
				if _private[self].coreData[parameter] then
					stash[parameter] = _private[self].coreData[parameter]
				end
			end
			-- individual adjustments, still with parameter as keys
			stash = self:myStashAdjustments(stash, 'smw')
			-- now convert the stash keys from parameter to property
			-- that also takes care of any fields, that were accidently added for a cargo store but have no property assigned
			if stash and FoundationClass.myTableTools.size(stash) > 0 then
				local stash_new = {}
				for property, parameter in pairs(properties) do
					stash_new[property] = stash[parameter]
				end
				stash = stash_new
			end
			if stash and FoundationClass.myTableTools.size(stash) > 0 then
				local result
				if _CFG.global.smwIsSubobject then
					result = FoundationClass.mySmwUtil.subobject(stash, self:getUid())
				else
					result = FoundationClass.mySmwUtil.set(stash)
				end
				if mw.ustring.len(result) > 0 then
					self:addWarning(result)
				end
				ret = true
			else
				ret = false
			end
		end	-- of if FoundationClass.usesDataStore(self.class, 'smw') then
	end
	return ret
end

function FoundationClass:method()
	_debug(self, 1, 'entering FoundationClass:method() to do something, from ' .. tostring(self))
	return true
end

-- these are special methods, so they are placed here. they are kind of abstract-ish in a way, that they thow a lua exception
-- if you don't have them implemented on your inherited class
function FoundationClass.static:mySfDynamicFieldAttribute(fieldname, attribute, value)
	_debug(self, 1, 'ERROR: entering FoundationClass.static:mySfDynamicFieldAttribute(fieldname, attribute, value), from ' .. tostring(self))
	error('You have to implement ' .. tostring(self.class) .. '.static:mySfDynamicFieldAttribute(fieldname, attribute, value). See Module:Foundationclass for documentation on this! (calling from ' .. tostring(self) .. ')', 1)
end

function FoundationClass:myArgumentProcessing(coreData)
	_debug(self, 1, 'ERROR: entering FoundationClass:myArgumentProcessing(coreData), from ' .. tostring(self))
	error('You have to implement ' .. tostring(self.class) .. ':myArgumentProcessing(coreData). See Module:Foundationclass for documentation on this! (calling from ' .. tostring(self) .. ')', 1)
end

function FoundationClass:myDataAdjustments(data)
	_debug(self, 1, 'ERROR: entering FoundationClass:myDataAdjustments(data), from ' .. tostring(self))
	error('You have to implement ' .. tostring(self.class) .. ':myDataAdjustments(coreData). See Module:Foundationclass for documentation on this! (calling from ' .. tostring(self) .. ')', 1)
end

function FoundationClass:myPlausibilityTest(args)
	_debug(self, 1, 'ERROR: entering FoundationClass:myPlausibilityTest(args), from ' .. tostring(self))
	error('You have to implement ' .. tostring(self.class) .. ':myPlausibilityTest(args). See Module:Foundationclass for documentation on this! (calling from ' .. tostring(self) .. ')', 1)
end

function FoundationClass:myStashAdjustments(stash)
	_debug(self, 1, 'ERROR: entering FoundationClass:myStashAdjustments(stash), from ' .. tostring(self))
	error('You have to implement ClassName:myStashAdjustments(stash). See Module:Foundationclass for documentation on this! (calling from ' .. tostring(self) .. ')', 1)
end

return FoundationClass