Any progress on this issue? 

Geir Ove will look at it this week.

The problem is that we have a <topic type="#type"> definition that is not 
primary. 
Primary topic entities will not have their topic types replaced at the moment. 
Instead any given types will be added to the list of topic types. This is not 
really 
very useful. To get around this limitation I do think that we have to say 
something 
about which topic types should get replaced (to avoid having any primary topic 
types 
replaced).

Example:

<topic type="#type" replace-types="fd:organisasjonsenhet">

If we added support for the replace-types attribute, which takes a topic 
reference, 
to the <topic> element then DB2TM would be able to replace topic types that 
were 
instances of the type given in the replace-types attribute, even though the 
topic 
entity is not primary.

Hmmm. Adding a replace-types attribute sounds very ad-hoc. It seems to me that 
users 
are unlikely to pick up on this one, and that they will only add this kind of 
attribute after they run into problems and are told to fix it this way by us. I 
would feel better about this if we could come up with some more general 
solution.

I'm not sure I understand why this limitation is there in the first place. Why 
can't 
we change the topic type if the topic element is not primary?

Well, that is a good question. :)

I guess there is not really any reason to treat the types of a topic any 
different 
than its other characteristics. 

Replacing the topic type would work in this particular case, but we might run 
into 
issues if there were two different tables that reference the same topic and 
assign 
them different topic types. What do you think?

I've thought about this and it seems to me that the general issue is that of 
what to 
do when statements of a specific type are spread over different tables. 
Usually, 
that just doesn't happen. For the type it's conceivable that it might happen 
(because it's one kind of statement that really might occur in different 
places), 
but then again we generally consider multi-typing topics to be a bad thing and 
don't 
encourage it.

So it seems to me that if we treated the topic type the same way as other 
statements 
then we'd solve this problem, and most likely we would not create a new one. If 
we 
did create a new one it would probably a pretty obscure issue, and we could 
come up 
with an ad-hoc solution at that point (because for really obscure issues ad-hoc 
solutions can be defensible).

Does that make sense?

Yes, that makes sense, and I do agree with you. Lets remove the 
Entity.isPrimary 
check in the code so that all topics get their topic type replaced when changed.

This issue was closed by revision r416.