C4DS

C4DS

Just for future reference ...

The topic's tag indicates this to be "solved" when it definitely isn't.
But as this is a R16 issue only I guess no further time will be taken to figure out why this issue exists in R16 and not in newer releases. Also, there is currently no workaround as far as I know. The only thing one can do is check for the current C4D version running and avoid writing to a MultipassBitmap.

C4DS

Still getting nowhere ...

Following code uses only maxon::BaseArray and all compiles fine.

#include "c4d.h"

class ValuePair
{
private:
	Int32 mValue1;
	Int32 mValue2;

public:
	ValuePair() : mValue1(0), mValue2(0) {}
	~ValuePair() {}
};

class ValuePairArray
{
	MAXON_DISALLOW_COPY_AND_ASSIGN(ValuePairArray)

private:
	maxon::BaseArray<ValuePair> mBaseArrayValues;

public:
	ValuePairArray() {}
	~ValuePairArray() {}

	// move constructor
	ValuePairArray(ValuePairArray&& src) :
		mBaseArrayValues(std::move(src.mBaseArrayValues))
	{}

	// move assignment operator
	MAXON_OPERATOR_MOVE_ASSIGNMENT(ValuePairArray);

	// copy
	MAXON_WARN_UNUSED maxon::Result<void> CopyFrom(const ValuePairArray& src)
	{
		if (mBaseArrayValues.CopyFrom(src.mBaseArrayValues) == maxon::FAILED)
			return maxon::OutOfMemoryError(CREATE);
		return maxon::OK;
	}
};

class StorageWrapper
{
	MAXON_DISALLOW_COPY_AND_ASSIGN(StorageWrapper)

public:
	StorageWrapper() {}
	~StorageWrapper() {}

	// move constructor
	StorageWrapper(StorageWrapper&& src) :
		mBaseArray(std::move(src.mBaseArray))
	{}

	// move assignment operator
	MAXON_OPERATOR_MOVE_ASSIGNMENT(StorageWrapper);

	// copy
	MAXON_WARN_UNUSED maxon::Result<void> CopyFrom(const StorageWrapper& src)
	{
		if (mBaseArray.CopyFrom(src.mBaseArray) == maxon::FAILED)
			return maxon::OutOfMemoryError(CREATE);
		return maxon::OK;
	}

	maxon::BaseArray<ValuePairArray> mBaseArray;
};

void Test()
{
	ValuePairArray newitem;

	// using the ValuePairArray class directly
	maxon::BaseArray<ValuePairArray> arrayOfValuePairArray;

	arrayOfValuePairArray.Append(newitem);


	// using the ValuePairArray class via a storage wrapper class
	StorageWrapper storageHelper;
	
	storageHelper.mBaseArray.Append(newitem);
}

Following code continues on the previous code, but adds a maxon::HashMap.
And results in compiler error for the private assignment operator being inaccessible.
I just don't get it.


#include "c4d.h"

class ValuePair
{
private:
	Int32 mValue1;
	Int32 mValue2;

public:
	ValuePair() : mValue1(0), mValue2(0) {}
	~ValuePair() {}
};

class ValuePairArray
{
	MAXON_DISALLOW_COPY_AND_ASSIGN(ValuePairArray)

private:
	maxon::BaseArray<ValuePair> mBaseArrayValues;

public:
	ValuePairArray() {}
	~ValuePairArray() {}

	// move constructor
	ValuePairArray(ValuePairArray&& src) :
		mBaseArrayValues(std::move(src.mBaseArrayValues))
	{}

	// move assignment operator
	MAXON_OPERATOR_MOVE_ASSIGNMENT(ValuePairArray);

	// copy
	MAXON_WARN_UNUSED maxon::Result<void> CopyFrom(const ValuePairArray& src)
	{
		if (mBaseArrayValues.CopyFrom(src.mBaseArrayValues) == maxon::FAILED)
			return maxon::OutOfMemoryError(CREATE);
		return maxon::OK;
	}
};

class StorageWrapper
{
	MAXON_DISALLOW_COPY_AND_ASSIGN(StorageWrapper)

public:
	StorageWrapper() {}
	~StorageWrapper() {}

	// move constructor
	StorageWrapper(StorageWrapper&& src) :
		mBaseArray(std::move(src.mBaseArray)),
		mHashMap(std::move(src.mHashMap))
	{}

	// move assignment operator
	MAXON_OPERATOR_MOVE_ASSIGNMENT(StorageWrapper);

	// copy
	MAXON_WARN_UNUSED maxon::Result<void> CopyFrom(const StorageWrapper& src)
	{
		if (mBaseArray.CopyFrom(src.mBaseArray) == maxon::FAILED)
			return maxon::OutOfMemoryError(CREATE);
		if (mHashMap.CopyFrom(src.mHashMap) == maxon::FAILED)
			return maxon::OutOfMemoryError(CREATE);
		return maxon::OK;
	}

	maxon::BaseArray<ValuePairArray> mBaseArray;
	maxon::HashMap<Int32, ValuePairArray> mHashMap;
};

void Test()
{
	ValuePairArray newitem;
	Int32 key = 1;

	// using the ValuePairArray class directly
	maxon::BaseArray<ValuePairArray> arrayOfValuePairArray;
	maxon::HashMap<Int32, ValuePairArray> mapOfValuePairArray;

	arrayOfValuePairArray.Append(newitem);
	mapOfValuePairArray.Put(key, newitem);


	// using the ValuePairArray class via a storage wrapper class
	StorageWrapper storageHelper;
	
	storageHelper.mBaseArray.Append(newitem);
	storageHelper.mHashMap.Put(key, newitem);
}

Error	C2248	'ValuePairArray::operator =' : cannot access private member declared in class 'ValuePairArray'

C4DS

Hmm ... seems I have been doing it wrong all those years ???

According to this post in the legacy forum, the disallowing of copy and assignment isn't to be done in the class that is being used INSIDE a maxon::BaseArray (or maxon::HashMap).
It's the class that holds such basearray or hashmap as member which will need to provide the copy and assignment implementation.

I need to try this.

C4DS

Hello,

While implementing plugins in the past I managed to understand that for using a specific class into maxon::BaseArray one had to provide own copy and assignment functionality, instead of the default generated ones. This related to the fact that MAXON_DISALLOW_COPY_AND_ASSIGN needed to be defined.
In R20 and above the issue I experience does not seem to exist.
This probably due to changes in the SDK related to maxon::HashMap::Insert replacing the former maxon::HashMap::Put ... I haven't digged deeper, so it is just a thought I have.

However, with R16 .. R19, I experience a 'TestClass::operator = ': cannot access private member declared in class 'TestClass'.

This has been brought up quite a while, back in the days before R20, but mostly when using maxon::BaseArray.
So, now that I am using maxon::HashMap I encounter an issue I don't seem to know the solution for.

I do have provided the necessary constructors and operators to make it work for the maxon::BaseArray, but I seem to miss something for the maxon::HashMap. And I just seem not to be able to put my finger on ...

#include "c4d.h"

class TestClass
{
	MAXON_DISALLOW_COPY_AND_ASSIGN(TestClass)

private:
	Bool mBool;
	Int32 mInt32;

public:
	TestClass() : mBool(false), mInt32(0) {}
	~TestClass() {}

	// move constructor
	TestClass(TestClass&& src) :
		mBool(std::move(src.mBool)),
		mInt32(std::move(src.mInt32))
	{}

	// move assignment operator
	MAXON_OPERATOR_MOVE_ASSIGNMENT(TestClass);

	// copy
	MAXON_WARN_UNUSED maxon::Result<void> CopyFrom(const TestClass& src)
	{
		mBool = src.mBool;
		mInt32 = src.mInt32;
		return maxon::OK;
	}
};

void Test()
{
	// using BaseArray does compile

	maxon::BaseArray<TestClass> arrayTestClass;

	TestClass newitem;
	arrayTestClass.Append(newitem);

	// using HashMap does not compile
	// operator = cannot acces private member

	maxon::HashMap<Int32, TestClass> mapTestClass;

	TestClass newitem2;
	mapTestClass.Put(0, newitem2);
}

Error	C2248	'TestClass::operator =' : cannot access private member declared in class 'TestClass'

Now, I do understand the fact that the assignment operator is private for the hashmap data structure, and thus the reason for the error being reported. I just don't see what is missing in my TestClass?

C4DS

@m_magalhaes
Thanks for bringing this up, as it seems I had overlooked it on multiple occasions.
Which also points me to the fact that the R19 SDK did have a String::operator == ()
Also overlooked that all those years. I need better glasses.

C4DS

@mp5gosu
OK, got.
For R20 I could keep using the equality operator, for R21 and future this would probably not be the best solution.

I will update both R20 and R21 code with the appropriate Compare.

Maybe someone from SDK team will chime in and clarify the equality operator issue (if any).

C4DS

@mp5gosu
Thanks for the response, but I am not sure to understand what you are trying to say.

You're replying on the fact of using the equality operator that one could potentially run into problems.
Then you add a statement that using the equality operator is safe to use.
I am confused.

Furthermore, I don't see what old style enum values have to do with the current situation?
In R19 I perform a Compare which returns an Int. I compare this with 0, resulting in a Bool.
No enum is involved here, as far as I understand.
In R20 code no old style enums are used at all.

C4DS

While porting a plugin implementation between R19, R20, R21 I noticed a potential problem I might have introduced.

In R19 I had been using:

String stringA, stringB;
...
Bool match = (stringA.Compare(stringB) == 0);

In R20, due to the introduction of maxon::String the return value of the comparison was replaced from an Int to an enum COMPARERESULT.
For some obscure reason I managed to overlook this and had ported the original implementation to:

maxon::String stringA, stringB;
...
Bool match = (stringA == stringB);

Thus completely neglecting the Compare function.
While this seems to work, I am now looking into converting all my existing R20 code to again use the Compare function.
But I am wondering what possible problems I would face by keeping the current equality operator?

Daniel

C4DS

Everyone browsing this forum has probably noticed that the amount of spam has increased recently.
I have done my best to flag every post I come across of ... and it is quite easily to distinguish spam post from others from the subject line alone. Unfortunately, in order to flag the post one need to open it.

Anyway, I understand the SDK support team has more than enough things on their mind, helping out people genuinely looking for help, that they cannot find the time to look into solutions to prevent spamming.
I am more than happy to flag the posts, but that is all I can do, flag.

While I don't want to add even more work into your (SDK support) hands, here might be some advice or suggestion that could help in reducing said spam.
People seem to simply register an account, and immediately post spam ... and never to be seen again afterwards.
So, apart from removing the spam post, why not simply delete the account. Maybe even banning if that is possible.
The other suggestion I have is that it might be worthwhile to introduce a delay before a new user can post its first message after having created an account. Let's say 24 hours (just a suggestion), by the time the account/user is allowed to post he/she has already moved on.
But seriously, try to delete these spammer-accounts before the database gets so crowded it does affect the whole forum.

Thanks for reading.

C4DS

@s_bach said in Communication between DescriptionTool and GeUserArea:

The typical modern approaches are patterns like Model-View-Controller or Model-View-Presenter.

In such models, you don't "send data around".

Thanks for mentioning this.
As stated in my opening post, this is what I have been using, where the "model" is a singleton class, available as a global variable to all plugins to synchronize and share data. Maybe not quite the exact wording.
I was just wondering if there is another means of providing this "model" instead of using an instanced (singleton) class via a global variable?

So in your example, the interaction with the DescriptionToolData would write data into the model. And the GeUserArea would read that data from the model.

The example I provided isn't making use of a "model" as it already represented too much code just to point out the bug that slipped into R21. There I indeed used a very simplified solution by "sending data around".

But an overall "thank you" for bringing up the model-view discussion, as this made me realize I could use an observer pattern in another project of mine which would fix its current poorly chosen design.

Daniel

C4DS

@C4DS

Posts made by C4DS