backend/mods/ModManager.java

package net.oni2.aeinstaller.backend.mods;

import java.io.File;
import java.io.FileFilter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.StaxDriver;

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

/**
 * @author Christian Illy
 */
public class ModManager {
        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>();

        private Vector<Integer> currentlyInstalled = new Vector<Integer>();

        /**
         * @param f
         *            Mod selection file
         * @return Mod selection
         */
        @SuppressWarnings("unchecked")
        public Vector<Integer> loadModSelection(File f) {
                Vector<Integer> res = new Vector<Integer>();
                try {
                        if (f.exists()) {
                                FileInputStream fis = new FileInputStream(f);
                                XStream xs = new XStream(new StaxDriver());
                                Object obj = xs.fromXML(fis);
                                if (obj instanceof Vector<?>)
                                        res = (Vector<Integer>) obj;
                                fis.close();
                        }
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
                return res;
        }

        /**
         * @param f
         *            Mod selection file
         * @param mods
         *            Selected mods
         */
        public void saveModSelection(File f, TreeSet<Mod> mods) {
                try {
                        Vector<Integer> installed = new Vector<Integer>();
                        for (Mod m : mods) {
                                installed.add(m.getPackageNumber());
                        }
                        FileOutputStream fos = new FileOutputStream(f);
                        XStream xs = new XStream(new StaxDriver());
                        xs.toXML(installed, fos);
                        fos.close();
                } catch (FileNotFoundException e) {
                        e.printStackTrace();
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

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

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

                for (TaxonomyTerm tt : DepotManager.getInstance().getTypes()) {
                        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);
                        }
                }

                for (NodeMod nm : DepotManager.getInstance().getModPackageNodes()) {
                        if (nm.getUploads().size() == 1) {
                                Mod m = new Mod(nm);
                                if (nm.isTool())
                                        tools.put(m.getPackageNumber(), m);
                                else
                                        mods.put(m.getPackageNumber(), m);
                                modFolders.remove(m.getPackageNumber());
                        }
                }

                for (Mod m : modFolders.values()) {
                        if (!m.isMandatoryMod()) {
                                localType.addEntry(m);
                                m.getTypes().add(localType);
                        }
                        mods.put(m.getPackageNumber(), m);
                }

                updateInstalledMods();
        }

        /**
         * Update the list of currently installed mods
         */
        public void updateInstalledMods() {
                currentlyInstalled = Installer.getInstalledMods();
                if (currentlyInstalled == null)
                        currentlyInstalled = new Vector<Integer>();
        }

        /**
         * @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 valid on this platform and not mandatory
         */
        public Collection<Mod> getModsValidAndNotMandatory() {
                Vector<Mod> res = new Vector<Mod>();
                for (Mod m : mods.values())
                        if (m.isValidOnPlatform() && !m.isMandatoryMod())
                                res.add(m);
                return res;
        }

        /**
         * @return Mods which are always installed and valid on this platform
         */
        public TreeSet<Mod> getMandatoryMods() {
                TreeSet<Mod> res = new TreeSet<Mod>();
                for (Mod m : mods.values()) {
                        if (m.isValidOnPlatform() && m.isMandatoryMod())
                                res.add(m);
                }
                return res;
        }

        /**
         * @return Mods which are already locally available
         */
        public TreeSet<Mod> getLocalAvailableMods() {
                TreeSet<Mod> res = new TreeSet<Mod>();
                for (Mod m : mods.values()) {
                        if (m.isLocalAvailable())
                                res.add(m);
                }
                return res;
        }

        /**
         * @return Mods which can be updated
         */
        public TreeSet<Mod> getUpdatableMods() {
                TreeSet<Mod> res = new TreeSet<Mod>();
                for (Mod m : getLocalAvailableMods()) {
                        if (m.isNewerAvailable())
                                res.add(m);
                }
                return res;
        }

        /**
         * @return Collection of tools valid on this platform and not mandatory
         */
        public TreeMap<String, Mod> getTools() {
                TreeMap<String, Mod> res = new TreeMap<String, Mod>();
                for (Mod m : tools.values())
                        if (m.isValidOnPlatform() && !m.isMandatoryMod())
                                res.put(m.getName(), m);
                return res;
        }

        /**
         * @return Tools which are always installed and valid on this platform
         */
        public TreeSet<Mod> getMandatoryTools() {
                TreeSet<Mod> res = new TreeSet<Mod>();
                for (Mod m : tools.values()) {
                        if (m.isValidOnPlatform() && m.isMandatoryMod())
                                res.add(m);
                }
                return res;
        }

        /**
         * @return Tools which are already locally available
         */
        public TreeSet<Mod> getLocalAvailableTools() {
                TreeSet<Mod> res = new TreeSet<Mod>();
                for (Mod m : tools.values()) {
                        if (m.isLocalAvailable())
                                res.add(m);
                }
                return res;
        }

        /**
         * @return Tools which can be updated
         */
        public TreeSet<Mod> getUpdatableTools() {
                TreeSet<Mod> res = new TreeSet<Mod>();
                for (Mod m : getLocalAvailableTools()) {
                        if (m.isNewerAvailable())
                                res.add(m);
                }
                return res;
        }

        /**
         * @return Currently installed tools
         */
        public TreeSet<Mod> getInstalledTools() {
                TreeSet<Mod> res = new TreeSet<Mod>();
                for (int n : Installer.getInstalledTools()) {
                        res.add(getModByNumber(n));
                }
                return res;
        }

        /**
         * Get a mod/tool by its package number
         * 
         * @param number
         *            Package number
         * @return Mod/tool or null
         */
        private Mod getModByNumber(int number) {
                if (mods.containsKey(number))
                        return mods.get(number);
                if (tools.containsKey(number))
                        return tools.get(number);
                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 (checkDependencies)
                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 incompabitilites between given mods
         * 
         * @param mods
         *            Mods to check
         * @return Incompatible mods
         */
        public HashMap<Mod, HashSet<Mod>> checkIncompabitilites(TreeSet<Mod> mods) {
                // TODO: Verify functionality (checkIncompatibilities)
                HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();

                for (Mod m : mods) {
                        for (int confNum : m.getIncompabitilities()) {
                                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;
        }

        /**
         * @param m
         *            Mod to check
         * @return Is mod installed?
         */
        boolean isModInstalled(Mod m) {
                return currentlyInstalled.contains(m.getPackageNumber());
        }
}
Revision:	637
Committed:	Sun Jan 20 11:28:12 2013 UTC (12 years, 8 months ago) by alloc
Content type:	text/x-java
File size:	8320 byte(s)
Log Message:	AEI2 0.94: - Added context menu item to open Depot page of mod in table - Added last-change column to table
#	Content
1	package net.oni2.aeinstaller.backend.mods;
2
3	import java.io.File;
4	import java.io.FileFilter;
5	import java.io.FileInputStream;
6	import java.io.FileNotFoundException;
7	import java.io.FileOutputStream;
8	import java.io.IOException;
9	import java.util.Collection;
10	import java.util.HashMap;
11	import java.util.HashSet;
12	import java.util.TreeMap;
13	import java.util.TreeSet;
14	import java.util.Vector;
15
16	import com.thoughtworks.xstream.XStream;
17	import com.thoughtworks.xstream.io.xml.StaxDriver;
18
19	import net.oni2.aeinstaller.backend.Paths;
20	import net.oni2.aeinstaller.backend.depot.DepotManager;
21	import net.oni2.aeinstaller.backend.depot.model.NodeMod;
22	import net.oni2.aeinstaller.backend.depot.model.TaxonomyTerm;
23	import net.oni2.aeinstaller.backend.oni.Installer;
24
25	/**
26	* @author Christian Illy
27	*/
28	public class ModManager {
29	private static ModManager instance = new ModManager();
30
31	private HashMap<String, Type> types = new HashMap<String, Type>();
32	private HashMap<Integer, Mod> mods = new HashMap<Integer, Mod>();
33	private HashMap<Integer, Mod> tools = new HashMap<Integer, Mod>();
34
35	private Vector<Integer> currentlyInstalled = new Vector<Integer>();
36
37	/**
38	* @param f
39	* Mod selection file
40	* @return Mod selection
41	*/
42	@SuppressWarnings("unchecked")
43	public Vector<Integer> loadModSelection(File f) {
44	Vector<Integer> res = new Vector<Integer>();
45	try {
46	if (f.exists()) {
47	FileInputStream fis = new FileInputStream(f);
48	XStream xs = new XStream(new StaxDriver());
49	Object obj = xs.fromXML(fis);
50	if (obj instanceof Vector<?>)
51	res = (Vector<Integer>) obj;
52	fis.close();
53	}
54	} catch (FileNotFoundException e) {
55	e.printStackTrace();
56	} catch (IOException e) {
57	e.printStackTrace();
58	}
59	return res;
60	}
61
62	/**
63	* @param f
64	* Mod selection file
65	* @param mods
66	* Selected mods
67	*/
68	public void saveModSelection(File f, TreeSet<Mod> mods) {
69	try {
70	Vector<Integer> installed = new Vector<Integer>();
71	for (Mod m : mods) {
72	installed.add(m.getPackageNumber());
73	}
74	FileOutputStream fos = new FileOutputStream(f);
75	XStream xs = new XStream(new StaxDriver());
76	xs.toXML(installed, fos);
77	fos.close();
78	} catch (FileNotFoundException e) {
79	e.printStackTrace();
80	} catch (IOException e) {
81	e.printStackTrace();
82	}
83	}
84
85	/**
86	* First initialization of ModManager
87	*/
88	public void init() {
89	types = new HashMap<String, Type>();
90	mods = new HashMap<Integer, Mod>();
91
92	Type localType = new Type("-Local-", null);
93	types.put("-Local-", localType);
94
95	for (TaxonomyTerm tt : DepotManager.getInstance().getTypes()) {
96	types.put(tt.getName(), new Type(tt.getName(), tt));
97	}
98
99	HashMap<Integer, Mod> modFolders = new HashMap<Integer, Mod>();
100	if (Paths.getModsPath().exists()) {
101	for (File f : Paths.getModsPath().listFiles(new FileFilter() {
102	@Override
103	public boolean accept(File pathname) {
104	return pathname.isDirectory();
105	}
106	})) {
107	Mod m = new Mod(f);
108	modFolders.put(m.getPackageNumber(), m);
109	}
110	}
111
112	for (NodeMod nm : DepotManager.getInstance().getModPackageNodes()) {
113	if (nm.getUploads().size() == 1) {
114	Mod m = new Mod(nm);
115	if (nm.isTool())
116	tools.put(m.getPackageNumber(), m);
117	else
118	mods.put(m.getPackageNumber(), m);
119	modFolders.remove(m.getPackageNumber());
120	}
121	}
122
123	for (Mod m : modFolders.values()) {
124	if (!m.isMandatoryMod()) {
125	localType.addEntry(m);
126	m.getTypes().add(localType);
127	}
128	mods.put(m.getPackageNumber(), m);
129	}
130
131	updateInstalledMods();
132	}
133
134	/**
135	* Update the list of currently installed mods
136	*/
137	public void updateInstalledMods() {
138	currentlyInstalled = Installer.getInstalledMods();
139	if (currentlyInstalled == null)
140	currentlyInstalled = new Vector<Integer>();
141	}
142
143	/**
144	* @return Singleton instance
145	*/
146	public static ModManager getInstance() {
147	return instance;
148	}
149
150	Type getTypeByName(String name) {
151	return types.get(name);
152	}
153
154	/**
155	* @return Collection of types which do have mods associated
156	*/
157	public Collection<Type> getTypesWithContent() {
158	Vector<Type> res = new Vector<Type>();
159	for (Type t : types.values()) {
160	if (t.getEntries().size() > 0)
161	res.add(t);
162	}
163	return res;
164	}
165
166	/**
167	* @return Collection of mods valid on this platform and not mandatory
168	*/
169	public Collection<Mod> getModsValidAndNotMandatory() {
170	Vector<Mod> res = new Vector<Mod>();
171	for (Mod m : mods.values())
172	if (m.isValidOnPlatform() && !m.isMandatoryMod())
173	res.add(m);
174	return res;
175	}
176
177	/**
178	* @return Mods which are always installed and valid on this platform
179	*/
180	public TreeSet<Mod> getMandatoryMods() {
181	TreeSet<Mod> res = new TreeSet<Mod>();
182	for (Mod m : mods.values()) {
183	if (m.isValidOnPlatform() && m.isMandatoryMod())
184	res.add(m);
185	}
186	return res;
187	}
188
189	/**
190	* @return Mods which are already locally available
191	*/
192	public TreeSet<Mod> getLocalAvailableMods() {
193	TreeSet<Mod> res = new TreeSet<Mod>();
194	for (Mod m : mods.values()) {
195	if (m.isLocalAvailable())
196	res.add(m);
197	}
198	return res;
199	}
200
201	/**
202	* @return Mods which can be updated
203	*/
204	public TreeSet<Mod> getUpdatableMods() {
205	TreeSet<Mod> res = new TreeSet<Mod>();
206	for (Mod m : getLocalAvailableMods()) {
207	if (m.isNewerAvailable())
208	res.add(m);
209	}
210	return res;
211	}
212
213	/**
214	* @return Collection of tools valid on this platform and not mandatory
215	*/
216	public TreeMap<String, Mod> getTools() {
217	TreeMap<String, Mod> res = new TreeMap<String, Mod>();
218	for (Mod m : tools.values())
219	if (m.isValidOnPlatform() && !m.isMandatoryMod())
220	res.put(m.getName(), m);
221	return res;
222	}
223
224	/**
225	* @return Tools which are always installed and valid on this platform
226	*/
227	public TreeSet<Mod> getMandatoryTools() {
228	TreeSet<Mod> res = new TreeSet<Mod>();
229	for (Mod m : tools.values()) {
230	if (m.isValidOnPlatform() && m.isMandatoryMod())
231	res.add(m);
232	}
233	return res;
234	}
235
236	/**
237	* @return Tools which are already locally available
238	*/
239	public TreeSet<Mod> getLocalAvailableTools() {
240	TreeSet<Mod> res = new TreeSet<Mod>();
241	for (Mod m : tools.values()) {
242	if (m.isLocalAvailable())
243	res.add(m);
244	}
245	return res;
246	}
247
248	/**
249	* @return Tools which can be updated
250	*/
251	public TreeSet<Mod> getUpdatableTools() {
252	TreeSet<Mod> res = new TreeSet<Mod>();
253	for (Mod m : getLocalAvailableTools()) {
254	if (m.isNewerAvailable())
255	res.add(m);
256	}
257	return res;
258	}
259
260	/**
261	* @return Currently installed tools
262	*/
263	public TreeSet<Mod> getInstalledTools() {
264	TreeSet<Mod> res = new TreeSet<Mod>();
265	for (int n : Installer.getInstalledTools()) {
266	res.add(getModByNumber(n));
267	}
268	return res;
269	}
270
271	/**
272	* Get a mod/tool by its package number
273	*
274	* @param number
275	* Package number
276	* @return Mod/tool or null
277	*/
278	private Mod getModByNumber(int number) {
279	if (mods.containsKey(number))
280	return mods.get(number);
281	if (tools.containsKey(number))
282	return tools.get(number);
283	return null;
284	}
285
286	/**
287	* Check for unresolved dependencies within the given mods
288	*
289	* @param mods
290	* Mods to check
291	* @return Unmet dependencies
292	*/
293	public HashMap<Mod, HashSet<Mod>> checkDependencies(TreeSet<Mod> mods) {
294	// TODO: Verify functionality (checkDependencies)
295	HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();
296
297	for (Mod m : mods) {
298	for (int depNum : m.getDependencies()) {
299	Mod other = getModByNumber(depNum);
300	if (!mods.contains(other)) {
301	if (!res.containsKey(m))
302	res.put(m, new HashSet<Mod>());
303	res.get(m).add(other);
304	}
305	}
306	}
307
308	return res;
309	}
310
311	/**
312	* Check for incompabitilites between given mods
313	*
314	* @param mods
315	* Mods to check
316	* @return Incompatible mods
317	*/
318	public HashMap<Mod, HashSet<Mod>> checkIncompabitilites(TreeSet<Mod> mods) {
319	// TODO: Verify functionality (checkIncompatibilities)
320	HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();
321
322	for (Mod m : mods) {
323	for (int confNum : m.getIncompabitilities()) {
324	Mod other = getModByNumber(confNum);
325	if (mods.contains(other)) {
326	if (!res.containsKey(m))
327	res.put(m, new HashSet<Mod>());
328	res.get(m).add(other);
329	}
330	}
331	}
332
333	return res;
334	}
335
336	/**
337	* @param m
338	* Mod to check
339	* @return Is mod installed?
340	*/
341	boolean isModInstalled(Mod m) {
342	return currentlyInstalled.contains(m.getPackageNumber());
343	}
344	}