
...
 */
public class Package implements Serializable {
    private static final long serialVersionUID = 1L;

    public Package() {
    }

    public Package(String name) {
        this();
        setName(name);
    }

    private String name;



    private String suite;

    private String section;

    private final LinkedList<PackageRelation> depends = new LinkedList<PackageRelation>();

    private final LinkedList<PackageRelation> conflicts = new LinkedList<PackageRelation>();

    private final LinkedList<PackageRelation> recommends = new LinkedList<PackageRelation>();

    private final LinkedList<Package> provides = new LinkedList<Package>();

    private Boolean installed;

    private Integer size;

...

    public void setName(String name) {
        this.name = name;
    }









    public String getSuite() {
        return suite;
    }

    public void setSuite(String suite) {
        this.suite = suite;
    }

    public LinkedList<PackageRelation> getDepends() {
        return this.depends;
    }

    public void setDepends(Collection<PackageRelation> arrayList) {
        this.depends.addAll(arrayList);
    }

    public LinkedList<PackageRelation> getConflicts() {
        return this.conflicts;
    }

    public void setConflicts(Collection<PackageRelation> conflicts) {
        this.conflicts.addAll(conflicts);
    }

    public LinkedList<PackageRelation> getRecommends() {
        return this.recommends;
    }

    public void setRecommends(Collection<PackageRelation> recommends) {
        this.recommends.addAll(recommends);
    }

    public LinkedList<Package> getProvides() {
        return provides;
    }

    public void setProvides(VersionedPackage provides) {
        this.provides.add(provides);
...
        this.section = section;
    }

    @Override
    public String toString() {
        return "package: " + this.name;
    }

    public void setDependsString(String dependsString) {
        this.dependsString = dependsString;
    }
...
    public void setVersionString(String versionString) {
        this.versionString = versionString;
    }

    public void resolveLinks(Map<String, Package> packageNameMap) {
        setDepends(parseDependencyPackages(dependsString, packageNameMap));
        setRecommends(parseDependencyPackages(recommendsString, packageNameMap));
        setConflicts(parseDependencyPackages(conflictsString, packageNameMap));
    }

    public ArrayList<PackageRelation> parseDependencyPackages(String pkgListString, Map<String, Package> packageNameMap) {
        ArrayList<PackageRelation> pkgs = new ArrayList<PackageRelation>();
        if (pkgListString != null) {
            final String[] elements = pkgListString.split(",");
            for (String pkg : elements) {
                String packageRef = pkg.trim();

                if (packageRef.contains("|")) {
                    // System.out.println("\t\tIgnoring package: " + parsedPackageInfo.getName() + "; ref was: " + packageRef);
                } else {
                    PackageRelation parsedPackageInfo = parsePackageInfo(packageRef, packageNameMap);
                    if (parsedPackageInfo != null) {
                        if (parsedPackageInfo.getTargetPackageName() == null) {
                            System.out.println("Got null package for ref: " + packageRef);
                            parsedPackageInfo = parsePackageInfo(packageRef, packageNameMap);
                        } else if (parsedPackageInfo.getTargetPackageName().contains("<")) {
                            System.out.println("Not parsed correctly package : " + parsedPackageInfo.getTargetPackageName() + "; ref was: "
                                    + packageRef);
                            parsedPackageInfo = parsePackageInfo(packageRef, packageNameMap);
                        }
                        pkgs.add(parsedPackageInfo);
                    }
                }

            }
        }
        return pkgs;
    }

    public PackageRelation parsePackageInfo(String packageRef, Map<String, Package> packageNameMap) {
        if (packageRef.contains("(") && packageRef.contains(")")) { // assume a versioned package relation

            String[] pkgParts = packageRef.split("\\(");
            String targetPackageName = pkgParts[0].trim();

            String pkgRelation = pkgParts[1].trim();
            if (!pkgRelation.endsWith(")")) {
                System.out.println("The package relation string details doesn't end with ) for " + pkgRelation);
                return null;
            }
            pkgRelation = pkgRelation.substring(0, pkgRelation.length() - 1);
            String[] pkgVersionDetailParts = pkgRelation.split(" ");

            Package targetPackage = packageNameMap.get(targetPackageName);
            if (targetPackage == null) {

            }

            PackageRelation packageRelation = new PackageRelation(targetPackageName);
            packageRelation.setConstraint(pkgVersionDetailParts[0].trim());
            packageRelation.setVersion(pkgVersionDetailParts[1].trim());
            return packageRelation;
        } else { // simple package relation
            String targetPackageName = packageRef.trim();
            Package targetPackage = packageNameMap.get(targetPackageName);
            if (targetPackage == null) {

            }
            return new PackageRelation(targetPackageName);
        }

    }

    public void setPackageInformation(ArrayList<String> packageInformation) {
        this.packageInformation = packageInformation;
    }

	a/src/main/java/net/timbusproject/dpes/alternative/kb/Package.java		b/src/main/java/net/timbusproject/dpes/alternative/kb/Package.java
	...		...
29	*/	29	*/
30	public class Package implements Serializable {	30	public class Package implements Serializable {
31	private static final long serialVersionUID = 1L;	31	private static final long serialVersionUID = 1L;
32		32
33	public Package() {	33	public Package() {
34	this.conflicts = new LinkedList<VersionedPackage>();	34	}
35	this.depends = new LinkedList<VersionedPackage>();	35
36	this.recommends = new LinkedList<VersionedPackage>();	36	public Package(String name) {
37	this.provides = new LinkedList<VersionedPackage>();	37	this();
		38	setName(name);
38	}	39	}
39		40
40	private String name;	41	private String name;
41		42
42	private Integer version;
43
44	private String suite;	43	private String suite;
45		44
46	private String section;	45	private String section;
47		46
48	private final LinkedList<VersionedPackage> depends;	47	private final LinkedList<PackageRelation> depends = new LinkedList<PackageRelation>();
49		48
50	private final LinkedList<VersionedPackage> conflicts;	49	private final LinkedList<PackageRelation> conflicts = new LinkedList<PackageRelation>();
51		50
52	private final LinkedList<VersionedPackage> recommends;	51	private final LinkedList<PackageRelation> recommends = new LinkedList<PackageRelation>();
53		52
54	private final LinkedList<VersionedPackage> provides;	53	private final LinkedList<Package> provides = new LinkedList<Package>();
55		54
56	private Boolean installed;	55	private Boolean installed;
57		56
58	private Integer size;	57	private Integer size;
59		58
	...		...
79		78
80	public void setName(String name) {	79	public void setName(String name) {
81	this.name = name;	80	this.name = name;
82	}	81	}
83		82
84	public Integer getVersion() {
85	return this.version;
86	}
87
88	public void setVersion(Integer version) {
89	this.version = version;
90	}
91
92	public String getSuite() {	83	public String getSuite() {
93	return suite;	84	return suite;
94	}	85	}
95		86
96	public void setSuite(String suite) {	87	public void setSuite(String suite) {
97	this.suite = suite;	88	this.suite = suite;
98	}	89	}
99		90
100	public LinkedList<VersionedPackage> getDepends() {	91	public LinkedList<PackageRelation> getDepends() {
101	return this.depends;	92	return this.depends;
102	}	93	}
103		94
104	public void setDepends(Collection<VersionedPackage> arrayList) {	95	public void setDepends(Collection<PackageRelation> arrayList) {
105	this.depends.addAll(arrayList);	96	this.depends.addAll(arrayList);
106	}	97	}
107		98
108	public LinkedList<VersionedPackage> getConflicts() {	99	public LinkedList<PackageRelation> getConflicts() {
109	return this.conflicts;	100	return this.conflicts;
110	}	101	}
111		102
112	public void setConflicts(Collection<VersionedPackage> conflicts) {	103	public void setConflicts(Collection<PackageRelation> conflicts) {
113	this.conflicts.addAll(conflicts);	104	this.conflicts.addAll(conflicts);
114	}	105	}
115		106
116	public LinkedList<VersionedPackage> getRecommends() {	107	public LinkedList<PackageRelation> getRecommends() {
117	return this.recommends;	108	return this.recommends;
118	}	109	}
119		110
120	public void setRecommends(Collection<VersionedPackage> recommends) {	111	public void setRecommends(Collection<PackageRelation> recommends) {
121	this.recommends.addAll(recommends);	112	this.recommends.addAll(recommends);
122	}	113	}
123		114
124	public LinkedList<VersionedPackage> getProvides() {	115	public LinkedList<Package> getProvides() {
125	return provides;	116	return provides;
126	}	117	}
127		118
128	public void setProvides(VersionedPackage provides) {	119	public void setProvides(VersionedPackage provides) {
129	this.provides.add(provides);	120	this.provides.add(provides);
	...		...
177	this.section = section;	168	this.section = section;
178	}	169	}
179		170
180	@Override	171	@Override
181	public String toString() {	172	public String toString() {
182	return "package: " + this.name + " version: " + this.version;	173	return "package: " + this.name;
183	}	174	}
184		175
185	public void setDependsString(String dependsString) {	176	public void setDependsString(String dependsString) {
186	this.dependsString = dependsString;	177	this.dependsString = dependsString;
187	}	178	}
	...		...
201	public void setVersionString(String versionString) {	192	public void setVersionString(String versionString) {
202	this.versionString = versionString;	193	this.versionString = versionString;
203	}	194	}
204		195
205	public void resolveLinks(Map<String, Package> packageNameMap) {	196	public void resolveLinks(Map<String, Package> packageNameMap) {
206	setDepends(parseVersionedPackages(dependsString));	197	setDepends(parseDependencyPackages(dependsString, packageNameMap));
207	setRecommends(parseVersionedPackages(recommendsString));	198	setRecommends(parseDependencyPackages(recommendsString, packageNameMap));
208	setConflicts(parseVersionedPackages(conflictsString));	199	setConflicts(parseDependencyPackages(conflictsString, packageNameMap));
209	}	200	}
210		201
211	public ArrayList<VersionedPackage> parseVersionedPackages(String pkgListString) {	202	public ArrayList<PackageRelation> parseDependencyPackages(String pkgListString, Map<String, Package> packageNameMap) {
212	ArrayList<VersionedPackage> pkgs = new ArrayList<VersionedPackage>();	203	ArrayList<PackageRelation> pkgs = new ArrayList<PackageRelation>();
213	if (pkgListString != null) {	204	if (pkgListString != null) {
214	final String[] elements = pkgListString.split(",");	205	final String[] elements = pkgListString.split(",");
215	for (String pkg : elements) {	206	for (String pkg : elements) {
		207	String packageRef = pkg.trim();
		208
		209	if (packageRef.contains("\|")) {
		210	// System.out.println("\t\tIgnoring package: " + parsedPackageInfo.getName() + "; ref was: " + packageRef);
		211	} else {
		212	PackageRelation parsedPackageInfo = parsePackageInfo(packageRef, packageNameMap);
		213	if (parsedPackageInfo != null) {
		214	if (parsedPackageInfo.getTargetPackageName() == null) {
		215	System.out.println("Got null package for ref: " + packageRef);
		216	parsedPackageInfo = parsePackageInfo(packageRef, packageNameMap);
		217	} else if (parsedPackageInfo.getTargetPackageName().contains("<")) {
		218	System.out.println("Not parsed correctly package : " + parsedPackageInfo.getTargetPackageName() + "; ref was: "
		219	+ packageRef);
		220	parsedPackageInfo = parsePackageInfo(packageRef, packageNameMap);
		221	}
216	pkgs.add(parseVersionedPackage(pkg));	222	pkgs.add(parsedPackageInfo);
		223	}
		224	}
		225
217	}	226	}
218	}	227	}
219	return pkgs;	228	return pkgs;
220	}	229	}
221		230
222	public VersionedPackage parseVersionedPackage(String string) {	231	public PackageRelation parsePackageInfo(String packageRef, Map<String, Package> packageNameMap) {
223	VersionedPackage pkg = new VersionedPackage();	232	if (packageRef.contains("(") && packageRef.contains(")")) { // assume a versioned package relation
224	if (string.contains("(") && string.contains(")")) {
225	String[] pkgParts = string.split("\\(");	233	String[] pkgParts = packageRef.split("\\(");
226	String pkgName = pkgParts[0].trim();	234	String targetPackageName = pkgParts[0].trim();
227	String pkgVersionDetail = pkgParts[1].substring(0, pkgParts[1].indexOf(")")).trim();	235
		236	String pkgRelation = pkgParts[1].trim();
		237	if (!pkgRelation.endsWith(")")) {
		238	System.out.println("The package relation string details doesn't end with ) for " + pkgRelation);
		239	return null;
		240	}
		241	pkgRelation = pkgRelation.substring(0, pkgRelation.length() - 1);
228	String[] pkgVersionDetailParts = pkgVersionDetail.split(" ");	242	String[] pkgVersionDetailParts = pkgRelation.split(" ");
229	pkg.setName(pkgName);	243
		244	Package targetPackage = packageNameMap.get(targetPackageName);
		245	if (targetPackage == null) {
		246
		247	}
		248
		249	PackageRelation packageRelation = new PackageRelation(targetPackageName);
230	pkg.setConstraint(pkgVersionDetailParts[0].trim());	250	packageRelation.setConstraint(pkgVersionDetailParts[0].trim());
231	pkg.setVersion(pkgVersionDetailParts[1].trim());	251	packageRelation.setVersion(pkgVersionDetailParts[1].trim());
232	} else {	252	return packageRelation;
233	pkg.setName(string);	253	} else { // simple package relation
		254	String targetPackageName = packageRef.trim();
		255	Package targetPackage = packageNameMap.get(targetPackageName);
		256	if (targetPackage == null) {
		257
		258	}
		259	return new PackageRelation(targetPackageName);
234	}	260	}
235	return pkg;
236	}	261	}
237		262
238	public void setPackageInformation(ArrayList<String> packageInformation) {	263	public void setPackageInformation(ArrayList<String> packageInformation) {
239	this.packageInformation = packageInformation;	264	this.packageInformation = packageInformation;
240	}	265	}