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

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

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

        /**
         * 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 incompabitilites between given mods
         * 
         * @param mods
         *            Mods to check
         * @return Incompatible mods
         */
        public HashMap<Mod, HashSet<Mod>> checkIncompabitilites(TreeSet<Mod> mods) {
                // TODO: Verify functionality
                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?
         */
        public boolean isModInstalled(Mod m) {
                return currentlyInstalled.contains(m.getPackageNumber());
        }
}
Revision:	608
Committed:	Mon Jan 14 17:49:25 2013 UTC (12 years, 8 months ago) by alloc
Content type:	text/x-java
File size:	6908 byte(s)
Log Message:	AEI2: - Added BSL handling to installation - Updated config-terms for dependencies/incompatibilities - Fixed mod counts for types - Open Edition folder through menu - Open folder of already downloaded mod through context menu - (Semi?)Fixed launching Oni on MacOS - Settings: Added checkbox for update notification
#	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.TreeSet;
13	import java.util.Vector;
14
15	import com.thoughtworks.xstream.XStream;
16	import com.thoughtworks.xstream.io.xml.StaxDriver;
17
18	import net.oni2.aeinstaller.backend.Paths;
19	import net.oni2.aeinstaller.backend.depot.DepotManager;
20	import net.oni2.aeinstaller.backend.depot.model.NodeMod;
21	import net.oni2.aeinstaller.backend.depot.model.TaxonomyTerm;
22	import net.oni2.aeinstaller.backend.oni.Installer;
23
24	/**
25	* @author Christian Illy
26	*/
27	public class ModManager {
28	private static ModManager instance = new ModManager();
29
30	private HashMap<String, Type> types = new HashMap<String, Type>();
31	private HashMap<Integer, Mod> mods = new HashMap<Integer, Mod>();
32	private HashMap<Integer, Mod> tools = new HashMap<Integer, Mod>();
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<Mod> mods) {
68	try {
69	Vector<Integer> installed = new Vector<Integer>();
70	for (Mod 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, Mod>();
90
91	Type localType = new Type("-Local-", null);
92	types.put("-Local-", localType);
93
94	for (TaxonomyTerm tt : DepotManager.getInstance()
95	.getTaxonomyTermsByVocabulary(
96	DepotManager.getInstance().getVocabIdType())) {
97	types.put(tt.getName(), new Type(tt.getName(), tt));
98	}
99
100	HashMap<Integer, Mod> modFolders = new HashMap<Integer, Mod>();
101	if (Paths.getModsPath().exists()) {
102	for (File f : Paths.getModsPath().listFiles(new FileFilter() {
103	@Override
104	public boolean accept(File pathname) {
105	return pathname.isDirectory();
106	}
107	})) {
108	Mod m = new Mod(f);
109	modFolders.put(m.getPackageNumber(), m);
110	}
111	}
112
113	for (NodeMod nm : DepotManager.getInstance().getModPackageNodes()) {
114	if (nm.getUploads().size() == 1) {
115	Mod m = new Mod(nm);
116	if (nm.isTool())
117	tools.put(m.getPackageNumber(), m);
118	else
119	mods.put(m.getPackageNumber(), m);
120	modFolders.remove(m.getPackageNumber());
121	}
122	}
123
124	for (Mod m : modFolders.values()) {
125	if (!m.isMandatoryMod()) {
126	localType.addEntry(m);
127	m.getTypes().add(localType);
128	}
129	mods.put(m.getPackageNumber(), m);
130	}
131
132	currentlyInstalled = Installer.getInstalledMods();
133	if (currentlyInstalled == null)
134	currentlyInstalled = new Vector<Integer>();
135	}
136
137	/**
138	* @return Singleton instance
139	*/
140	public static ModManager getInstance() {
141	return instance;
142	}
143
144	Type getTypeByName(String name) {
145	return types.get(name);
146	}
147
148	/**
149	* @return Collection of types which do have mods associated
150	*/
151	public Collection<Type> getTypesWithContent() {
152	Vector<Type> res = new Vector<Type>();
153	for (Type t : types.values()) {
154	if (t.getEntries().size() > 0)
155	res.add(t);
156	}
157	return res;
158	}
159
160	/**
161	* @return Collection of mods valid on this platform and not mandatory
162	*/
163	public Collection<Mod> getModsValidAndNotMandatory() {
164	Vector<Mod> res = new Vector<Mod>();
165	for (Mod m : mods.values())
166	if (m.isValidOnPlatform() && !m.isMandatoryMod())
167	res.add(m);
168	return res;
169	}
170
171	/**
172	* @return Mods which are always installed and valid on this platform
173	*/
174	public TreeSet<Mod> getMandatoryMods() {
175	TreeSet<Mod> res = new TreeSet<Mod>();
176	for (Mod m : mods.values()) {
177	if (m.isValidOnPlatform() && m.isMandatoryMod())
178	res.add(m);
179	}
180	return res;
181	}
182
183	/**
184	* @return Collection of tools valid on this platform and not mandatory
185	*/
186	public Collection<Mod> getTools() {
187	Vector<Mod> res = new Vector<Mod>();
188	for (Mod m : tools.values())
189	if (m.isValidOnPlatform() && !m.isMandatoryMod())
190	res.add(m);
191	return res;
192	}
193
194	/**
195	* @return Tools which are always installed and valid on this platform
196	*/
197	public TreeSet<Mod> getMandatoryTools() {
198	TreeSet<Mod> res = new TreeSet<Mod>();
199	for (Mod m : tools.values()) {
200	if (m.isValidOnPlatform() && m.isMandatoryMod())
201	res.add(m);
202	}
203	return res;
204	}
205
206	/**
207	* Get a mod by its package number
208	*
209	* @param number
210	* Package number
211	* @return Mod or null
212	*/
213	public Mod getModByNumber(int number) {
214	for (Mod m : mods.values()) {
215	if (m.getPackageNumber() == number)
216	return m;
217	}
218	return null;
219	}
220
221	/**
222	* Check for unresolved dependencies within the given mods
223	*
224	* @param mods
225	* Mods to check
226	* @return Unmet dependencies
227	*/
228	public HashMap<Mod, HashSet<Mod>> checkDependencies(TreeSet<Mod> mods) {
229	// TODO: Verify functionality
230	HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();
231
232	for (Mod m : mods) {
233	for (int depNum : m.getDependencies()) {
234	Mod other = getModByNumber(depNum);
235	if (!mods.contains(other)) {
236	if (!res.containsKey(m))
237	res.put(m, new HashSet<Mod>());
238	res.get(m).add(other);
239	}
240	}
241	}
242
243	return res;
244	}
245
246	/**
247	* Check for incompabitilites between given mods
248	*
249	* @param mods
250	* Mods to check
251	* @return Incompatible mods
252	*/
253	public HashMap<Mod, HashSet<Mod>> checkIncompabitilites(TreeSet<Mod> mods) {
254	// TODO: Verify functionality
255	HashMap<Mod, HashSet<Mod>> res = new HashMap<Mod, HashSet<Mod>>();
256
257	for (Mod m : mods) {
258	for (int confNum : m.getIncompabitilities()) {
259	Mod other = getModByNumber(confNum);
260	if (mods.contains(other)) {
261	if (!res.containsKey(m))
262	res.put(m, new HashSet<Mod>());
263	res.get(m).add(other);
264	}
265	}
266	}
267
268	return res;
269	}
270
271	/**
272	* @param m
273	* Mod to check
274	* @return Is mod installed?
275	*/
276	public boolean isModInstalled(Mod m) {
277	return currentlyInstalled.contains(m.getPackageNumber());
278	}
279	}