Skip to main content


Eclipse Community Forums
Forum Search:

Search      Help    Register    Login    Home
Home » Modeling » TMF (Xtext) » Cross reference to data type
Cross reference to data type [message #1272270] Mon, 17 March 2014 14:12 Go to next message
Cristiano Politowski is currently offline Cristiano PolitowskiFriend
Messages: 11
Registered: February 2014
Location: Brasil
Junior Member
Hi guys, one more problem with CrossReferences. Is it possible do this:

Attribute:
	name=AttName;

AttName:
	name=[Element|QualifiedName] '.' an=QualifiedName
;

Value:
        attribute=[Attribute|[color=red]AttName[/color]] 
;

Element:
        name=QualifiedName
;


The problem is with attribute=[Attribute|AttName]. Is said that i must wrap it in data type rule. Then i tried this:

AttName returns ecore::EString :
	name=[Element|QualifiedName]'.'an=QualifiedName
;


So, the error is: Datatype rules may only use other datatype rules, lexer rules and keywords.

Any hints?

Thanks again.

Report message to a moderator

Re: Cross reference to data type [message #1272290 is a reply to message #1272270] Mon, 17 March 2014 14:59 Go to previous messageGo to next message
Christian Dietrich is currently offline Christian DietrichFriend
Messages: 14665
Registered: July 2009
Senior Member
Hi

|AttName means "by AttName" and not "or Attname"

so what you (may) want to do is

attribute=[Attribute|QualifiedName]

or you change AttName to a datatyperule e.g:

attname: qualifiedName

Twitter : @chrdietrich
Blog : https://www.dietrich-it.de

Report message to a moderator

Re: Cross reference to data type [message #1272301 is a reply to message #1272290] Mon, 17 March 2014 15:26 Go to previous messageGo to next message
Cristiano Politowski is currently offline Cristiano PolitowskiFriend
Messages: 11
Registered: February 2014
Location: Brasil
Junior Member
Sorry, I don't know if i made me understand.

What i want is a name formed by a CrossReference.

The model is like this:

ElementName          //Element
ElementName.someName //Attribute: CrossReference from ElementName'.'QualifiedName
ElementName.someName //Value: CrossReference from Attribute


Is it possible?

Report message to a moderator

Re: Cross reference to data type [message #1272313 is a reply to message #1272301] Mon, 17 March 2014 16:07 Go to previous messageGo to next message
Christian Dietrich is currently offline Christian DietrichFriend
Messages: 14665
Registered: July 2009
Senior Member
HI,

this does not work out of the box,
you have to adapt iqualifiednameprovider (using the nodemodel) to give the AttName a proper qualifiedname

Twitter : @chrdietrich
Blog : https://www.dietrich-it.de

Report message to a moderator

Re: Cross reference to data type [message #1272402 is a reply to message #1272313] Mon, 17 March 2014 20:46 Go to previous messageGo to next message
Cristiano Politowski is currently offline Cristiano PolitowskiFriend
Messages: 11
Registered: February 2014
Location: Brasil
Junior Member
Can you be more specific? Let me show my grammar:

Model:
	'Elements'
	el+=Element*
	'Attributes'
	att+=Attribute*;

Attribute:
	name=AttName " - " (attribute=[Attribute|QualifiedName] | 'EOF');

AttName:
	element=[Element|QualifiedName] '.' attributeName=QualifiedName;

Element:
	name=QualifiedName;

QualifiedName:
	ID;


And my model:

Elements
E1 
E2
E3
Attributes
E1.someNameA - EOF
E2.someNameB - E1.someNameA


I tried to do as you said, creating a class MydslQNP but i don't know where to go from here.

I'm sending the project too.

Thank in advance.

Report message to a moderator

Re: Cross reference to data type [message #1272407 is a reply to message #1272402] Mon, 17 March 2014 21:08 Go to previous messageGo to next message
Christian Dietrich is currently offline Christian DietrichFriend
Messages: 14665
Registered: July 2009
Senior Member
Hi,

i still dont understand why you make your grammar such complicated.
never the less ...

public class MydslQNP extends DefaultDeclarativeQualifiedNameProvider{
	
	QualifiedName qualifiedName(Attribute a) {
		if (a.getName() != null) {
			List<INode> nodes = NodeModelUtils.findNodesForFeature(a.getName(), MyDslPackage.Literals.ATT_NAME__ELEMENT);
			if (nodes.size() > 0) {
				return QualifiedName.create(nodes.get(0).getText().trim(),a.getName().getAttributeName());
			}
			
		}
		return null;
	}

}


another problem is that your grammar is wrong

Attribute:
	name=AttName " - " (attribute=[Attribute|QualifiedName] | 'EOF');

AttName:
	element=[Element|ID] '.' attributeName=ID;

Element:
	name=ID;

QualifiedName:
	ID ("." ID);


Twitter : @chrdietrich
Blog : https://www.dietrich-it.de

Report message to a moderator

Re: Cross reference to data type [message #1272795 is a reply to message #1272407] Tue, 18 March 2014 20:03 Go to previous message
Cristiano Politowski is currently offline Cristiano PolitowskiFriend
Messages: 11
Registered: February 2014
Location: Brasil
Junior Member
Perfect, with some adjusts it worked like a charm.

Are you some kind of Xtex Master or something like this? Razz

Just to you know, i need to do a DSL for a model like this:

%Relationships
 VP1 : [1,1]{V1 V2 V3 V4} ;
 VP2 : [1,1]{V5 V6} ;
 VP3 : [V7] [V8] [V9][V10] ;
 VP4 : [1,1]{V11 V12} ;
 VP5 : [1,1]{V13 V14} ;
 VP6 : [1,1]{V15 V16} [V17] ;
 [VP7] : [V18] [V19] [V20] [V21] [V22] [V23] [V24] [V25] ;
 [VP8] : [V26] [V27] [V28] [V29] [V30] [V31] [V32] [V33] ;
 [VP9] : [V34] [V35] [V36] [V37][V38] [V39] ;
 [VP10] : [V40] [V41] [V42] [V43] [V44] [V45] [V46] [V47] [V48] [V49] ;
 VP11: [1,1]{V50 V51 V52} ;
 VP12: [1,2]{V53 V54} ;
 VP13: [1,1]{V55 V56 V57} ;
  
%Attributes
V53.Accuracy: [8], 8;, INF;
V54.Accuracy:  [4], 4;, INF;
VP12.Accuracy: [4,8], min(V53.Accuracy,V54.Accuracy);,INF;

V55.AccuracyFactor: [4], 4;, MINF;
V56.AccuracyFactor: [3], 3;, MINF;
V57.AccuracyFactor: [1], 1;, MINF;
VP13.AccuracyFactor: [1,3,4], max(V55.AccuracyFactor, V56.AccuracyFactor,V57.AccuracyFactor);,MINF;

V5.Memory: [2], 2, 0; 
V6.Memory: [2], 2, 0;
V11.Memory: [2], 2, 0;
V12.Memory:  [2], 2, 0;
V13.Memory:  [2], 2, 0;
V14.Memory:  [2], 2, 0;
V15.Memory:  [8], 8, 0;
V16.Memory:  [8], 8, 0;
V17.Memory:  [16], 16, 0;
V18.Memory:  [4], 4, 0;
V19.Memory:  [2], 2, 0;
V20.Memory:  [2], 2, 0;
V21.Memory:  [4], 4, 0;
V22.Memory:  [4], 4, 0;
V23.Memory:  [4], 4, 0;
V24.Memory:  [2], 2, 0;
V25.Memory:  [4], 4, 0;
V26.Memory:  [2], 2, 0;
V27.Memory:  [2], 2, 0;
V28.Memory:  [8], 8, 0;
V29.Memory:  [2], 2, 0;
V30.Memory:  [8], 8, 0;
V31.Memory:  [2], 2, 0;
V32.Memory:  [8], 8, 0;
V33.Memory:  [2], 2, 0;
V34.Memory:  [2], 2, 0;
V35.Memory:  [2], 2, 0;
V36.Memory:  [2], 2, 0;
V37.Memory:  [2], 2, 0;
V38.Memory:  [2], 2, 0;
V39.Memory:  [2], 2, 0;
V40.Memory:  [2], 2, 0;
V41.Memory:  [4], 4, 0;
V42.Memory:  [4], 4, 0;
V43.Memory:  [4], 4, 0;
V44.Memory:  [4], 4, 0;
V45.Memory:  [2], 2, 0;
V46.Memory:  [8], 8, 0;
V47.Memory:  [2], 2, 0;
V48.Memory:  [8], 8, 0;
V49.Memory:  [4], 4, 0;
VP2.Memory: Integer [1 to 512], V5.Memory + V6.Memory;, 0;
VP4.Memory: Integer [1 to 512], V11.Memory + V12.Memory;, 0;
VP5.Memory: Integer [1 to 512], V13.Memory + V14.Memory;, 0;
VP6.Memory: Integer [1 to 512], V15.Memory + V16.Memory + V17.Memory;, 0;
VP7.Memory: Integer [1 to 512], V18.Memory + V19.Memory + V20.Memory + V21.Memory + V22.Memory + V23.Memory + V24.Memory + V25.Memory;, 0;
VP8.Memory: Integer [1 to 512], V26.Memory + V27.Memory + V28.Memory + V29.Memory + V30.Memory + V31.Memory + V32.Memory + V33.Memory;, 0;
VP9.Memory: Integer [1 to 512], V34.Memory + V35.Memory + V36.Memory + V37.Memory + V38.Memory + V39.Memory;, 0;
VP10.Memory: Integer [1 to 512], V40.Memory + V41.Memory + V42.Memory + V43.Memory + V44.Memory + V45.Memory + V46.Memory + V47.Memory + V48.Memory + V49.Memory;, 0;

V5.ROM:  [2], 2, 0; 
V6.ROM:  [2], 2, 0;
V7.ROM:  [8], 8, 0;
V8.ROM:  [16], 16, 0;
V9.ROM:  [4], 4, 0;
V10.ROM:  [16], 16, 0;
V11.ROM:  [4], 4, 0;
V12.ROM:  [4], 4, 0;
V13.ROM:  [4], 4, 0;
V14.ROM:  [0], 0, 0;
V15.ROM:  [8], 8, 0;
V16.ROM:  [8], 8, 0;
V17.ROM:  [32], 32, 0;
V18.ROM:  [4], 4, 0;
V19.ROM:  [4], 4, 0;
V20.ROM:  [4], 4, 0;
V21.ROM:  [4], 4, 0;
V22.ROM:  [4], 4, 0;
V23.ROM:  [4], 4, 0;
V24.ROM:  [4], 4, 0;
V25.ROM:  [4], 4, 0;
V26.ROM:  [4], 4, 0;
V27.ROM:  [4], 4, 0;
V28.ROM:  [8], 8, 0;
V29.ROM:  [4], 4, 0;
V30.ROM:  [8], 8, 0;
V31.ROM:  [4], 4, 0;
V32.ROM:  [8], 8, 0;
V33.ROM:  [4], 4, 0;
V34.ROM:  [4], 4, 0;
V35.ROM:  [4], 4, 0;
V36.ROM:  [4], 4, 0;
V37.ROM:  [4], 4, 0;
V38.ROM:  [4], 4, 0;
V39.ROM:  [4], 4, 0;
V40.ROM:  [4], 4, 0;
V41.ROM:  [4], 4, 0;
V42.ROM:  [4], 4, 0;
V43.ROM:  [4], 4, 0;
V44.ROM:  [4], 4, 0;
V45.ROM:  [4], 4, 0;
V46.ROM:  [8], 8, 0;
V47.ROM:  [4], 4, 0;
V48.ROM:  [8], 8, 0;
V49.ROM:  [4], 4, 0;
VP2.ROM: Integer [1 to 512], V5.ROM + V6.ROM;, 0;
VP3.ROM: Integer [1 to 512], V7.ROM + V8.ROM + V9.ROM + V10.ROM;, 0;
VP4.ROM: Integer [1 to 512], V11.ROM + V12.ROM;, 0;
VP5.ROM: Integer [1 to 512], V13.ROM + V14.ROM;, 0;
VP6.ROM: Integer [1 to 512], V15.ROM + V16.ROM + V17.ROM;, 0;
VP7.ROM: Integer [1 to 512], V18.ROM + V19.ROM + V20.ROM + V21.ROM + V22.ROM + V23.ROM + V24.ROM + V25.ROM;, 0;
VP8.ROM: Integer [1 to 512], V26.ROM + V27.ROM + V28.ROM + V29.ROM + V30.ROM + V31.ROM + V32.ROM + V33.ROM;, 0;
VP9.ROM: Integer [1 to 512], V34.ROM + V35.ROM + V36.ROM + V37.ROM + V38.ROM + V39.ROM;, 0;
VP10.ROM: Integer [1 to 512], V40.ROM + V41.ROM + V42.ROM + V43.ROM + V44.ROM + V45.ROM + V46.ROM + V47.ROM + V48.ROM + V49.ROM;, 0;

V50.Range:  [20], 20, MINF;
V51.Range:  [45], 45, MINF;
V52.Range:  [70], 70, MINF;
VP11.Range: [20,45,70], max(V50.Range,V51.Range,V52.Range);,MINF;

V11.Latency:   [400], 400, INF;
V12.Latency:   [400], 400, INF;
V13.Latency:   [500], 500, INF;
V14.Latency:   [500], 500, INF;
V15.Latency:   [350], 350, INF;
V16.Latency:   [350], 350, INF;
V17.Latency:   [350], 350, INF;
VP4.Latency:  [350,400,500], min(V11.Latency,V12.Latency);,INF;
VP5.Latency:  [350,400,500], min(V13.Latency,V14.Latency);,INF;
VP6.Latency:  [350,400,500], min(V15.Latency,V16.Latency,V17.Latency);,INF;

V5.Costs:  [20], 20, 0; 
V6.Costs:  [2], 2, 0;
V7.Costs:  [5], 5, 0;
V8.Costs:  [5], 5, 0;
V9.Costs:  [10], 10, 0;
V10.Costs:  [10], 10, 0;
V11.Costs:  [10], 10, 0;
V12.Costs:  [10], 10, 0;
V13.Costs:  [5], 5, 0;
V14.Costs:  [2], 2, 0;
V15.Costs:  [10], 10, 0;
V16.Costs:  [10], 10, 0;
V17.Costs:  [30], 30, 0;
V18.Costs:  [2], 2, 0;
V19.Costs:  [2], 2, 0;
V20.Costs:  [2], 2, 0;
V21.Costs:  [2], 2, 0;
V22.Costs:  [2], 2, 0;
V23.Costs:  [2], 2, 0;
V24.Costs:  [2], 2, 0;
V25.Costs:  [2], 2, 0;
V26.Costs:  [2], 2, 0;
V27.Costs:  [2], 2, 0;
V28.Costs:  [2], 2, 0;
V29.Costs:  [2], 2, 0;
V30.Costs:  [2], 2, 0;
V31.Costs:  [2], 2, 0;
V32.Costs:  [2], 2, 0;
V33.Costs:  [2], 2, 0;
V34.Costs:  [5], 5, 0;
V35.Costs:  [5], 5, 0;
V36.Costs:  [5], 5, 0;
V37.Costs:  [5], 5, 0;
V38.Costs:  [5], 5, 0;
V39.Costs:  [5], 5, 0;
V40.Costs:  [2], 2, 0;
V41.Costs:  [2], 2, 0;
V42.Costs:  [2], 2, 0;
V43.Costs:  [2], 2, 0;
V44.Costs:  [2], 2, 0;
V45.Costs:  [2], 2, 0;
V46.Costs:  [2], 2, 0;
V47.Costs:  [2], 2, 0;
V48.Costs:  [2], 2, 0;
V49.Costs:  [2], 2, 0;
V50.Costs:  [10], 10, 0;
V51.Costs:  [35], 35, 0;
V52.Costs:  [50], 50, 0;
V55.Costs:  [15], 15, 0;
V56.Costs:  [5], 5, 0;
V57.Costs:  [50], 50, 0;
VP2.Costs: Integer [1 to 500], V5.Costs + V6.Costs;, 0;
VP3.Costs: Integer [1 to 500], V7.Costs + V8.Costs + V9.Costs + V10.Costs;, 0;
VP4.Costs: Integer [1 to 500], V11.Costs + V12.Costs;, 0;
VP5.Costs: Integer [1 to 500], V13.Costs + V14.Costs;, 0;
VP6.Costs: Integer [1 to 500], V15.Costs + V16.Costs + V17.Costs;, 0;
VP7.Costs: Integer [1 to 500], V18.Costs + V19.Costs + V20.Costs + V21.Costs + V22.Costs + V23.Costs + V24.Costs + V25.Costs;, 0;
VP8.Costs: Integer [1 to 500], V26.Costs + V27.Costs + V28.Costs + V29.Costs + V30.Costs + V31.Costs + V32.Costs + V33.Costs;, 0;
VP9.Costs: Integer [1 to 500], V34.Costs + V35.Costs + V36.Costs + V37.Costs + V38.Costs + V39.Costs;, 0;
VP10.Costs: Integer [1 to 500], V40.Costs + V41.Costs + V42.Costs + V43.Costs + V44.Costs + V45.Costs + V46.Costs + V47.Costs + V48.Costs + V49.Costs;, 0;
VP11.Costs: Integer [1 to 500], V50.Costs + V51.Costs + V52.Costs;, 0;
VP13.Costs: Integer [1 to 500], V55.Costs + V56.Costs + V57.Costs;, 0;


V18.Cycle: [100], 100, INF;
V19.Cycle: [50], 50, INF;
V20.Cycle: [100], 100, INF;
V21.Cycle: [100], 100, INF;
V22.Cycle: [100], 100, INF;
V23.Cycle: [50], 50, INF;
V24.Cycle: [75], 75, INF;
V25.Cycle: [100], 100, INF;
V26.Cycle: [50], 50, INF;
V27.Cycle: [100], 100, INF;
V28.Cycle: [200], 200, INF;
V29.Cycle: [100], 100, INF;
V30.Cycle: [200], 200, INF;
V31.Cycle: [100], 100, INF;
V32.Cycle: [200], 200, INF;
V33.Cycle: [100], 100, INF;
V34.Cycle: [100], 100, INF;
V35.Cycle: [100], 100, INF;
V36.Cycle: [100], 100, INF;
V37.Cycle: [100], 100, INF;
V38.Cycle: [100], 100, INF;
V39.Cycle: [100], 100, INF;
V40.Cycle: [50], 50, INF;
V41.Cycle: [50], 50, INF;
V42.Cycle: [50], 50, INF;
V43.Cycle: [50], 50, INF;
V44.Cycle: [50], 50, INF;
V45.Cycle: [50], 50, INF;
V46.Cycle: [200], 200, INF;
V47.Cycle: [50], 50, INF;
V48.Cycle: [200], 200, INF;
V49.Cycle: [50], 50, INF;
VP7.Cycle: [50,75,100,200], min(V18.Cycle, V19.Cycle, V20.Cycle, V21.Cycle, V22.Cycle, V23.Cycle, V24.Cycle, V25.Cycle);,INF;
VP8.Cycle: [50,75,100,200], min(V26.Cycle, V27.Cycle, V28.Cycle, V29.Cycle, V30.Cycle, V31.Cycle, V32.Cycle, V33.Cycle);,INF;
VP9.Cycle: [50,75,100,200], min(V34.Cycle, V35.Cycle, V36.Cycle, V37.Cycle, V38.Cycle, V39.Cycle);,INF;
VP10.Cycle: [50,75,100,200], min(V40.Cycle, V41.Cycle, V42.Cycle, V43.Cycle, V44.Cycle, V45.Cycle, V46.Cycle, V47.Cycle, V48.Cycle, V49.Cycle);,INF;

%GlobalAttributes
TotalAccuracy: Integer [1 to 40], VP12.Accuracy * VP13.AccuracyFactor;, 0;
TotalMemory: Integer[1 to 512], VP2.Memory + VP4.Memory + VP5.Memory + VP6.Memory + VP7.Memory + VP8.Memory + VP9.Memory + VP10.Memory;,0;
TotalROM: Integer[1 to 512], VP2.ROM + VP3.ROM + VP4.ROM + VP5.ROM + VP6.ROM + VP7.ROM + VP8.ROM + VP9.ROM + VP10.ROM;,0;
TotalLatency: [350,400,500], min(VP4.Latency,VP5.Latency,VP6.Latency);,500;
TotalCosts: Integer [1 to 500], VP2.Costs + VP3.Costs + VP4.Costs + VP5.Costs + VP6.Costs + VP7.Costs + VP8.Costs + VP9.Costs + VP10.Costs + VP11.Costs + VP13.Costs;,0;
TotalCycle: [50,75,100,200], min(VP7.Cycle,VP8.Cycle,VP9.Cycle,VP10.Cycle);,500;

%Constraints

VP1 REQUIRES VP9 ;
VP1 REQUIRES VP10 ;
VP1 REQUIRES VP8 ;
VP1 REQUIRES VP7 ;
V10 REQUIRES V16 ;
V15 EXCLUDES V10 ;
V9  REQUIRES V12 ;
V9  REQUIRES V34 ;
V11 EXCLUDES V9 ;
V8  REQUIRES V48 ;
V8  REQUIRES V19 ;
V8  REQUIRES V21 ;
V7  REQUIRES V33 ;
V7  REQUIRES V13 ;
V7  EXCLUDES V14 ;
V1  REQUIRES V26 ;
V1  REQUIRES V27 ;
V1  REQUIRES V31 ;
V1  REQUIRES V41 ;
V1  REQUIRES V5 ;
V2  REQUIRES V26 ;
V2  REQUIRES V27 ;
V2  REQUIRES V31 ;
V2  REQUIRES V41 ;
V2  REQUIRES V6 ;
V2  REQUIRES V8 ;
V3  REQUIRES V26 ;
V3  REQUIRES V27 ;
V3  REQUIRES V31 ;
V3  REQUIRES V41 ;
V3  REQUIRES V5 ;
V4  REQUIRES V29 ;
V4  REQUIRES V30 ;
V4  REQUIRES V43 ;
V4  REQUIRES V41 ;
V4  REQUIRES V6 ;
V17 REQUIRES V10 ;
V53 EXCLUDES V55 ;

V10 IMPLIES VP11.Range >= 50;
V17 IMPLIES VP11.Range >= 50;
V18 IMPLIES VP11.Range >= 25;
V19 IMPLIES VP11.Range >= 50;
V20 IMPLIES VP11.Range >= 25;
V21 IMPLIES VP11.Range >= 25;
V22 IMPLIES VP11.Range >= 10;
V23 IMPLIES VP11.Range >= 10;
V24 IMPLIES VP11.Range >= 10;
V25 IMPLIES VP11.Range >= 10;
V26 IMPLIES VP11.Range >= 25;
V27 IMPLIES VP11.Range >= 25;
V28 IMPLIES VP11.Range >= 25;
V29 IMPLIES VP11.Range >= 25;
V30 IMPLIES VP11.Range >= 25;
V31 IMPLIES VP11.Range >= 25;
V32 IMPLIES VP11.Range >= 25;
V33 IMPLIES VP11.Range >= 10;
V34 IMPLIES VP11.Range >= 50;
V35 IMPLIES VP11.Range >= 50;
V36 IMPLIES VP11.Range >= 50;
V37 IMPLIES VP11.Range >= 50;
V38 IMPLIES VP11.Range >= 80;
V39 IMPLIES VP11.Range >= 80;
V40 IMPLIES VP11.Range >= 50;
V41 IMPLIES VP11.Range >= 50;
V42 IMPLIES VP11.Range >= 50;
V43 IMPLIES VP11.Range >= 50;
V44 IMPLIES VP11.Range >= 25;
V45 IMPLIES VP11.Range >= 80;
V46 IMPLIES VP11.Range >= 50;
V47 IMPLIES VP11.Range >= 25;
V48 IMPLIES VP11.Range >= 10;
V49 IMPLIES VP11.Range >= 10;
 
V11 IMPLIES TotalAccuracy <= 30;
V12 IMPLIES TotalAccuracy <= 30;
V13 IMPLIES TotalAccuracy <= 10;
V15 IMPLIES TotalAccuracy <= 30;
V16 IMPLIES TotalAccuracy <= 30;
V17 IMPLIES TotalAccuracy <= 10;
V18 IMPLIES TotalAccuracy <= 30;
V19 IMPLIES TotalAccuracy <= 30;
V20 IMPLIES TotalAccuracy <= 30;
V21 IMPLIES TotalAccuracy <= 30;
V22 IMPLIES TotalAccuracy <= 30;
V23 IMPLIES TotalAccuracy <= 30;
V24 IMPLIES TotalAccuracy <= 30;
V25 IMPLIES TotalAccuracy <= 30;
V26 IMPLIES TotalAccuracy <= 10;
V27 IMPLIES TotalAccuracy <= 10;
V28 IMPLIES TotalAccuracy <= 10;
V29 IMPLIES TotalAccuracy <= 10;
V30 IMPLIES TotalAccuracy <= 10;
V31 IMPLIES TotalAccuracy <= 10;
V32 IMPLIES TotalAccuracy <= 10;
V33 IMPLIES TotalAccuracy <= 10;
V34 IMPLIES TotalAccuracy <= 30;
V35 IMPLIES TotalAccuracy <= 30;
V36 IMPLIES TotalAccuracy <= 30;
V37 IMPLIES TotalAccuracy <= 30;
V38 IMPLIES TotalAccuracy <= 10;
V39 IMPLIES TotalAccuracy <= 30;
V40 IMPLIES TotalAccuracy <= 10;
V41 IMPLIES TotalAccuracy <= 30;
V42 IMPLIES TotalAccuracy <= 30;
V43 IMPLIES TotalAccuracy <= 30;
V44 IMPLIES TotalAccuracy <= 30;
V45 IMPLIES TotalAccuracy <= 10;
V46 IMPLIES TotalAccuracy <= 30;
V48 IMPLIES TotalAccuracy <= 30;
V49 IMPLIES TotalAccuracy <= 30;


With your help it's done, thank you again.

Report message to a moderator

Previous Topic:As a result, alternative(s) 2 were disabled for that input__ldscript
Next Topic:Xtext artifact generation from Ecore model fails when Ecore model refers to another model.
Goto Forum:
  

[ Syndicate this forum (XML) ] [ RSS ]

Current Time: Thu Apr 25 05:28:34 GMT 2024

Powered by FUDForum. Page generated in 0.04118 seconds
.:: Contact :: Home ::.

Powered by: FUDforum 3.0.2.
Copyright ©2001-2010 FUDforum Bulletin Board Software

Back to the top

Sign up to our Newsletter

A fresh new issue delivered monthly