Modul:Foundationclass

Module documentation[view] [edit] [history] [purge]

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

1. create your base module Module:Name
2. 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()
3. create and fill your configuration Module:Name/config
4. create your template Template:Name
5. create your form Form:Name
6. if applicable, create your category page Category:Name
7. 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

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:

1. 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
2. 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

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

 

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

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

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

• Module:Arguments
• Module:Collapse
• Module:Debug/class
• Module:Error
• Module:Infobox
• Module:Lua banner
• Module:Message box
• Module:SFfield
• Module:SFfield
• Module:TableTools
• Module:Yesno
• {{code}}
• Extension:TemplateData

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:

• MediaWiki:Classengine-content-documentation-methods
• MediaWiki:Classengine-content-documentation-properties
• MediaWiki:Classengine-template-module-page
• MediaWiki:Classengine-template-module-documentation-page
• MediaWiki:Classengine-template-module-class-page
• MediaWiki:Classengine-template-module-class-documentation-page
• MediaWiki:Classengine-template-module-config-documentation-page
• MediaWiki:Classengine-template-template-page
• MediaWiki:Classengine-template-template-documentation-page
• MediaWiki:Classengine-template-form-page
• MediaWiki:Classengine-template-category-page
• MediaWiki:Classengine-template-gardeningcategory-page
• MediaWiki:Classengine-template-property-page

Next in dev queue

1. have foundation class try to detect integer inputs (by td_type or cargo_type) and run a regexp in _plausibilityTest
2. have foundationclass use mw message system for printouts instead of hardcoded text
3. 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
			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
				if FoundationClass.globalConfig.ucfirst then
					property = lang:ucfirst(key)
				else
					property = key
				end
				properties[property] = { text = value, ucname }
			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
				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
			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 = {'html4strict', 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