backend/mods/ModManager.java

package net.oni2.aeinstaller.backend.mods;

import java.io.File;
import java.io.FileFilter;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.TreeSet;
import java.util.Vector;

import net.oni2.aeinstaller.backend.Paths;
import net.oni2.aeinstaller.backend.depot.DepotConfig;
import net.oni2.aeinstaller.backend.depot.DepotManager;
import net.oni2.aeinstaller.backend.depot.model.NodeMod;
import net.oni2.aeinstaller.backend.depot.model.TaxonomyTerm;

/**
 * @author Christian Illy
 */
public class ModManager {
        // Download mods
        // Update mods

        private static ModManager instance = new ModManager();

        private HashMap<String, Type> types = new HashMap<String, Type>();
        private HashMap<Integer, Mod> mods = new HashMap<Integer, Mod>();
        private HashMap<Integer, Mod> tools = new HashMap<Integer, Mod>();

        /**
         * First initialization of ModManager
         */
        public void init() {
                types = new HashMap<String, Type>();
                mods = new HashMap<Integer, Mod>();

                types.put("-Local-", new Type("-Local-", null));

                for (TaxonomyTerm tt : DepotManager.getInstance()
                                .getTaxonomyTermsByVocabulary(
                                                DepotManager.getInstance().getVocabIdType())) {
                        types.put(tt.getName(), new Type(tt.getName(), tt));
                }

                HashMap<Integer, Mod> modFolders = new HashMap<Integer, Mod>();
                if (Paths.getModsPath().exists()) {
                        for (File f : Paths.getModsPath().listFiles(new FileFilter() {
                                @Override
                                public boolean accept(File pathname) {
                                        return pathname.isDirectory();
                                }
                        })) {
                                Mod m = new Mod(f);
                                modFolders.put(m.getPackageNumber(), m);
                        }
                }

                TaxonomyTerm toolTerm = DepotManager.getInstance().getTaxonomyTerm(
                                DepotConfig.getTaxonomyName_ModType_Tool());
                for (NodeMod nm : DepotManager.getInstance().getModPackageNodes()) {
                        if (nm.getUploads().size() == 1) {
                                Mod m = new Mod(nm);
                                if (nm.getTypes().contains(toolTerm))
                                        tools.put(m.getPackageNumber(), m);
                                else
                                        mods.put(m.getPackageNumber(), m);
                                modFolders.remove(m.getPackageNumber());
                        }
                }

                for (Mod m : modFolders.values()) {
                        mods.put(m.getPackageNumber(), m);
                }
        }

        public void refreshLocalMods() {
                // TODO: evtl nur private e.g. als listener für downloads?
        }

        /**
         * @return Singleton instance
         */
        public static ModManager getInstance() {
                return instance;
        }

        Type getTypeByName(String name) {
                return types.get(name);
        }

        /**
         * @return Collection of types which do have mods associated
         */
        public Collection<Type> getTypesWithContent() {
                Vector<Type> res = new Vector<Type>();
                for (Type t : types.values()) {
                        if (t.getEntries().size() > 0)
                                res.add(t);
                }
                return res;
        }

        /**
         * @return Collection of mods
         */
        public Collection<Mod> getMods() {
                return mods.values();
        }

        /**
         * @return Mods which are always installed
         */
        public Collection<Mod> getMandatoryMods() {
                Vector<Mod> res = new Vector<Mod>();
                for (Mod m : mods.values()) {
                        if (m.isMandatoryMod())
                                res.add(m);
                }
                return res;
        }
        
        /**
         * @return Collection of tools
         */
        public Collection<Mod> getTools() {
                return tools.values();
        }
        
        /**
         * @return Tools which are always installed
         */
        public Collection<Mod> getMandatoryTools() {
                Vector<Mod> res = new Vector<Mod>();
                for (Mod m : tools.values()) {
                        if (m.isMandatoryMod())
                                res.add(m);
                }
                return res;
        }

        /**
         * Get a mod by its package number
         * 
         * @param number
         *            Package number
         * @return Mod or null
         */
        public Mod getModByNumber(int number) {
                for (Mod m : mods.values()) {
                        if (m.getPackageNumber() == number)
                                return m;
                }
                return null;
        }

        /**
         * Check for unresolved dependencies within the given mods
         * 
         * @param mods
         *            Mods to check
         * @return Unmet dependencies
         */
        public HashMap<Mod, HashSet<Mod>> checkDependencies(TreeSet<Mod> mods) {
                // TODO: Verify functionality
                HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();

                for (Mod m : mods) {
                        for (int depNum : m.getDependencies()) {
                                Mod other = getModByNumber(depNum);
                                if (!mods.contains(other)) {
                                        if (!res.containsKey(m))
                                                res.put(m, new HashSet<Mod>());
                                        res.get(m).add(other);
                                }
                        }
                }

                return res;
        }

        /**
         * Check for conflicts between given mods
         * 
         * @param mods
         *            Mods to check
         * @return Conflicting mods
         */
        public HashMap<Mod, HashSet<Mod>> checkConflicts(TreeSet<Mod> mods) {
                // TODO: Verify functionality
                HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();

                for (Mod m : mods) {
                        for (int confNum : m.getConflicts()) {
                                Mod other = getModByNumber(confNum);
                                if (mods.contains(other)) {
                                        if (!res.containsKey(m))
                                                res.put(m, new HashSet<Mod>());
                                        res.get(m).add(other);
                                }
                        }
                }

                return res;
        }

}
Revision:	602
Committed:	Thu Jan 10 15:39:53 2013 UTC (12 years, 9 months ago) by alloc
Content type:	text/x-java
File size:	4810 byte(s)
Log Message:	AEI2
#	Content
1	package net.oni2.aeinstaller.backend.mods;
2
3	import java.io.File;
4	import java.io.FileFilter;
5	import java.util.Collection;
6	import java.util.HashMap;
7	import java.util.HashSet;
8	import java.util.TreeSet;
9	import java.util.Vector;
10
11	import net.oni2.aeinstaller.backend.Paths;
12	import net.oni2.aeinstaller.backend.depot.DepotConfig;
13	import net.oni2.aeinstaller.backend.depot.DepotManager;
14	import net.oni2.aeinstaller.backend.depot.model.NodeMod;
15	import net.oni2.aeinstaller.backend.depot.model.TaxonomyTerm;
16
17	/**
18	* @author Christian Illy
19	*/
20	public class ModManager {
21	// Download mods
22	// Update mods
23
24	private static ModManager instance = new ModManager();
25
26	private HashMap<String, Type> types = new HashMap<String, Type>();
27	private HashMap<Integer, Mod> mods = new HashMap<Integer, Mod>();
28	private HashMap<Integer, Mod> tools = new HashMap<Integer, Mod>();
29
30	/**
31	* First initialization of ModManager
32	*/
33	public void init() {
34	types = new HashMap<String, Type>();
35	mods = new HashMap<Integer, Mod>();
36
37	types.put("-Local-", new Type("-Local-", null));
38
39	for (TaxonomyTerm tt : DepotManager.getInstance()
40	.getTaxonomyTermsByVocabulary(
41	DepotManager.getInstance().getVocabIdType())) {
42	types.put(tt.getName(), new Type(tt.getName(), tt));
43	}
44
45	HashMap<Integer, Mod> modFolders = new HashMap<Integer, Mod>();
46	if (Paths.getModsPath().exists()) {
47	for (File f : Paths.getModsPath().listFiles(new FileFilter() {
48	@Override
49	public boolean accept(File pathname) {
50	return pathname.isDirectory();
51	}
52	})) {
53	Mod m = new Mod(f);
54	modFolders.put(m.getPackageNumber(), m);
55	}
56	}
57
58	TaxonomyTerm toolTerm = DepotManager.getInstance().getTaxonomyTerm(
59	DepotConfig.getTaxonomyName_ModType_Tool());
60	for (NodeMod nm : DepotManager.getInstance().getModPackageNodes()) {
61	if (nm.getUploads().size() == 1) {
62	Mod m = new Mod(nm);
63	if (nm.getTypes().contains(toolTerm))
64	tools.put(m.getPackageNumber(), m);
65	else
66	mods.put(m.getPackageNumber(), m);
67	modFolders.remove(m.getPackageNumber());
68	}
69	}
70
71	for (Mod m : modFolders.values()) {
72	mods.put(m.getPackageNumber(), m);
73	}
74	}
75
76	public void refreshLocalMods() {
77	// TODO: evtl nur private e.g. als listener für downloads?
78	}
79
80	/**
81	* @return Singleton instance
82	*/
83	public static ModManager getInstance() {
84	return instance;
85	}
86
87	Type getTypeByName(String name) {
88	return types.get(name);
89	}
90
91	/**
92	* @return Collection of types which do have mods associated
93	*/
94	public Collection<Type> getTypesWithContent() {
95	Vector<Type> res = new Vector<Type>();
96	for (Type t : types.values()) {
97	if (t.getEntries().size() > 0)
98	res.add(t);
99	}
100	return res;
101	}
102
103	/**
104	* @return Collection of mods
105	*/
106	public Collection<Mod> getMods() {
107	return mods.values();
108	}
109
110	/**
111	* @return Mods which are always installed
112	*/
113	public Collection<Mod> getMandatoryMods() {
114	Vector<Mod> res = new Vector<Mod>();
115	for (Mod m : mods.values()) {
116	if (m.isMandatoryMod())
117	res.add(m);
118	}
119	return res;
120	}
121
122	/**
123	* @return Collection of tools
124	*/
125	public Collection<Mod> getTools() {
126	return tools.values();
127	}
128
129	/**
130	* @return Tools which are always installed
131	*/
132	public Collection<Mod> getMandatoryTools() {
133	Vector<Mod> res = new Vector<Mod>();
134	for (Mod m : tools.values()) {
135	if (m.isMandatoryMod())
136	res.add(m);
137	}
138	return res;
139	}
140
141	/**
142	* Get a mod by its package number
143	*
144	* @param number
145	* Package number
146	* @return Mod or null
147	*/
148	public Mod getModByNumber(int number) {
149	for (Mod m : mods.values()) {
150	if (m.getPackageNumber() == number)
151	return m;
152	}
153	return null;
154	}
155
156	/**
157	* Check for unresolved dependencies within the given mods
158	*
159	* @param mods
160	* Mods to check
161	* @return Unmet dependencies
162	*/
163	public HashMap<Mod, HashSet<Mod>> checkDependencies(TreeSet<Mod> mods) {
164	// TODO: Verify functionality
165	HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();
166
167	for (Mod m : mods) {
168	for (int depNum : m.getDependencies()) {
169	Mod other = getModByNumber(depNum);
170	if (!mods.contains(other)) {
171	if (!res.containsKey(m))
172	res.put(m, new HashSet<Mod>());
173	res.get(m).add(other);
174	}
175	}
176	}
177
178	return res;
179	}
180
181	/**
182	* Check for conflicts between given mods
183	*
184	* @param mods
185	* Mods to check
186	* @return Conflicting mods
187	*/
188	public HashMap<Mod, HashSet<Mod>> checkConflicts(TreeSet<Mod> mods) {
189	// TODO: Verify functionality
190	HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();
191
192	for (Mod m : mods) {
193	for (int confNum : m.getConflicts()) {
194	Mod other = getModByNumber(confNum);
195	if (mods.contains(other)) {
196	if (!res.containsKey(m))
197	res.put(m, new HashSet<Mod>());
198	res.get(m).add(other);
199	}
200	}
201	}
202
203	return res;
204	}
205
206	}