backend/packages/PackageManager.java

package net.oni2.aeinstaller.backend.packages;

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.TreeSet;
import java.util.Vector;

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;

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

/**
 * @author Christian Illy
 */
public class PackageManager {
        private static PackageManager instance = new PackageManager();

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

        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<Package> mods) {
                try {
                        Vector<Integer> installed = new Vector<Integer>();
                        for (Package 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, Package>();

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

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

                for (Package m : modFolders.values()) {
                        if (!m.isCorePackage()) {
                                localType.addEntry(m);
                                m.getTypes().add(localType);
                        }
                        if (m.isTool())
                                tools.put(m.getPackageNumber(), m);
                        else
                                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 PackageManager 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 core package
         */
        public Collection<Package> getModsValidAndNotCore() {
                Vector<Package> res = new Vector<Package>();
                for (Package m : mods.values())
                        if (m.isValidOnPlatform() && !m.isCorePackage())
                                res.add(m);
                return res;
        }

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

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

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

        /**
         * @return Collection of tools valid on this platform and not core
         */
        public Collection<Package> getTools() {
                Vector<Package> res = new Vector<Package>();
                for (Package m : tools.values())
                        if (m.isValidOnPlatform() && !m.isCorePackage())
                                res.add(m);
                return res;
        }

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

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

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

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

        /**
         * Get a mod/tool by its package number
         * 
         * @param number
         *            Package number
         * @return Mod/tool or null
         */
        private Package getPackageByNumber(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<Package, HashSet<Package>> checkDependencies(TreeSet<Package> mods) {
                HashMap<Package, HashSet<Package>> res = new HashMap<Package, HashSet<Package>>();

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

                return res;
        }

        /**
         * Check for incompabitilites between given mods
         * 
         * @param mods
         *            Mods to check
         * @return Incompatible mods
         */
        public HashMap<Package, HashSet<Package>> checkIncompabitilites(TreeSet<Package> mods) {
                HashMap<Package, HashSet<Package>> res = new HashMap<Package, HashSet<Package>>();

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

                return res;
        }

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