buildframework/helium/sf/java/antdata/src/com/nokia/helium/ant/data/TargetMeta.java
changeset 628 7c4a911dc066
parent 587 85df38eb4012
child 645 b8d81fa19e7d
equal deleted inserted replaced
588:c7c26511138f 628:7c4a911dc066
    15  *
    15  *
    16  */
    16  */
    17 
    17 
    18 package com.nokia.helium.ant.data;
    18 package com.nokia.helium.ant.data;
    19 
    19 
    20 import java.io.IOException;
       
    21 import java.util.ArrayList;
    20 import java.util.ArrayList;
       
    21 import java.util.Collection;
       
    22 import java.util.Iterator;
    22 import java.util.List;
    23 import java.util.List;
    23 import java.util.StringTokenizer;
    24 import java.util.StringTokenizer;
    24 import java.util.regex.Matcher;
    25 import java.util.regex.Matcher;
    25 import java.util.regex.Pattern;
    26 import java.util.regex.Pattern;
    26 
    27 
    36 /**
    37 /**
    37  * Meta object representing a target.
    38  * Meta object representing a target.
    38  */
    39  */
    39 public class TargetMeta extends TaskContainerMeta {
    40 public class TargetMeta extends TaskContainerMeta {
    40 
    41 
    41     public TargetMeta(AntObjectMeta parent, Node node) throws IOException {
    42     public TargetMeta(AntObjectMeta parent, Node node) {
    42         super(parent, node);
    43         super(parent, node);
    43         // callAntTargetVisitor();
       
    44     }
    44     }
    45 
    45 
    46     public String getIf() {
    46     public String getIf() {
    47         return getAttr("if");
    47         return getAttr("if");
    48     }
    48     }
    77         return depends;
    77         return depends;
    78     }
    78     }
    79 
    79 
    80     public List<String> getSignals() {
    80     public List<String> getSignals() {
    81         List<String> signals = super.getSignals();
    81         List<String> signals = super.getSignals();
    82         List<String> additionalSignals = getDatabase().getSignals(getName());
    82         Collection<AntFile> antFiles = getDatabase().getAntFiles();
    83         if (additionalSignals != null) {
    83         for (Iterator<AntFile> iterator = antFiles.iterator(); iterator.hasNext();) {
    84             signals.addAll(additionalSignals);
    84             AntFile antFile = (AntFile) iterator.next();
       
    85             RootAntObjectMeta rootObjectMeta = antFile.getRootObjectMeta();
       
    86             if (rootObjectMeta instanceof ProjectMeta) {
       
    87                 ProjectMeta projectMeta = (ProjectMeta)rootObjectMeta;
       
    88                 projectMeta.getConfigSignals(getName(), signals);
       
    89             }
    85         }
    90         }
    86         return signals;
    91         return signals;
    87     }
    92     }
    88 
    93 
    89     public List<String> getPropertyDependencies() {
    94     public List<String> getPropertyDependencies() {
   118         public void visit(Element node) {
   123         public void visit(Element node) {
   119             if (node.getName().equals("property")) {
   124             if (node.getName().equals("property")) {
   120                 String propertyName = node.attributeValue("name");
   125                 String propertyName = node.attributeValue("name");
   121                 if (propertyName != null && !propertyList.contains(propertyName)) {
   126                 if (propertyName != null && !propertyList.contains(propertyName)) {
   122                     propertyList.add(propertyName);
   127                     propertyList.add(propertyName);
   123                     // System.out.println("prop "+propertyName);
       
   124                     log("property matches :" + propertyName, Project.MSG_DEBUG);
   128                     log("property matches :" + propertyName, Project.MSG_DEBUG);
   125                 }
   129                 }
   126             }
   130             }
   127         }
   131         }
   128 
   132 
   129         private void extractUsedProperties(String text) {
   133         private void extractUsedProperties(String text) {
   130             Pattern p1 = Pattern.compile("\\$\\{([^@$}]*)\\}");
   134             Pattern p1 = Pattern.compile("\\$\\{([^@$}]*)\\}");
   131             Matcher m1 = p1.matcher(text);
   135             Matcher m1 = p1.matcher(text);
   132             log(text, Project.MSG_DEBUG);
       
   133             while (m1.find()) {
   136             while (m1.find()) {
   134                 String group = m1.group(1);
   137                 String group = m1.group(1);
   135                 if (!propertyList.contains(group)) {
   138                 if (!propertyList.contains(group)) {
   136                     propertyList.add(group);
   139                     propertyList.add(group);
   137                     // System.out.println("m1 "+group + " "+ text);
       
   138                 }
   140                 }
   139                 log("property matches: " + group, Project.MSG_DEBUG);
   141                 log("property matches: " + group, Project.MSG_DEBUG);
   140             }
   142             }
   141 
   143 
   142             Pattern p2 = Pattern.compile("\\$\\{([^\n]*\\})\\}");
   144             Pattern p2 = Pattern.compile("\\$\\{([^\n]*\\})\\}");
   143             Matcher m2 = p2.matcher(text);
   145             Matcher m2 = p2.matcher(text);
   144             log(text, Project.MSG_DEBUG);
       
   145             while (m2.find()) {
   146             while (m2.find()) {
   146                 String group = m2.group(1);
   147                 String group = m2.group(1);
   147                 if (!propertyList.contains(group)) {
   148                 if (!propertyList.contains(group)) {
   148                     propertyList.add(group);
   149                     propertyList.add(group);
   149                     // System.out.println("m2 "+group + " "+ text);
       
   150                 }
   150                 }
   151                 log("property matches: " + group, Project.MSG_DEBUG);
   151                 log("property matches: " + group, Project.MSG_DEBUG);
   152             }
   152             }
   153 
   153 
   154             Pattern p3 = Pattern.compile("\\$\\{(\\@\\{[^\n]*)\\}");
   154             Pattern p3 = Pattern.compile("\\$\\{(\\@\\{[^\n]*)\\}");
   156             log(text, Project.MSG_DEBUG);
   156             log(text, Project.MSG_DEBUG);
   157             while (m3.find()) {
   157             while (m3.find()) {
   158                 String group = m3.group(1);
   158                 String group = m3.group(1);
   159                 if (!propertyList.contains(group)) {
   159                 if (!propertyList.contains(group)) {
   160                     propertyList.add(group);
   160                     propertyList.add(group);
   161                     // System.out.println("m3 "+group + " "+ text);
       
   162                 }
   161                 }
   163                 log("property matches: " + group, Project.MSG_DEBUG);
   162                 log("property matches: " + group, Project.MSG_DEBUG);
   164             }
   163             }
   165         }
   164         }
   166     }
   165     }