Show Posts

This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.


Messages - Shegit Brahm

Pages: 1 [2] 3 4 ... 7
16
I found a "workaround" to connect a merge with an ActionPin:

Go to toolbox "Activity Relationships", click "object flow" and connect Merge with ActionPin...

EA does not bother (validation check iO)

So either this is a bug that it needed a workaround in the end - or it is violated UML and a bug that it worked in the end....

Suggestions?

Thanks, Shegit

17
Uml Process / how to "merge" object flows in activity diagram
« on: June 26, 2019, 09:48:06 pm »
I have the following simple activity diagram:



My problem / question about is the last activity and its incoming object flows:

- how to model proper UML here?

In UML-Spec 2.5.1 I find these quotes:

15.2.3.1 Activities
An object token is a container for a value that flows over ObjectFlow edges [...]. An object token with no value in it is called a null token. [...] Each token is distinct from any other, even if it contains the same value as another.

15.2.3.4 Object Flows
Object tokens pass over ObjectFlows, carrying data through an Activity via their values, or carrying no data (null tokens). A null token can still be passed along an ObjectFlow and used like any other token.

15.3.3.5 Merge Nodes
A MergeNode is a control node that brings together multiple flows without synchronization. [...] if the outgoing edge is an ObjectFlow, then all
incoming edges must be ObjectFlows

16.2.3.3 Pins
The multiplicity bounds on a Pin constrain the total number of values that may be input or output by a single execution of an Action, not the number of tokens it contains (see the upperBound property inherited from ObjectNode). A Pin may hold null tokens that contain no values. [...] An Action cannot start execution if one of its InputPins has fewer values than the lower multiplicity of that InputPin.

16.2.3.4 Actions and Pins in Activities
Executing an Action in an Activity requires all of its InputPins to be offered all necessary tokens, as specified by their minimum multiplicity (except for the special cases of ActionInputPins and ValuePins, as discussed above).


I understand it that way, that my model is currently wrong - because it is impossible to have both object G as input due to the decision before.

So I have to reduce the object flows to 1 to succeed.

That seems to give me these options:

 1. set multiplicity to zero
 - but multiplicity is on value, not on token, so a token would be required to flow in
 - I just don't create even a null token in B if I decide for A
 2. use a separate merge for the object flow
 - simply said: the EA does not allow an object flow to an object or action pin
- could be a bug

Then there is more in spec:

15.4.3.3. Central Buffer Nodes

[...] It accepts all object tokens offered to it on all incoming flows, which are then held by the node. Held object tokens are offered to outgoing flows [...]. When an offer for a token is accepted by a downstream object node, that token is removed from the CentralBufferNode and moved to the accepting object node, as for any object node.

Well, sounds like a way out: any input is accepted and the moment an output is accepted, it is done.

Problem smaller:

the EA now offers only Dependency, Trace and Information Flow (2) - no object flow to the receiving Action Pin. All I could get is an object flow (1) to the related action. Which misses the visualization - might it be necessary because an action pin is unable to accept a token?


I found that I can use ExpansionNodes to have object flows in and out of a Merge Node.

Just my actions are no ExpansionRegions as in

16.14.22 ExpansionNode
An ExpansionNode is an ObjectNode used to indicate a collection input or output for an ExpansionRegion.



Suggestions how to get valid UML here?

PS: Sidenote: in some cases it is necessary that the object is transfered to a later action than the one right behind the merge / decision.


18
Update as I think I'm done:

I rebuild my query to avoid subqueries and take (implicit) inner joins instead.
That way it fits regardless the database used - unless database specific features are used.

The EA translate most things, so #WC# works in EA, not in HeidiSQL or AnySQL Maestro.
And + als string concatenation works in EA, not in HeidiSQL or AnySQL Maestro. (where mysql needs concat(), postgresql supports || too)

so
Code: [Select]
select * from t_xref xr
inner join
(select 'RefGUID=' + ob1ob.ea_guid  + ';RefName=' + ob1ob.name + ';' as something
from t_object ob2
inner join (select ob1.ea_guid, ob1.name from t_object ob1 where object_type = 'Signal') ob1ob
on ob1ob.ea_guid = ob2.ea_guid
) abc
on abc.something = xr.Description

turned to
Code: [Select]
select
xr.client, 'RefGUID=' + ob1s.ea_guid  + ';RefName=' + ob1s.name + ';' as something
from t_object obs1, t_xref xr
where 'RefGUID=' + ob1s.ea_guid  + ';RefName=' + ob1s.name + ';' = xr.Description
and obs2.object_type = 'Signal'

As you may notice: the deepest join was obsolete.
In the end I also used this line:
Code: [Select]
where xr.Description like ('RefGUID=' + ob1s.ea_guid + '#WC#')

why?

Because I renamed a signal after connecting it to a trigger and it keeps in t_xref safed with it's old name ... so I never found it.
In dialogues and gui the naming is correct.

19
thanks for that client option. I will have a look into it.

I have to narrow my "solved" for step two:
- it does not work on eap file
- it does not work on dbms based on mysql because step one returns 0.00 [for "+"]/ 0[for "&"] in the desired amount => step two returns entire t_xref / needs fixes
- it does work on dbms based on postgres

I copy'pasted the package from project browser via gui feature from ea project to ea project.
I think that is unproblematic.

Just the different implementation of memo fields seem the key factor here.

20
Maybe, just not in my specific case.

As my first step with select 'RefGUID=' + ob1ob.ea_guid  + ';RefName=' + ob1ob.name + ';'as something from works fine within eap file,
and a replacement check with "&" works as well for step one and pops same error on step two - I just don't know if & which additional SearchSQL hack could make it fit within eap file, too.

21
General Board / Re: Office MDG and SharePoint
« on: March 20, 2019, 11:13:52 pm »
I have no idea about it. As I have no / don't find the button "Publish to Sharepoint" I cannot see if there is a "help" button like on almost any other dialogue - is there any? maybe on the dialogue before?

I have only "publish to joomla" which has a help button that leads to https://sparxsystems.com/enterprise_architect_user_guide/14.0/model_publishing/publish_joomla.html, hence  with two clicks to this general publishing site: https://sparxsystems.com/enterprise_architect_user_guide/14.0/model_publishing/documentingprojects.html

no sharepoint there.

the model repository link https://sparxsystems.com/resources/user-guides/14.0/repository/model-repository.pdf contains sharepoint as an external source:
"Integrate Data from External Providers
The Pro Cloud Server helps you to integrate data from external providers into an Enterprise Architect Cloud model. A
variety of third-party providers can be connected to, including:"

(like https://sparxsystems.com/enterprise_architect_user_guide/14.0/model_repository/pcs_plugins_config.html also talks about same usage of sharepoint)

as far as I know Sharepoint, you definitly need to address a page that is able to take what EA delivers.
so a document library itself might be a starting point.


22
Solved. (update: for postgres dbms only, see below)

this link https://blog.lieberlieber.com/2014/08/26/enterprise-architect-sql-issue-on-selecting-note-fields/
brought me to the attempt to try it in a dbms EA project - works like a charm.

So it is a eap file only issue [update:] depending on the database - see below.

23
oh, yes, of course, thank you very much.

Well, now the error is changed to
DAO.Database [3118]
combination using a memo or ole object not possible
(xr.Description='RefGUID='+ob1ob.ea_guid +';RefName='+ob1ob.name+';')

even when I "wrap it" and put a (select abc.something) edf around to achieve a "not so visible concatenation".

Sounds like the string concat is not loved, while a given single string is accepted.

24
I saw that my join pattern was different in outer query, so I changed to:
Code: [Select]
select * from t_xref xr
inner join
(select 'RefGUID=' + ob1ob.ea_guid  + ';RefName=' + ob1ob.name + ';' as abc.something
from t_object ob2
inner join (select ob1.ea_guid, ob1.name from t_object ob1 where object_type = 'Signal') ob1ob
on ob1ob.ea_guid = ob2.ea_guid
) abc
on abc.something = xr.Description
resulting in new error code:
DAO.Database [3141]
the select statement includes a reserved word or argument name which has been entered wrong, wrong character set or is missing at all.

25
what I have:

a model with some signals, some statemachines and some triggers on state's transitions from type signal (=using existing signals as specification).

what I want:
search for a signal's name or ea_guid and find all triggers that are based on them (additionally their start state and end state)

what I did:
using advice in https://www.sparxsystems.com/forums/smf/index.php/topic,37989.msg236784.html to find corresponding states to a trigger (and their start state and end state), works well

What I observed:
in t_xref is also the link between a signal and its trigger:
in t_xref.Description there is "RefGUID={6BE433ED-92D8-4ff4-8CBF-BE947A2B5627};RefName=signaltrigger_to_stm3St2" and t_xref.Client contains the ea_guid of the trigger, e.g. "{AC0F2201-0378-46d7-B825-124F8220A686}"

So I thought:
I need to search for the signal's ea_guid in t_xref.Description and from there I will get the trigger via t_xref.Client

step one: create search column for signal (and use this advise: https://www.sparxsystems.com/forums/smf/index.php/topic,40370.msg247193.html):
Code: [Select]
select 'RefGUID=' + ob1ob.ea_guid  + ';RefName=' + ob1ob.name + ';'as something from
t_object ob2
inner join (select ob1.ea_guid, ob1.name from t_object ob1 where object_type = 'Signal') ob1ob on ob1ob.ea_guid = ob2.ea_guid

step two: search for that in t_xref.Description:
Code: [Select]
select * from t_xref where t_xref.Description in
    (select 'RefGUID=' + ob1ob.ea_guid  + ';RefName=' + ob1ob.name + ';'as something
        from t_object ob2
        inner join (select ob1.ea_guid, ob1.name from t_object ob1 where object_type = 'Signal') ob1ob
        on ob1ob.ea_guid = ob2.ea_guid
    )

throws the error:
DAO.Database [3342] invalid memo or OLE object in subquery ('t_xref.Description')

checking with fixed values - works fine:
Code: [Select]
select * from t_xref where t_xref.Description in
    ('RefGUID={77EB79E7-DA34-4532-B64B-8B0F26A82545};RefName=signaltrigger_to_stm3St3;',
    'RefGUID={6BE433ED-92D8-4ff4-8CBF-BE947A2B5627};RefName=signaltrigger_to_stm3St2;',
    'RefGUID={6BE433ED-92D8-4ff4-8CBF-BE947A2B5627};RefName=signaltrigger_to_stm3St2;')

Did I miss some general SQL knowledge here or is it EA specific and what can I do to solve it?

Thanks,
Shegit

26
thanks again, will take a look. Thought I could concentrate on an UML model for this software only.

now I understand that I don't understand enough of the UML (class diagram) to model UML (class diagram).

27
I see where you want wrong.
The "Attributes" you describe are not attributes at all.
Attributes are the properties of a class that are defined at design time. They have a fixed name and datatype at design time

What you are describing is some kind of generic "properties" system that can describe any sort of data structure.
I'm afraid you've fallen victim of the so called inner platform effect; google it  ;)

Geert

Thanks for your hint,
I understand it that way, that there is no live class modeling while software usage, there has to be "static" class modeling before the software runs.
- I guess that is the reason why someone suggested to make Class1 an abstract class and have three classes instead.


So I would say, my current suggestion has this flaw:
- the values of the instantiated object of any type Field, [] array or DictCollection cannot be stored anyhow because there is no attribute for it. and the data type of attributes to store values are dependent on other attributes to get theirs determined.

In ClassNone as the simplest case it already lacks it - so the "inner platform effect" happens already the moment I say "data type of attribute X depends on user decision" - is that effect understanding correct?

=> would it be useful to have a class for each possible data type combination?
- for ClassNone it would be ClassNoneInt and ClassNoneChar
... sounds a bit odd for DictCollection, even there are only pairs.

So how can I break the effect and get it straight forward? What should I research for?

Thank you very much, at least you could bring my "subconscious nonagreement" to light :)

28
thanks for trying, I try to rewrite the example:

JohnA:
- is one object so via GUI I say "create" and then a blank formular appears
- I chose name "JohnA"
- I set some AttributesA
- then I choose attribute "EnumType" with value "None"
- that displays a single Field
- before I can edit it, I have to choose the data type, I take "char" (int and char is possible)
- Now I can enter 'a' and save JohnA
=>  None=>Field | => char ='a' | AttributeA

JohnA:
- is one object so via GUI I say "create" and then a blank formular appears
- I choose name "JohnB"
- I set some AttributesA
- then I choose attribute "EnumType" with value "None"
- that displays a single Field
- before I can edit it, I have to choose the data type, I take "int"  (int and char is possible)
- Now I can enter '23' and save JohnB
=> JohnB: None=>Field | => int = 23 | AttributeA

JohnC:
- is one object so via GUI I say "create" and then a blank formular appears
- I chose name "JohnC"
- I set some AttributesA
- then I choose attribute "EnumType" with value "List"
- that displays an expandable array
- before I can edit it, I have to choose the data type, I take "String"  (int and char and String and double is possible)
- Now I can enter "hello", click "add entry", can enter "world", click "add entry", can enter "list"
- with saving JohnC has as an attribute an array from type String with 3 entries
=> JohnC: List=>[]Array | => String =["hello","world","list"] | AttributeA

JohnD:
- is one object so via GUI I say "create" and then a blank formular appears
- I choose name "JohnD"
- I set some AttributesA
- then I choose attribute "EnumType" with value "DictCollection"
- that displays an expendable Collection of paired values
- before I can edit it, I have to choose the data type, I take "XML" and "double" (int and char and String and double and XML is possible)
- Now I can enter "<lenght>" and "2.34", click "add entry", can enter "<width>" and "5.43"
- with saving, JohnD has as an attribute a collection of two pairs, each pair with two values of same data type
=> JohnD: Diction=>DictCollection | => {XML, double} = {(<length>, 2.34); (<width>, 5.43)} | AttributeA

JohnE:
- is one object so via GUI I say "create" and then a blank formular appears
- I choose name "JohnE"
- I set some AttributesA
- then I choose attribute "EnumType" with value "DictCollection"
- that displays an expendable collection of paired values
- before I can edit it, I have to choose the data type, I take "int" and "double" (int and char and String and double and XML is possible)
- Now I can enter "4" and "2.34", click "add entry", can enter "32" and "5.43", click "add entry", can enter "12" and "6.87"
- with saving, JohnE has as an attribute a collection of three pairs, each pair with two values of same data type
=> JohnE: Diction=>DictCollection | => {int, double} = {(4, 2.34); (32, 5.43);(12,6.87)} | AttributeA


My assumption is: JohnA-JohnE are objects of the same class - or the same superclass, not important.

Some new questions for clarification? :-o

29
Thanks for your feedbacks.

I intend to model the code reality.

Because I see only the result using the software, my perspective is mainly from that GUI. Decisions made live via GUI have an effect what is possible in the following drop downs inside that gui.

So each time the gui is used to create a new object John..., it attributes for an object of this class got attributes with values.
That makes each time a John... as the class' instantiated object.
And if only that, a simple class with some attributes.
That simple part is summed up as "AttributeA"

Each John... object has 3 dropdowns that are dependent from each other:
- first the user decides which EnumType the current John... gets: Field, []-Array or DictCollection
- after that, the gui changes upon this selection:
-- it offers either
--- a simple field
--- or an expendible array-like list (with one value per entry)
--- or a collection like list (with two values per entry)
-- additionally the user has to use another dropdown to specify what data type can be used in all these entries:
--- for the single field: int or char => there is only one value stored of either these two types
--- for the []-array: int or char or double or String => multiple values can be stored, they have all the same data type (for each John... object, so different John... objects can have different data types for this array)
--- for the DictCollection: int or char or double or String or XML => multiple pairs of values can be stored, the first part of a pair has for each John... object the same data type, the second part of a pair can be different and is the same for each John... object.

(repeated):
Example:
JohnA: None=>Field | => char ='a' | AttributeA
JohnB: None=>Field | => int = 23 | AttributeA
JohnC: List=>[]Array | => String =["hello","world","list"] | AttributeA
JohnD: Diction=>DictCollection | => {XML, double} = {(<length>, 2.34); (<width>, 5.43)} | AttributeA
JohnE: Diction=>DictCollection | => {int, double} = {(4, 2.34); (32, 5.43)} | AttributeA

Which understanding do you get now? Thanks again for reading.

30
Hi there,

I have the following "software reality in working code" (also no access to it):

    There is a class Class1 with different attributes
        AttributeA - sums up all "ordinary attributes"
        EnumType
        DataType
        AttributeValue

It is realized that there are some objects John... of type Class1, so they all have these 4 attributes. They can be set via GUI. The tricky part is: First EnumType has to be chosen. Depending on this choice the possible choices for DataType might be reduced. And the "attribute type" of AttributeValue might differ:

    EnumType = None => DataType: int | char && AttributeValue: Field
    EnumType = List => DataType: int | char | double | String && Value: []-Array
    EnumType = Diction => DataType: int | char | double | String | XML && Value: DictCollection

That means:
If "None" than Value is only a single "field" of some possible data types.
If "List" than Value is like an []-Array where there is a long list of storable entries, it is gui chosen which data type this instantiation gets (and than all entries have same), possible data types are a bit more than "None".
If "Diction" than Value is like a collection of attribute pairs, it is gui chosen which data type this instantiation gets (and than each pair has the same combination), possible data types are more than "List".

Example:
JohnA: None=>Field | => char ='a' | AttributeA
JohnB: None=>Field | => int = 23 | AttributeA
JohnC: List=>[]Array | => String =["hello","world","list"] | AttributeA
JohnD: Diction=>DictCollection | => {XML, double} = {(<length>, 2.34); (<width>, 5.43)} | AttributeA



How to model Class1 in UML class diagram?

Additional info: this Class1 also needs to be used in another class as data type of attributes over there as well - just in case that is relevant to ensure that while using it as data type the class structure and inner dependencies are coming into affect.

I read a bit and got some hints, I just don't understand them fully:
- when (not) to use a "refine"?
- when (not) to use a "derive"?

I understood, that a "refine" is useful in specialization where the subclass attribute has same name and different data type.
I understood, that  a "derive" is useful in case an attribute depends on e.g. values of another like it gets calculated (calc "age" from "birthday" and "today").
I understood that a "readonly" is useful e.g. in a specialization in combination with a default value when this default is the only one possible for this subclass. (despite "query" which just describes that the attribute has no changing effect to this class).

The hints are summarized in this approach:


As you might see,
  • the Class1 became abstract
  • there are three specializations for each EnumType
  • ClassDiction has no "redefines Value" (due to my lack of understanding)
  • DictCollection is shown as separate class as pair of key, counterkey
  • the enums for data types got specializations the way down

I have the feeling that "Value" needs two attributes: one aspect is: it defines the structure, second aspect is: it defines the data type inside the structure.
Or is this stored in "DataType" because this attribute is there to determine the data type of "Value" - and then it needs somehow an information to store this piece for just 'Field' / '[]-Array' or more data types for DictCollection as well?

Thank you very much for clarification, Shegit

Pages: 1 [2] 3 4 ... 7