diff options
Diffstat (limited to 'src/qtconcurrent/codegenerator/src/codegenerator.h')
| -rw-r--r-- | src/qtconcurrent/codegenerator/src/codegenerator.h | 204 |
1 files changed, 204 insertions, 0 deletions
diff --git a/src/qtconcurrent/codegenerator/src/codegenerator.h b/src/qtconcurrent/codegenerator/src/codegenerator.h new file mode 100644 index 000000000..1d0fcd994 --- /dev/null +++ b/src/qtconcurrent/codegenerator/src/codegenerator.h @@ -0,0 +1,204 @@ +/**************************************************************************** +** +** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the tools applications of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ +#ifndef CODEGENERATOR_H +#define CODEGENERATOR_H + +#include <QByteArray> +#include <QString> +#include <QList> +#include <QStack> + +namespace CodeGenerator +{ + enum GeneratorType {NoopType, CompoundType, TextType, RepeaterType, CounterType, GroupType}; + class BaseGenerator; + typedef QStack<BaseGenerator *> GeneratorStack; + + template <typename ValueType> + class Stacker { + public: + Stacker(QStack<ValueType> *stack, ValueType value) : stack(stack) { stack->push(value); } + ~Stacker() { stack->pop();} + private: + QStack<ValueType> *stack; + }; + typedef Stacker<BaseGenerator *> GeneratorStacker; + + class BaseGenerator + { + public: + BaseGenerator(GeneratorType type = NoopType) : type(type) {} + virtual ~BaseGenerator() {}; + virtual QByteArray generate(GeneratorStack *stack) { Q_UNUSED(stack); return QByteArray(); }; + int currentCount(GeneratorStack *stack) const; + int repeatCount(GeneratorStack *stack) const; + GeneratorType type; + }; + + class Item + { + public: + Item(BaseGenerator * const base) : generator(base) {} + Item(const char * const text); + QByteArray generate() const + { GeneratorStack stack; return generator->generate(&stack); } + // ### TODO: Fix memory leak! + // QExplicitlySharedDataPointer<BaseGenerator> generator; + BaseGenerator * const generator; + }; + + class CompoundGenerator : public BaseGenerator + { + public: + CompoundGenerator(BaseGenerator * const a, BaseGenerator * const b) + : BaseGenerator(CompoundType), a(a), b(b) {} + virtual QByteArray generate(GeneratorStack *stack) + { return a->generate(stack) + b->generate(stack); }; + protected: + BaseGenerator * const a; + BaseGenerator * const b; + }; + + class Compound : public Item + { + public: + Compound(const Item &a, const Item &b) : Item(new CompoundGenerator(a.generator, b.generator)) {} + }; + + class TextGenerator : public BaseGenerator + { + public: + TextGenerator(const QByteArray &text) : BaseGenerator(TextType), text(text) {} + virtual QByteArray generate(GeneratorStack *) { return text; }; + protected: + QByteArray text; + }; + + class Text : public Item { + public: + Text(const QByteArray &text) : Item(new TextGenerator(text)) {} + Text(const char * const text) : Item(new TextGenerator(QByteArray(text))) {} + }; + + class RepeaterGenerator : public BaseGenerator + { + public: + RepeaterGenerator(BaseGenerator * const childGenerator) + : BaseGenerator(RepeaterType), repeatCount(1), repeatOffset(0), childGenerator(childGenerator) {} + virtual QByteArray generate(GeneratorStack *stack); + + int repeatCount; + int repeatOffset; + int currentRepeat; + BaseGenerator * const childGenerator; + }; + + class Repeater : public Item { + public: + Repeater(const Item &item) : Item(new RepeaterGenerator(item.generator)) {} + void setRepeatCount(int count) + { static_cast<RepeaterGenerator * const>(generator)->repeatCount = count; } + void setRepeatOffset(int offset) + { static_cast<RepeaterGenerator * const>(generator)->repeatOffset = offset; } + }; + + class CounterGenerator : public BaseGenerator + { + public: + CounterGenerator() : BaseGenerator(CounterType), offset(0), increment(1), reverse(false) {} + QByteArray generate(GeneratorStack *stack) + { + if (reverse) + return QByteArray::number(repeatCount(stack) - (currentCount(stack) * increment) + offset + 1); + else + return QByteArray::number((currentCount(stack) * increment) + offset); + } + int offset; + int increment; + bool reverse; + }; + + class Counter : public Item { + public: + Counter() : Item(new CounterGenerator()) {} + Counter(int offset) : Item(new CounterGenerator()) { setOffset(offset); } + void setOffset(int offset) + { static_cast<CounterGenerator *>(generator)->offset = offset; } + void setIncrement(int increment) + { static_cast<CounterGenerator *>(generator)->increment = increment; } + void setReverse(bool reverse) + { static_cast<CounterGenerator *>(generator)->reverse = reverse; } + + }; + + class GroupGenerator : public BaseGenerator + { + public: + GroupGenerator(BaseGenerator * const childGenerator) + : BaseGenerator(GroupType), currentRepeat(0), childGenerator(childGenerator), + separator(new BaseGenerator()), prefix(new BaseGenerator()), postfix(new BaseGenerator()) { } + virtual QByteArray generate(GeneratorStack *stack); + int currentRepeat; + BaseGenerator * const childGenerator; + BaseGenerator *separator; + BaseGenerator *prefix; + BaseGenerator *postfix; + }; + + class Group : public Item + { + public: + Group(const Item &item) : Item(new GroupGenerator(item.generator)) { setSeparator(", "); } + void setSeparator(const Item &separator) + { static_cast<GroupGenerator *>(generator)->separator = separator.generator; } + void setPrefix(const Item &prefix) + { static_cast<GroupGenerator *>(generator)->prefix = prefix.generator; } + void setPostfix(const Item &postfix) + { static_cast<GroupGenerator *>(generator)->postfix = postfix.generator; } + }; + + const Compound operator+(const Item &a, const Item &b); + const Compound operator+(const Item &a, const char * const text); + const Compound operator+(const char * const text, const Item &b); + +} //namespace CodeGenerator + +#endif |