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.oni.management.ModInstallationList;
import net.oni2.aeinstaller.backend.oni.management.tools.ToolInstallationList;
import net.oni2.moddepot.DepotManager;
import net.oni2.moddepot.model.NodeMod;
import net.oni2.moddepot.model.TaxonomyTerm;

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>();

        /**
         * @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-");
                types.put("-Local-", localType);

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

                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) {
                                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);
                }
        }

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