bmcclure wrote:
It looks like Python keeps a list of ReadOnly attributes for the DOM library, and checks against that list when setting the value. I would still need to figure out set-once values, though. Maybe the _new() function for the object would bypass the read-only check.
Well, true constants would be initialized when creating the object, right? So, these would be put into YourClass_new. For set-once, you can use bit flags and check them in the setter. Since each char (1 byte) can store 8 bit flags, you should be able to have enough for your needs without wasting memory. Also, since bit-flags modify / retrieve a single-bit at a time, you can easily check if the value is set and set it.
Here's an example. It only looks bloated because the comments
Code:
YourClass_setFunction(YourClassObject, setValue)
{
;"b1" would store the read-only bit flags (as a uchar)
;this would leave 3 bytes of that word for your needs - a short, some chars, etc.
;since this function sets a word, we will start at "b2"
;I would presume we could store a word starting at "b1a", but it looks weird to me
;check the read-only bit for this value ("b1-1")
if !Class_getValue(YourClassObject, "b1-1", "uchar")
{
;since it hasn't been set yet, we can set the value
;set the read-only bit for this value (since it's a write-once value)
Class_setValue(YourClassObject, "b1-1", true, "uchar")
;you can either return the setter's return (the previous value) or your own
;also, you can specify the type (this call uses "uint" - the default)
return Class_setValue(YourClassObject, "b2", setValue)
}
;value was set once, return a value of your liking
;I chose the previous value (for consistency)
return Class_getValue(YourClassObject, "b2")
}
I could also shorten this a little with a wrapper for read-only. It would only shorten it by a line. It would, however, allow using the
ternary operation.
Code:
YourClass_setFunction(YourClassObject, setValue)
{
return Class_canWrite(YourClassObject, "b1-1", "uchar")
? Class_setValue(YourClassObject, "b2", setValue)
: Class_getValue(YourClassObject, "b2")
}
Class_canWrite would return true (1) if the bit flag is unset (0), and return false (0) if the bit flag is set (non-zero). Also, if unset, it would automatically set it before returning. Then, you can use the ternary operation to set your value or return a different value if you cannot set it. Of course, if you didn't return the previous value (the return from setValue), then you couldn't use the ternary operation, but at least you don't have the headache of the bit flag.
Like the first function, "b1-1" is the read-only bit flag for the specified value ("b2"), and "uchar" is the type that it is stored as. For example, you can store bit-flags in char, uchar, short, ushort, int, and uint types - number of bit-flags based on type. Unsigned versus signed only matters if you ever return all the bit flags at once - ex.
Class_getValue(YourClassObject, "b1", "uchar"). I use unsigned, just because I'm used to it. Either behave the same way when used as bit-flags. You cannot use float, double, UInt64 or Int64 though. There is no check, just this warning (which will also be on the site).
_________________
As always, if you have any further questions, don't hesitate to ask.
Add OOP to your scripts via the
Class Library. Check out
my scripts.
Login
Register
FAQ
Search
