source: wkhtmltox/trunk/fuentes/src/lib/reflect.hh @ 51

Last change on this file since 51 was 51, checked in by mabarracus, 4 years ago

wip

File size: 6.4 KB
Line 
1// -*- mode: c++; tab-width: 4; indent-tabs-mode: t; eval: (progn (c-set-style "stroustrup") (c-set-offset 'innamespace 0)); -*-
2// vi:set ts=4 sts=4 sw=4 noet :
3//
4// Copyright 2010, 2011 wkhtmltopdf authors
5//
6// This file is part of wkhtmltopdf.
7//
8// wkhtmltopdf is free software: you can redistribute it and/or modify
9// it under the terms of the GNU Lesser General Public License as published by
10// the Free Software Foundation, either version 3 of the License, or
11// (at your option) any later version.
12//
13// wkhtmltopdf is distributed in the hope that it will be useful,
14// but WITHOUT ANY WARRANTY; without even the implied warranty of
15// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16// GNU General Public License for more details.
17//
18// You should have received a copy of the GNU Lesser General Public License
19// along with wkhtmltopdf.  If not, see <http://www.gnu.org/licenses/>.
20
21#ifndef __REFLECT_HH__
22#define __REFLECT_HH__
23
24#if defined(_MSC_VER) && _MSC_VER>=1600
25#define typeof decltype
26#endif
27
28#include "loadsettings.hh"
29#include "websettings.hh"
30#include <QStringList>
31#include <cstring>
32
33#include "dllbegin.inc"
34namespace wkhtmltopdf {
35namespace settings {
36
37#define WKHTMLTOPDF_REFLECT(name) ReflectClass::add(#name, new ReflectImpl<typeof(c.name)> (c.name));
38
39class DLL_LOCAL Reflect {
40public:
41        virtual QString get(const char * name) = 0;
42        virtual bool set(const char * name, const QString & value) = 0;
43        virtual ~Reflect() {};
44};
45
46class DLL_LOCAL ReflectSimple: public Reflect {
47public:
48        virtual QString get() = 0;
49        virtual void set(const QString & value, bool * ok) = 0;
50
51        virtual QString get(const char * name) {return name[0]=='\0'?get():QString();}
52        virtual bool set(const char * name, const QString & value);
53};
54
55class DLL_LOCAL ReflectClass: public Reflect {
56public:
57        QMap<QString, Reflect *> elms;
58        void add(const char * name, Reflect * r) {elms[name] = r;}
59        QString get(const char * name);
60        bool set(const char * name, const QString & value);
61        ~ReflectClass();
62};
63
64template <typename X>
65class DLL_LOCAL ReflectImpl {
66private:
67        ReflectImpl();
68};
69
70template<>
71struct DLL_LOCAL ReflectImpl<bool>: public ReflectSimple {
72        bool & b;
73        ReflectImpl(bool & _): b(_) {}
74        QString get() {return b?"true":"false";}
75        void set(const QString & value, bool * ok) {
76                if (value == "true") b=true;
77                else if (value == "false") b=false;
78                else *ok=false;
79                *ok=true;
80        }
81};
82
83template<>
84struct DLL_LOCAL ReflectImpl<QString>: public ReflectSimple {
85        QString & s;
86        ReflectImpl(QString & _): s(_) {}
87        QString get() {return s;}
88        void set(const QString & value, bool * ok) {s=value; *ok=true;}
89};
90
91template<>
92struct DLL_LOCAL ReflectImpl<int>: public ReflectSimple {
93        int & i;
94        ReflectImpl(int & _): i(_) {}
95        QString get() {return QString::number(i);}
96        void set(const QString & value, bool * ok) {i = value.toInt(ok);}
97};
98
99template<>
100struct DLL_LOCAL ReflectImpl<float>: public ReflectSimple {
101        float & f;
102        ReflectImpl(float & _): f(_) {}
103        QString get() {return QString::number(f);}
104        void set(const QString & value, bool * ok) {f = value.toDouble(ok);}
105};
106
107template<>
108struct DLL_LOCAL ReflectImpl< QPair<QString, QString> >: public ReflectSimple {
109        QPair<QString, QString> & p;
110        ReflectImpl(QPair<QString, QString> & _): p(_) {};
111
112        QString get() {
113                return p.first + "\n" + p.second;
114        }
115
116        void set(const QString & value, bool * ok) {
117                QStringList l = value.split("\n");
118                if (l.size() != 2) {*ok=false; return;}
119                *ok      = true;
120                p.first  = l[0];
121                p.second = l[1];
122        }
123};
124
125template<typename X>
126struct DLL_LOCAL ReflectImpl< QList< X> >: public Reflect {
127        QList<X> & l;
128
129        ReflectImpl(QList<X> & _): l(_) {}
130
131        bool parse(const char * name, int & parmsize, int & next, int & elm) {
132                elm=-1;
133                parmsize = -1;
134                if (name[0] == '[') {
135                        next = 0;
136                        while (name[next] != '\0' && name[next] != ']') ++next;
137                        bool ok=true;
138                        elm = QString::fromLocal8Bit(name+1,next-1).toInt(&ok);
139                        while (name[next] == ']' || name[next] == '.') ++next;
140                        return ok;
141                }
142                parmsize = 0;
143                while (name[parmsize] != '\0' && name[parmsize] != '.' && name[parmsize] != '[') ++parmsize;
144                next = parmsize;
145                if (name[next] == '.') ++next;
146                return true;
147        }
148
149        virtual QString get(const char * name) {
150                int ps, next, elm;
151                if (!strcmp(name,"size") || !strcmp(name,"length") || !strcmp(name,"count")) return QString::number(l.size());
152                if (!parse(name, ps, next, elm)) return QString();
153                if (ps > 0 && !l.isEmpty() && !strncmp(name, "first", ps)) elm = 0;
154                if (ps > 0 && !l.isEmpty() && !strncmp(name, "last",  ps)) elm = l.size() - 1;
155                if (elm < 0 || elm >= l.size()) return QString();
156                ReflectImpl<X> impl(l[elm]);
157                return static_cast<Reflect*>(&impl)->get(name+next);
158        };
159
160        virtual bool set(const char * name, const QString & value) {
161                int ps, next, elm;
162                if (!strcmp(name,"clear"))
163                        l.clear();
164                else if (!strcmp(name,"append"))
165                        l.append(X());
166                else if (!strcmp(name,"prepend"))
167                        l.prepend(X());
168                else if (!strcmp(name,"delete")) {
169                        bool ok = true;
170                        int idx = value.toInt(&ok);
171                        if (ok && idx >= 0 && idx < l.size()) {
172                                l.removeAt(idx);
173                                return true;
174                        }
175                        return false;
176                }
177                else {
178                        if (!parse(name, ps, next, elm)) return false;
179                        if (ps > 0 && !l.isEmpty() && !strncmp(name, "first", ps)) elm = 0;
180                        if (ps > 0 && !l.isEmpty() && !strncmp(name, "last",  ps)) elm = l.size() - 1;
181                        ReflectImpl<X> impl(l[elm]);
182                        return static_cast<Reflect *>(&impl)->set(name+next, value);
183                }
184                return true;
185        }
186};
187
188
189template<>
190struct DLL_LOCAL ReflectImpl<LoadPage::LoadErrorHandling>: public ReflectSimple {
191        LoadPage::LoadErrorHandling & l;
192        ReflectImpl(LoadPage::LoadErrorHandling & _): l(_) {}
193        QString get() {return loadErrorHandlingToStr(l);}
194        void set(const QString & value, bool * ok) {l = strToLoadErrorHandling(value.toUtf8().constData(), ok);}
195};
196
197
198template<>
199struct DLL_LOCAL ReflectImpl<Proxy>: public ReflectSimple {
200        Proxy & p;
201        ReflectImpl(Proxy & _): p(_) {}
202        QString get() {return proxyToStr(p);}
203        void set(const QString & value, bool * ok) {p = strToProxy(value.toUtf8().constData(), ok);}
204};
205
206template<>
207struct DLL_LOCAL ReflectImpl<PostItem>: public ReflectClass {
208        ReflectImpl(PostItem & c) {
209                WKHTMLTOPDF_REFLECT(name);
210                WKHTMLTOPDF_REFLECT(value);
211                WKHTMLTOPDF_REFLECT(file);
212        }
213};
214
215template <>
216struct DLL_LOCAL ReflectImpl<LoadGlobal>: public ReflectClass {
217        ReflectImpl(LoadGlobal & c);
218};
219
220
221template <>
222struct DLL_LOCAL ReflectImpl<LoadPage>: public ReflectClass {
223        ReflectImpl(LoadPage & c);
224};
225
226template <>
227struct DLL_LOCAL ReflectImpl<Web>: public ReflectClass {
228        ReflectImpl(Web & c);
229};
230
231}
232}
233#include "dllend.inc"
234#endif //__REFLECT_HH__
Note: See TracBrowser for help on using the repository browser.