BorlandTalk.com

M_R · Guest

I'm trying to stora a class which should hold either an int-value or a
pointer to an int-value. (Element 'type' contains information about
which of the both is saved here).

If I have a constant, I store the int-value, if it is a 'dynamic'
value, e.g. the changing vlaue of a variable v, I use the pointer
(i.e. &v).

Now I need to store a 'dynamic' property value, e.g. for a TBitmap
my_bitmap 'my_bitmap->Width'. Unfortunately a property has no adress.

So is there a way to expand my class that way I can initiate it with a
property somehow, so that a get_val-method() inside it would return
the actual value this property contains?

~~~~~~
The (reduced to the essential) class is this:

class MyArg {
public:
char type; // valid chars:'i' (int), 'I' (int *)
private:
union {
int value_int;
int *value_int_ptr;
};
public:
MyArg() {
init(0);
}
void init(int _val) {
type='i';
value_int=_val;
}
void init(int *_val_ptr) {
type='I';
value_int_ptr=_val_ptr;
}
get_value(void) {
return(type=='i' ? value_int : *value_int_ptr);
}
};

~~~~~~~~~~~~~~~

Thanks a lot,

Michael

Remy Lebeau (TeamB) · Guest

<M_R> wrote

M_R · Guest

Thanks, Gambit, for your very extensive answer.

I temporarily 'solved' my problem with defining the possibility to
give a pointer to a function which is called to evaluate the
int-value.

This works fine so far, but your solutions seem to be more elegant, so
I consider changing my design. I especially like your first version,
because as it seems there is no need to create a new class as in the
second approach (or looking at my design function) for each new
property, e.g. my_bitmap->Width, my_bitmap->Height, ...

Thanks a lot,

Michael

M_R · Guest

Being curious about the two ways, I tried both (and both worked fine),
I have some smaller questions about them:

I'm using BCB5

First I had to modify them a little, to make it run, so I copied the
modified classes (and a little test). The '???' indicates where I made
a necessary modification, hoping not mess things up...

Way 1)

#include <TypInfo.hpp>

enum MyArgType {matInt, matIntPtr, matObjProp};

class MyArg
{
private:
union
{
int value;
int* value_ptr;
struct {
TObject* obj;
PPropInfo prop;
};
};
public:
MyArgType type;
MyArg()
{
init(0);
}
void init(int _val)
{
type = matInt;
value = _val;
}
void init(int *_val_ptr)
{
type = matIntPtr;
value_ptr = _val_ptr;
}
void init(TObject *_obj, const AnsiString &PropName)
{
type = matObjProp;
obj = _obj;
prop = GetPropInfo(obj, PropName, TTypeKinds()/*???*/);
}
int get_value(void)
{
if( type == matInt )
return value;
else if( type == matIntPtr )
return *value_ptr;
else
return GetOrdProp(obj, prop);
}
};

~~~~~~~

bool Test_MyArg(void) {
bool success=true; // so far...
class MyArg my_arg;
my_arg.init(Application->MainForm, "Height");
success=(my_arg.get_value()==Application->MainForm->Height);
if(success) {
Application->MainForm->Height++;
success=(my_arg.get_value()==Application->MainForm->Height);
}
return(success);
}

~~~~~~~

Questions

a) What is the meaning of the TTypeKinds-argument in GetPropInfo?
(BCB5 needs it). I did not find any information in the help-system. I
would suppose it's the set of (from the user) allowed types. So the
function would e.g. return NULL, if the user allows only tkChar, but
the property is of type int!?? (Argument TTypeKinds() would mean:
accept any type...)

a2) Is the snipppet

else {
Typinfo::TTypeKind kind=prop->PropType[0]->Kind; // ???
assert(kind==tkInteger);
return GetOrdProp(obj, prop);
}

correct, which should test, if the property really is an
int-property?

[ I' m little irritated about prop->PropType is a pointer to pointer
to TTypeInfo(, instead of just a pointer to TTypeInfo). The reason
might be that prop could hold more than one TTypeInfo!?]

b) Istead of giving the ' void init(TObject *_obj, const AnsiString
&PropName)'-function the property-name, is it possible to give it some
kind of int-constant (calculated at compile-time)?

~~~~~~
~~~~~~

Way 2.

class MyArgValueBase/*???*/ {
public:
MyArgValueBase() {}
virtual ~MyArgValueBase() {}
virtual int get_value() = 0;
};

class MyArgValueInt : public MyArgValueBase
{
private:
int value;
public:
MyArgValueInt(int _value) : MyArgValueBase(), value(_value) {}
virtual int get_value() { return value; }
};

class MyArgValueIntPtr : public MyArgValueBase
{
private:
int* value;
public:
MyArgValueIntPtr(int *_value) : MyArgValueBase(), value(_value)
{}
virtual int get_value() { return *value; }
};

class MyArgValueBitmapWidth : public MyArgValueBase
{
private:
Graphics::TBitmap *bmp;
public:
MyArgValueBitmapWidth(Graphics::TBitmap *_bmp) :
MyArgValueBase(), bmp(_bmp) {}
virtual int get_value() { return bmp->Width; }
};

~~~~ Extention and Test-Function

class MyArgValueFormHeight : public MyArgValueBase
{
private:
TForm *form;
public:
MyArgValueFormHeight(TForm *_form) : MyArgValueBase(),
form(_form) {}
virtual int get_value() { return form->Height; }
};

bool Test_MyArgValue(void) {
bool success=true; // so far...
class MyArgValueFormHeight my_arg(Application->MainForm);
success=(my_arg.get_value()==Application->MainForm->Height);
if(success) {
Application->MainForm->Height++;
success=(my_arg.get_value()==Application->MainForm->Height);
}
return(success);
}

Question:

1) I suppose the base-class should be MyArgValueBase (instead of class
MyArgValue)...

2) Yes, I agree, it's more elegant. But - as said - what I didn't like
that much is the need for having to create an additional class for
each property used. Isn't it possible this to be done automatically,
e.g. using 'template<..>' somehow?

Thanks a lot,

Michael

M_R · Guest

Sorry: when implementing 'way 1' this for TBitmap a problem arises:

Analysing it , I found out, the reason was, that

TPropInfo *property_info=GetPropInfo(image->Picture->Bitmap, "Height",
TTypeKinds() << tkInteger/*???*/);

(
and
PropInfo *property_info=GetPropInfo(image->Picture->Bitmap, "Height",
TTypeKinds());
too
)

returned NULL.

I tried it with an Image intitalized with a visible picture in the
designer Image1 too: same result...

I suppose the reason might be that TBitmap's Height is not published!?

So is there an alternative for GetPropInfo()? If not, how can the
Object-Inspector used when debugging this line can find and display
it?

~~~~~~~~~~~~

When copying and editing 'way2' I forgot the MyArg-class, so here it
is. But now I do not know how to initialize the constructor (or the
init), since - as I learned now - a property does not have an adress.
I marked the place as before with a ???

class MyArg2 // renaming it to avoid conflict with MyArg from 'Way
1'
{
private:
MyArgValueBase *value;
public:
MyArg2(MyArgValueBase* _value = NULL) { init(_value); }
void init(MyArgValueBase* _value) { value = _value; }
int get_value(void)
{
if( value )
return value->get_value();
return 0;
}
};

bool Test_MyArgValue2(void) {
bool success=true; // so far...
class MyArg2 my_arg(/*???*/); // how to initialize it correctly?
success=(my_arg.get_value()==Application->MainForm->Height);
if(success) {
Application->MainForm->Height++;
success=(my_arg.get_value()==Application->MainForm->Height);
}
return(success);
}

Thanks a lot in advance,

Michael

Remy Lebeau (TeamB) · Guest

<M_R> wrote

Remy Lebeau (TeamB) · Guest

<M_R> wrote

Remy Lebeau (TeamB) · Guest

<M_R> wrote