upcast | A JavaScript type | Frontend Utils library

every upcaster in the upcaster chain is called only when it finds an 'old' event to convert to the new one. New events that are fired are the new version of it, so the upcaster will not be used for that.

Upcasters are used when:

• An aggregate is loaded (without snapshot) and an old event is encountered
• A projection is replayed and an old event is encountered

In all other cases, it will be the new event, so the upcaster won't have to be fired. The upcaster is there so aggregates can keep being loaded, and projections can be replayed from the beginning of the event store.

If this is not the case, we need to take a look at the Revision parameter on the old event definition and the new event definition. For example, if the old event had no @Revision annotation, the SimpleSerializedType needs a version of null or it won't match.

Please include the code of the upcasters if we need to dig further, that would help greatly!

This is the documented behaviour of bit64 package, see Arithmetic precision and coercion in ?bit64:

The fact that we introduce 64 bit long long integers – without introducing 128-bit long doubles – creates some subtle challenges

The multiplication operator * coerces its first argument to integer64 but allows its second argument to be also double: the second argument is internaly coerced to 'long double' and the result of the multiplication is returned as integer64

I Found the answer after some trial and error and examples of ckeditor. For some reason, there is still a problem with Angular 9 and even though it didn't throw any errors, the mentions still would not work. Fortunately, I was only going through 9 to upgrade to 11.

I removed the extraPlugins from the editorConfig and added a new function to initialise the mentionCustomization function.

You need to explicitly state what the lifetime of the Trait Object &'dyn DefDatabase is so that the borrow checker knows what the lifetime of any references held by the struct behind the pointer are. 'static is the default if you do not define it, or it cannot otherwise be determined from the context. See default trait object lifetimes in the rust language reference for more information.

Adding a lifetime to your Upcast trait definition allows you to drop 'static.

1. It depends; if you cast a Derived object to Base, the result is a new object created by omitting the fields that are not in the Base. However, if you cast a pointer to Derived (i.e. Derived*), the result is a pointer which points to the same object but whose type is Base*.

2. It depends; if you cast a Base object, you get a compile error unless you overload the typecast operator for doing such an operation (you have correctly observed that the values of the fields would otherwise be undefined). However, if you cast a Base* (a pointer) to Derived* (using dynamic_cast(p)), the result depends on the object the pointer points to. If it points to an instance of the Derived class (or its subclass), the result is a Derived* pointer to that object; otherwise, you get a nullptr pointer of type Derived*.

The rule for casting is https://port70.net/~nsz/c/c11/n1570.html#6.3.2.3p7 :

A pointer to an object type may be converted to a pointer to a different object type. If the resulting pointer is not correctly aligned for the referenced type, the behavior is undefined.

Also in case of structures https://port70.net/~nsz/c/c11/n1570.html#6.7.2.1p15 :

A pointer to a structure object, suitably converted, points to its initial member (or if that member is a bit-field, then to the unit in which it resides), and vice versa.

And then accessing https://port70.net/~nsz/c/c11/n1570.html#6.5p7 :

An object shall have its stored value accessed only by an lvalue expression that has one of the following types:88)

• a type compatible with the effective type of the object,
• a qualified version of a type compatible with the effective type of the object,
• a type that is the signed or unsigned type corresponding to the effective type of the object,
• a type that is the signed or unsigned type corresponding to a qualified version of the effective type of the object,
• an aggregate or union type that includes one of the aforementioned types among its members (including, recursively, a member of a subaggregate or contained union), or
• a character type.

as long as proper parameters are passed this should work right?

There is a vast ocean between "should work" and "is guaranteed to work". The goal is to write code that is guaranteed to work as intended – it has no undefined behavior, because there is no guarantee what happens when it's undefined.

In practice, most compilers will convert a non-virtual member function into a static function with a hidden this parameter. As long as the function doesn't use any data members that aren't part of the base class, it will probably work.

The problem with UB is that you can't predict it. Something that worked yesterday can fail today, with no rhyme or reason behind it. The compiler is given a lot of latitude on how to interpret anything that's technically undefined, and the race to find better optimizations means that unexpected changes can happen suddenly. Murphy's law says that these changes will be most evident when you're demoing the software to your most important boss or biggest customer.

So I found it out.

You need to specify that no parameters go into the functions. The parenthesis in ToString() do just that, as they differentiate returning a function from returning a result. I need more coffee.

I think you want to extend VersionedStruct instead of trying to do the magic mixes in class methods trick. That works really well: