--Security table and Table both have the same keys
--however, the security table's values are numbers representing
--the current security level of execution.  and Table's values
--are the actual methods/properties of the class.\
--Parent is the parent, pass nil if no parent.
function newObj(table, securityTable, parent)
    local rTable = {}
    local mTable = {}
    local sTable = securityTable
    local real = table
	
	for k,v in pairs(real) do
		if v == real then
			real[k] = nil
		end
	end
	
    real.Parent = parent

	
    function mTable.__index(t,k)
        if t == nil or k == nil then
            return nil
        end
        for key,val in pairs(sTable) do
            if key == k then
                if val > code_level() then
                   return nil
                else
                return real[k]
                end
            end
        end
        if real.Parent ~= nil then 
            return real.Parent[k]
        end
    end

    function mTable.__newindex(t,k,v)
        if t == nil or k == nil or v == nil then
            return
        end
        for key,val in pairs(sTable) do            
            if key == k then
                if val > code_level() then
                error("Improper set attempt on protected object")
                else
                real[k] = v
                return
                end
            end
        end
        if real.Parent == nil then return; end;
        if real.Parent[k] ~= nil then 
        real[k] = v
        sTable[k] = real.Parent:GetSecurityRequire(k);
        end
    end
    function rTable:IsA(table)
        if real.Parent == table:SuperClass() then
            return true
        else
        if real.Parent == nil then return false; end
         return real.Parent:IsA(table)
        end
        return false;
    end
    function rTable:GetSecurityRequire(key)
        if sTable[key] == nil then 
            if real.Parent ~= nil then 
                return real.Parent:GetSecurityRequire(key)
            end
        else
            return sTable[key]
        end
    end
    function rTable:SuperClass()
        return real.Parent
    end
	
	function rTable:create()
		local newReal = {}
		local newSecure = {}
		
		for k,v in pairs(real) do
			newReal[k] = v
		end
		
		for k,v in pairs(sTable) do
			newSecure[k] = v
		end	
		return newObj(newReal, newSecure, real.Parent)
	end

local function InnerIter(target, spot)
            if code_level() < 5 then
                return nil, nil, false
            end 

			local key, val  = next(target, spot)
            if key == "Parent" then 
                return key, val, true
            end 
            return key, val, false 
end

	
	function rTable:Pairs()
            if code_level() < 5 then
                local fail = function() return nil, nil; end
                return fail, nil
            end 
            local loopTarget = real
            local iterTarget = InnerIter
            local function iter(target, spot)
                local key, val, changeTarget
                key, val,changeTarget  = iterTarget(loopTarget,spot)
                if changeTarget == true then
                    iterTarget, loopTarget = loopTarget.Parent:Pairs()
                    return key,val 
                end
                return key,val
            end

		return iter, looptarg, nil
	end
	
setmetatable(rTable, mTable)
return rTable
end