Docs for wOOP 0.5

This will go over all the functions and ways to use wOOP. It's a tad different from other libraries.
Any optional arguments will be shown by being wrapped in [ and ].
To create a class, you can use something similar to this:

class "className" ["extends"]
{
	--data
}

This will create a class called "className" and if "extends" is provided, it'll extend that class (inherit all data). The table is what contains all the properties and methods. "extends" defaults to "base", the root class.

To create an object, you can just call the class name like a function (i.e. className()). With constructors,   you can supply arguments when you call it (className(1, 2, 3)). This is *NOT* a table, it is a userdata generated using "newproxy". This allow people to use the __gc and __len metamethods.

To make a constructor, define the "__settings" table within the class data. Create the function "new" and make it return a table containing certain items. In example:

class "coordinates"
{
	x=0,
	y=0,
	__settings=
	{
		new=function(x,y)
			return {x=x,y=y}
		end
	}
}

Calling coordinates(1, 3) will give you a table (really a proxy to a table) containing {x=1,y=3}.

As for the __ at the beginning of that, that creates a private value. This is another advantage of using proxies: they can actually act as proxies! The __settings value and any other private values can be accessed by using one of the psuedomethods.

Wait, what's a psuedomethod you say? A psuedomethod is quite plain: it's a table with the __call metamethod set. Why in the world would I do this!?

Now, self can be used without having to use methods! You can just use a plain function:

class "coordinates"
{
	_x=0,
	_y=0,
	__settings=
	{
		new=function(x,y)
			return {x=x,y=y}
		end
	},
	slide=function(x,y)
		self._x=self.x+x
		self._y=self.y+y
	end,
	coords=function()
		return {x=self._x,y=self._y}
	end
}

The function is auto-converted to the table and auto-assigned the metatable: not to worry! Now you can just use the self value from any public psuedomethod!

As for the single _, that designates it as a read only value! Attempting to set it from anything outside a psuedomethod will give an error.

Another powerful feature of this is the "object metatable" (abbreviated to omt in the code). This is a metatable that applies to the objects (kinda obvious). To use it, just define "__omt" as a table containing all the contents! Woohoo, simplicity is good!

By the way, using getmetatable or setmetatable on any object will give an error. Sorry, but the metatables can be set with the object metatable! You shouldn't mess with the objects directly, modify the __omt. There is also a __mt for the class itself.

Oh, and an object cannot have any new values attached to it. The __newindex locks out any NEW value.

One last thing. The default psuedomethods and properties are listed here as well.

.isA("classname")
A psuedomethod that checks if it is a class or extends one.

.className
Set every time by the library, but it's global anyways.

.__omt
The default omt contains nothing.

.__mt
The default mt contains only __tostring=function(a) return "Class "..a.className end

.__settings
The default constructor returns a blank table.

Thank you for using wOOP.