filealias.cpp
1 //------------------------------------------------------------------------------
2 // filealias.cpp
3 //------------------------------------------------------------------------------
4 //
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License, or (at your option) any later version.
9 //
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
18 // 02110-1301 USA
19 //
20 //------------------------------------------------------------------------------
21 // Copyright (C) 2014 "Zalewa" <zalewapl@gmail.com>
22 //------------------------------------------------------------------------------
23 #include "filealias.h"
24 
25 #include <cassert>
26 
27 FileAlias::FileAlias()
28 {
29  d.matchType = FileAlias::LeftToRight;
30 }
31 
32 FileAlias::FileAlias(const QString &name)
33 {
34  d.matchType = FileAlias::LeftToRight;
35  d.name = name;
36 }
37 
38 void FileAlias::addAlias(const QString &val)
39 {
40  if (!d.aliases.contains(val, Qt::CaseInsensitive))
41  {
42  d.aliases << val;
43  }
44 }
45 
46 void FileAlias::addAliases(const QStringList &val)
47 {
48  foreach (const QString &element, val)
49  {
50  addAlias(element);
51  }
52 }
53 
54 const QStringList &FileAlias::aliases() const
55 {
56  return d.aliases;
57 }
58 
59 void FileAlias::setAliases(const QStringList &val)
60 {
61  d.aliases = val;
62 }
63 
64 FileAlias FileAlias::deserializeQVariant(const QVariant &var)
65 {
66  QVariantMap m = var.toMap();
67  FileAlias result;
68  result.setAliases(m["aliases"].toStringList());
69  result.setMatchType(deserializeMatchType(m["matchType"]));
70  result.setName(m["name"].toString());
71  return result;
72 }
73 
74 QVariant FileAlias::serializeQVariant() const
75 {
76  QVariantMap m;
77  m["aliases"] = aliases();
78  m["matchType"] = serializeMatchType(matchType());
79  m["name"] = name();
80  return m;
81 }
82 
83 FileAlias::MatchType FileAlias::deserializeMatchType(const QVariant &variant)
84 {
85  QString val = variant.toString();
86  if (val == "LeftToRight")
87  return LeftToRight;
88  else if (val == "AllEqual")
89  return AllEqual;
90  // Default return value.
91  return LeftToRight;
92 }
93 
94 QVariant FileAlias::serializeMatchType(MatchType matchType)
95 {
96  switch (matchType)
97  {
98  default:
99  assert(false && "don't know how to serialize this FileAlias::MatchType");
100  // intentional fall-through
101  case LeftToRight:
102  return "LeftToRight";
103  case AllEqual:
104  return "AllEqual";
105  }
106 }
107 
108 FileAlias FileAlias::freeDoom1Aliases()
109 {
110  FileAlias result;
111  result.setName("doom.wad");
112  QStringList aliases;
113  aliases << "freedomu.wad" << "freedoom1.wad";
114  result.setAliases(aliases);
115  result.setMatchType(LeftToRight);
116  return result;
117 }
118 
119 QList<FileAlias> FileAlias::freeDoom2Aliases()
120 {
121  QStringList bases;
122  // Each of these are equivalent in terms of modern source-ports.
123  // If custom levels require one of those WADs as a base, I'd assume
124  // they will run just fine with any of them, and thus also with freedoom.
125  bases << "doom2.wad" << "tnt.wad" << "plutonia.wad";
126  QList<FileAlias> result;
127  foreach (const QString &base, bases)
128  {
129  FileAlias alias;
130  alias.setName(base);
131  alias.setMatchType(LeftToRight);
132  QStringList aliases;
133  aliases << "freedoom.wad" << "freedoom2.wad";
134  alias.setAliases(aliases);
135  result << alias;
136  }
137  return result;
138 }
139 
140 bool FileAlias::isSameName(const QString &otherName) const
141 {
142  return d.name.compare(otherName, Qt::CaseInsensitive) == 0;
143 }
144 
145 bool FileAlias::isValid() const
146 {
147  return !name().isEmpty() && !aliases().isEmpty();
148 }
149 
150 FileAlias::MatchType FileAlias::matchType() const
151 {
152  return d.matchType;
153 }
154 
155 void FileAlias::setMatchType(MatchType matchType)
156 {
157  d.matchType = matchType;
158 }
159 
160 const QString &FileAlias::name() const
161 {
162  return d.name;
163 }
164 
165 void FileAlias::setName(const QString &val)
166 {
167  d.name = val;
168 }
169 
171 {
172  QList<FileAlias> result;
173  result << freeDoom1Aliases();
174  foreach (const FileAlias &alias, freeDoom2Aliases())
175  {
176  result << alias;
177  }
178  return result;
179 }
181 QStringList FileAliasList::aliases(const QList<FileAlias> &candidates, const QString &name)
182 {
183  QStringList allAliases;
184  foreach (const FileAlias &candidate, candidates)
185  {
186  switch (candidate.matchType())
187  {
188  case FileAlias::LeftToRight:
189  if (candidate.name().compare(name, Qt::CaseInsensitive) == 0)
190  allAliases << candidate.aliases();
191  break;
192  case FileAlias::AllEqual:
193  {
194  QStringList allValidNames;
195  allValidNames << candidate.name();
196  allValidNames << candidate.aliases();
197  if (allValidNames.contains(name, Qt::CaseInsensitive))
198  allAliases << allValidNames;
199  break;
200  }
201  default:
202  assert(false && "unknown FileAlias::MatchType");
203  break;
204  }
205  }
206  // Normalize to remove duplicates and the source name.
207  allAliases.removeDuplicates();
208  allAliases.removeAll(name);
209  return allAliases;
210 }
211 
212 QList<FileAlias> FileAliasList::mergeDuplicates(const QList<FileAlias> &input)
213 {
214  QList<FileAlias> result;
215  foreach (const FileAlias &alias, input)
216  {
217  bool merged = false;
218  for (int i = 0; i < result.size(); ++i)
219  {
220  FileAlias &aliasOnList = result[i];
221  if (aliasOnList.isSameName(alias.name()) && aliasOnList.matchType() == alias.matchType())
222  {
223  aliasOnList.addAliases(alias.aliases());
224  merged = true;
225  break;
226  }
227  }
228  if (!merged)
229  {
230  result << alias;
231  }
232  }
233  return result;
234 }
bool isValid() const
Valid FileAlias has a name and at least one alias.
Definition: filealias.cpp:145
void addAliases(const QStringList &val)
Will ensure unique values.
Definition: filealias.cpp:46
static QList< FileAlias > standardWadAliases()
Standard/default aliases for configuration init.
Definition: filealias.cpp:170
bool isSameName(const QString &otherName) const
Compares passed string to local name and checks if they&#39;re same.
Definition: filealias.cpp:140
void addAlias(const QString &val)
Will ensure unique values.
Definition: filealias.cpp:38
static QStringList aliases(const QList< FileAlias > &candidates, const QString &name)
Definition: filealias.cpp:181