From 253067c782955380bbf66ac0475dc954375b1ff4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Petr=20Mr=C3=A1zek?= Date: Sat, 17 Aug 2013 13:40:51 +0200 Subject: Move all the things (YES. Move them.) Also, implemented some basic modlist logic, to be wired up. --- depends/util/include/apputils.h | 21 +++ depends/util/include/cmdutils.h | 259 ++++++++++++++++++++++++++++++++++ depends/util/include/libutil_config.h | 27 ++++ depends/util/include/osutils.h | 29 ++++ depends/util/include/pathutils.h | 37 +++++ depends/util/include/siglist.h | 129 +++++++++++++++++ depends/util/include/siglist_impl.h | 156 ++++++++++++++++++++ depends/util/include/userutils.h | 19 +++ 8 files changed, 677 insertions(+) create mode 100644 depends/util/include/apputils.h create mode 100644 depends/util/include/cmdutils.h create mode 100644 depends/util/include/libutil_config.h create mode 100644 depends/util/include/osutils.h create mode 100644 depends/util/include/pathutils.h create mode 100644 depends/util/include/siglist.h create mode 100644 depends/util/include/siglist_impl.h create mode 100644 depends/util/include/userutils.h (limited to 'depends/util/include') diff --git a/depends/util/include/apputils.h b/depends/util/include/apputils.h new file mode 100644 index 00000000..a64adc50 --- /dev/null +++ b/depends/util/include/apputils.h @@ -0,0 +1,21 @@ +/* Copyright 2013 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef APPUTILS_H +#define APPUTILS_H + +#define STR_VAL(val) # val + +#endif // APPUTILS_H diff --git a/depends/util/include/cmdutils.h b/depends/util/include/cmdutils.h new file mode 100644 index 00000000..a6379397 --- /dev/null +++ b/depends/util/include/cmdutils.h @@ -0,0 +1,259 @@ +/* Copyright 2013 MultiMC Contributors + * + * Authors: Orochimarufan + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef CMDUTILS_H +#define CMDUTILS_H + +#include + +#include +#include +#include +#include + +#include "libutil_config.h" + +/** + * @file libutil/include/cmdutils.h + * @brief commandline parsing and processing utilities + */ + +namespace Util { +namespace Commandline { + +/** + * @brief split a string into argv items like a shell would do + * @param args the argument string + * @return a QStringList containing all arguments + */ +LIBUTIL_EXPORT QStringList splitArgs(QString args); + +/** + * @brief The FlagStyle enum + * Specifies how flags are decorated + */ + +namespace FlagStyle +{ +enum LIBUTIL_EXPORT Enum +{ + GNU, /**< --option and -o (GNU Style) */ + Unix, /**< -option and -o (Unix Style) */ + Windows, /**< /option and /o (Windows Style) */ +#ifdef Q_OS_WIN32 + Default = Windows +#else + Default = GNU +#endif +}; +} + +/** + * @brief The ArgumentStyle enum + */ +namespace ArgumentStyle +{ +enum LIBUTIL_EXPORT Enum +{ + Space, /**< --option=value */ + Equals, /**< --option value */ + SpaceAndEquals, /**< --option[= ]value */ +#ifdef Q_OS_WIN32 + Default = Equals +#else + Default = SpaceAndEquals +#endif +}; +} + +/** + * @brief The ParsingError class + */ +class LIBUTIL_EXPORT ParsingError : public std::exception +{ +public: + ParsingError(const QString &what); + ParsingError(const ParsingError &e); + ~ParsingError() throw() {} + const char *what() const throw(); + QString qwhat() const; +private: + QString m_what; +}; + +/** + * @brief The Parser class + */ +class LIBUTIL_EXPORT Parser +{ +public: + /** + * @brief Parser constructor + * @param flagStyle the FlagStyle to use in this Parser + * @param argStyle the ArgumentStyle to use in this Parser + */ + Parser(FlagStyle::Enum flagStyle = FlagStyle::Default, + ArgumentStyle::Enum argStyle = ArgumentStyle::Default); + + /** + * @brief set the flag style + * @param style + */ + void setFlagStyle(FlagStyle::Enum style); + + /** + * @brief get the flag style + * @return + */ + FlagStyle::Enum flagStyle(); + + /** + * @brief set the argument style + * @param style + */ + void setArgumentStyle(ArgumentStyle::Enum style); + + /** + * @brief get the argument style + * @return + */ + ArgumentStyle::Enum argumentStyle(); + + /** + * @brief define a boolean switch + * @param name the parameter name + * @param def the default value + */ + void addSwitch(QString name, bool def = false); + + /** + * @brief define an option that takes an additional argument + * @param name the parameter name + * @param def the default value + */ + void addOption(QString name, QVariant def = QVariant()); + + /** + * @brief define a positional argument + * @param name the parameter name + * @param required wether this argument is required + * @param def the default value + */ + void addArgument(QString name, bool required = true, QVariant def = QVariant()); + + /** + * @brief adds a flag to an existing parameter + * @param name the (existing) parameter name + * @param flag the flag character + * @see addSwitch addArgument addOption + * Note: any one parameter can only have one flag + */ + void addShortOpt(QString name, QChar flag); + + /** + * @brief adds documentation to a Parameter + * @param name the parameter name + * @param metavar a string to be displayed as placeholder for the value + * @param doc a QString containing the documentation + * Note: on positional arguments, metavar replaces the name as displayed. + * on options , metavar replaces the value placeholder + */ + void addDocumentation(QString name, QString doc, QString metavar = QString()); + + /** + * @brief generate a help message + * @param progName the program name to use in the help message + * @param helpIndent how much the parameter documentation should be indented + * @param flagsInUsage whether we should use flags instead of options in the usage + * @return a help message + */ + QString compileHelp(QString progName, int helpIndent = 22, bool flagsInUsage = true); + + /** + * @brief generate a short usage message + * @param progName the program name to use in the usage message + * @param useFlags whether we should use flags instead of options + * @return a usage message + */ + QString compileUsage(QString progName, bool useFlags = true); + + /** + * @brief parse + * @param argv a QStringList containing the program ARGV + * @return a QHash mapping argument names to their values + */ + QHash parse(QStringList argv); + + /** + * @brief clear all definitions + */ + void clear(); + + ~Parser(); + +private: + FlagStyle::Enum m_flagStyle; + ArgumentStyle::Enum m_argStyle; + + enum OptionType + { + otSwitch, + otOption + }; + + // Important: the common part MUST BE COMMON ON ALL THREE structs + struct CommonDef { + QString name; + QString doc; + QString metavar; + QVariant def; + }; + + struct OptionDef { + // common + QString name; + QString doc; + QString metavar; + QVariant def; + // option + OptionType type; + QChar flag; + }; + + struct PositionalDef { + // common + QString name; + QString doc; + QString metavar; + QVariant def; + // positional + bool required; + }; + + QHash m_options; + QHash m_flags; + QHash m_params; + QList m_positionals; + QList m_optionList; + + void getPrefix(QString &opt, QString &flag); +}; + +} +} + +#endif // CMDUTILS_H diff --git a/depends/util/include/libutil_config.h b/depends/util/include/libutil_config.h new file mode 100644 index 00000000..4bf111e6 --- /dev/null +++ b/depends/util/include/libutil_config.h @@ -0,0 +1,27 @@ +/* Copyright 2013 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef LIBUTIL_CONFIG_H +#define LIBUTIL_CONFIG_H + +#include + +#ifdef LIBUTIL_LIBRARY +# define LIBUTIL_EXPORT Q_DECL_EXPORT +#else +# define LIBUTIL_EXPORT Q_DECL_IMPORT +#endif + +#endif // LIBUTIL_CONFIG_H diff --git a/depends/util/include/osutils.h b/depends/util/include/osutils.h new file mode 100644 index 00000000..c5d4bb61 --- /dev/null +++ b/depends/util/include/osutils.h @@ -0,0 +1,29 @@ +/* Copyright 2013 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef OSUTILS_H +#define OSUTILS_H + +#include + +#if defined _WIN32 | defined _WIN64 +#define WINDOWS 1 +#elif __APPLE__ & __MACH__ +#define OSX 1 +#elif __linux__ +#define LINUX 1 +#endif + +#endif // OSUTILS_H diff --git a/depends/util/include/pathutils.h b/depends/util/include/pathutils.h new file mode 100644 index 00000000..d4f41da3 --- /dev/null +++ b/depends/util/include/pathutils.h @@ -0,0 +1,37 @@ +/* Copyright 2013 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef PATHUTILS_H +#define PATHUTILS_H + +#include + +#include "libutil_config.h" + +LIBUTIL_EXPORT QString PathCombine(QString path1, QString path2); +LIBUTIL_EXPORT QString PathCombine(QString path1, QString path2, QString path3); + +LIBUTIL_EXPORT QString AbsolutePath(QString path); + +LIBUTIL_EXPORT QString RemoveInvalidFilenameChars(QString string, QChar replaceWith = '-'); + +LIBUTIL_EXPORT QString DirNameFromString(QString string, QString inDir = "."); + +LIBUTIL_EXPORT bool ensurePathExists(QString filenamepath); + +LIBUTIL_EXPORT bool copyPath(QString src, QString dst); + + +#endif // PATHUTILS_H diff --git a/depends/util/include/siglist.h b/depends/util/include/siglist.h new file mode 100644 index 00000000..24b1a889 --- /dev/null +++ b/depends/util/include/siglist.h @@ -0,0 +1,129 @@ +/* Copyright 2013 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef SIGLIST_H +#define SIGLIST_H + +#include +#include + +// A QList that allows emitting signals when the list changes. +// Since QObject doesn't support templates, to use this class with a +// certain type, you should create a class deriving from SigList and then +// call the DEFINE_SIGLIST_SIGNALS(T) and SETUP_SIGLIST_SIGNALS(T) macros. +template +class SigList : public QList +{ +public: + explicit SigList() : QList() {} + + virtual void append(const T &value); + virtual void append(const QList &other); + + virtual void clear(); + + virtual void erase(typename QList::iterator pos); + virtual void erase(typename QList::iterator first, typename QList::iterator last); + + virtual void insert(int i, const T &t); + virtual void insert(typename QList::iterator before, const T &t); + + virtual void move(int from, int to); + + virtual void pop_back() { takeLast(); } + virtual void pop_front() { takeFirst(); } + + virtual void push_back(const T &t) { append(t); } + virtual void push_front(const T &t) { prepend(t); } + + virtual void prepend(const T &t); + + virtual int removeAll(const T &t); + virtual bool removeOne(const T &t); + + virtual void removeAt(int i) { takeAt(i); } + virtual void removeFirst() { takeFirst(); } + virtual void removeLast() { takeLast(); } + + virtual void swap(QList &other); + virtual void swap(int i, int j); + + virtual T takeAt(int i); + virtual T takeFirst(); + virtual T takeLast(); + + virtual QList &operator +=(const QList &other) { append(other); return *this; } + virtual QList &operator +=(const T &value) { append(value); return *this; } + virtual QList &operator <<(const QList &other) { append(other); return *this; } + virtual QList &operator <<(const T &value) { append(value); return *this; } + + virtual QList &operator =(const QList &other); + +protected: + // Signal emitted after an item is added to the list. + // Contains a reference to item and the item's new index. + virtual void onItemAdded(const T &item, int index) = 0; + + // Signal emitted after multiple items are added to the list at once. + // The items parameter is a const reference to a QList of the items that + // were added. + // The firstIndex parameter is the new index of the first item added. + virtual void onItemsAdded(const QList &items, int firstIndex) = 0; + + // Signal emitted after an item is removed to the list. + // Contains a reference to the item and the item's old index. + virtual void onItemRemoved(const T &item, int index) = 0; + + // Signal emitted after multiple items are removed from the list at once. + // The items parameter is a const reference to a QList of the items that + // were added. + // The firstIndex parameter is the new index of the first item added. + virtual void onItemsRemoved(const QList &items, int firstIndex) = 0; + + // Signal emitted after an item is moved to another index. + // Contains the item, the old index, and the new index. + virtual void onItemMoved(const T &item, int oldIndex, int newIndex) = 0; + + // Signal emitted after an operation that changes the whole list occurs. + // This signal should be treated as if all data in the entire list was cleared + // and new data added in its place. + virtual void onInvalidated() = 0; +}; + +// Defines the signals for a SigList +#define DEFINE_SIGLIST_SIGNALS(TYPE) \ + Q_SIGNAL void itemAdded(TYPE const &item, int index);\ + Q_SIGNAL void itemsAdded(const QList &items, int firstIndex);\ + Q_SIGNAL void itemRemoved(TYPE const &item, int index);\ + Q_SIGNAL void itemsRemoved(const QList &items, int firstIndex);\ + Q_SIGNAL void itemMoved(TYPE const &item, int oldIndex, int newIndex);\ + Q_SIGNAL void invalidated(); + +// Overrides the onItem* functions and causes them to emit their corresponding +// signals. +#define SETUP_SIGLIST_SIGNALS(TYPE) \ + virtual void onItemAdded(TYPE const &item, int index)\ + { emit itemAdded(item, index); }\ + virtual void onItemsAdded(const QList &items, int firstIndex)\ + { emit itemsAdded(items, firstIndex); }\ + virtual void onItemRemoved(TYPE const &item, int index)\ + { emit itemRemoved(item, index); }\ + virtual void onItemsRemoved(const QList &items, int firstIndex)\ + { emit itemsRemoved(items, firstIndex); }\ + virtual void onItemMoved(TYPE const &item, int oldIndex, int newIndex)\ + { emit itemMoved(item, oldIndex, newIndex); }\ + virtual void onInvalidated() { emit invalidated(); } + +#endif // SIGLIST_H diff --git a/depends/util/include/siglist_impl.h b/depends/util/include/siglist_impl.h new file mode 100644 index 00000000..5cdc632a --- /dev/null +++ b/depends/util/include/siglist_impl.h @@ -0,0 +1,156 @@ +/* Copyright 2013 MultiMC Contributors + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "siglist.h" + +template +void SigList::append(const T &value) +{ + QList::append(value); + onItemAdded(value, QList::length() - 1); +} + +template +void SigList::prepend(const T &value) +{ + QList::prepend(value); + onItemAdded(value, 0); +} + +template +void SigList::append(const QList &other) +{ + int index = QList::length(); + QList::append(other); + onItemsAdded(other, index); +} + +template +void SigList::clear() +{ + QList::clear(); + onInvalidated(); +} + +template +void SigList::erase(typename QList::iterator pos) +{ + T value = *pos; + int index = QList::indexOf(*pos); + QList::erase(pos); + onItemRemoved(value, index); +} + +template +void SigList::erase(typename QList::iterator first, typename QList::iterator last) +{ + QList removedValues; + int firstIndex = QList::indexOf(*first); + + for (auto iter = first; iter < last; iter++) + { + removedValues << *iter; + QList::erase(iter); + } + + onItemsRemoved(removedValues, firstIndex); +} + +template +void SigList::insert(int i, const T &t) +{ + QList::insert(i, t); + onItemAdded(t, i); +} + +template +void SigList::insert(typename QList::iterator before, const T &t) +{ + QList::insert(before, t); + onItemAdded(t, QList::indexOf(t)); +} + +template +void SigList::move(int from, int to) +{ + const T &item = QList::at(from); + QList::move(from, to); + onItemMoved(item, from, to); +} + +template +int SigList::removeAll(const T &t) +{ + int retVal = QList::removeAll(t); + onInvalidated(); + return retVal; +} + +template +bool SigList::removeOne(const T &t) +{ + int index = QList::indexOf(t); + if (QList::removeOne(t)) + { + onItemRemoved(t, index); + return true; + } + return false; +} + +template +void SigList::swap(QList &other) +{ + QList::swap(other); + onInvalidated(); +} + +template +void SigList::swap(int i, int j) +{ + const T &item1 = QList::at(i); + const T &item2 = QList::at(j); + QList::swap(i, j); + onItemMoved(item1, i, j); + onItemMoved(item2, j, i); +} + +template +T SigList::takeAt(int i) +{ + T val = QList::takeAt(i); + onItemRemoved(val, i); + return val; +} + +template +T SigList::takeFirst() +{ + return takeAt(0); +} + +template +T SigList::takeLast() +{ + return takeAt(QList::length() - 1); +} + +template +QList &SigList::operator =(const QList &other) +{ + QList::operator =(other); + onInvalidated(); + return *this; +} diff --git a/depends/util/include/userutils.h b/depends/util/include/userutils.h new file mode 100644 index 00000000..4f2760b1 --- /dev/null +++ b/depends/util/include/userutils.h @@ -0,0 +1,19 @@ +#ifndef USERUTILS_H +#define USERUTILS_H + +#include + +#include "libutil_config.h" + +namespace Util +{ +// Get the Directory representing the User's Desktop +LIBUTIL_EXPORT QString getDesktopDir(); + +// Create a shortcut at *location*, pointing to *dest* called with the arguments *args* +// call it *name* and assign it the icon *icon* +// return true if operation succeeded +LIBUTIL_EXPORT bool createShortCut(QString location, QString dest, QStringList args, QString name, QString iconLocation); +} + +#endif // USERUTILS_H -- cgit v1.2.3