Peter M. Groen / dali-demo

Commit 4f2d9d01598786b08a6f50d86e140d23951be2e0

Authored by Adeel Kazmi
1 parent 2d059e9a

Removed duplicated code by creating third-party folder 

Change-Id: If45b62cd020858588491a4701fb834675caf8f2a
Inline Side-by-side
Showing 5 changed files with 11 additions and 1438 deletions
examples/fpp-game/game-scene.cpp
  View file @4f2d9d0
... ... @@ -25,7 +25,7 @@
25 25 #include "game-scene.h"
26 26 #include "game-texture.h"
27 27  
28   -#include "third-party/picojson.h"
  28 +#include "third-party/pico-json.h"
29 29  
30 30 #include <dali/dali.h>
31 31  
... ...
examples/fpp-game/third-party/picojson.h deleted
View file @2d059e9
1   -/*
2   - * Copyright 2009-2010 Cybozu Labs, Inc.
3   - * Copyright 2011-2014 Kazuho Oku
4   - * All rights reserved.
5   - *
6   - * Redistribution and use in source and binary forms, with or without
7   - * modification, are permitted provided that the following conditions are met:
8   - *
9   - * 1. Redistributions of source code must retain the above copyright notice,
10   - * this list of conditions and the following disclaimer.
11   - *
12   - * 2. Redistributions in binary form must reproduce the above copyright notice,
13   - * this list of conditions and the following disclaimer in the documentation
14   - * and/or other materials provided with the distribution.
15   - *
16   - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17   - * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18   - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19   - * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20   - * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21   - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22   - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23   - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24   - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25   - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26   - * POSSIBILITY OF SUCH DAMAGE.
27   - */
28   -#ifndef picojson_h
29   -#define picojson_h
30   -
31   -#include <algorithm>
32   -#include <cstddef>
33   -#include <cstdio>
34   -#include <cstdlib>
35   -#include <cstring>
36   -#include <iostream>
37   -#include <iterator>
38   -#include <limits>
39   -#include <map>
40   -#include <stdexcept>
41   -#include <string>
42   -#include <utility>
43   -#include <vector>
44   -
45   -// for isnan/isinf
46   -#if __cplusplus >= 201103L
47   -#include <cmath>
48   -#else
49   -extern "C"
50   -{
51   -#ifdef _MSC_VER
52   -#include <float.h>
53   -#elif defined(__INTEL_COMPILER)
54   -#include <mathimf.h>
55   -#else
56   -#include <math.h>
57   -#endif
58   -}
59   -#endif
60   -
61   -#ifndef PICOJSON_USE_RVALUE_REFERENCE
62   -#if(defined(__cpp_rvalue_references) && __cpp_rvalue_references >= 200610) || (defined(_MSC_VER) && _MSC_VER >= 1600)
63   -#define PICOJSON_USE_RVALUE_REFERENCE 1
64   -#else
65   -#define PICOJSON_USE_RVALUE_REFERENCE 0
66   -#endif
67   -#endif //PICOJSON_USE_RVALUE_REFERENCE
68   -
69   -// experimental support for int64_t (see README.mkdn for detail)
70   -#ifdef PICOJSON_USE_INT64
71   -#define __STDC_FORMAT_MACROS
72   -#include <errno.h>
73   -#include <inttypes.h>
74   -#endif
75   -
76   -// to disable the use of localeconv(3), set PICOJSON_USE_LOCALE to 0
77   -#ifndef PICOJSON_USE_LOCALE
78   -#define PICOJSON_USE_LOCALE 1
79   -#endif
80   -#if PICOJSON_USE_LOCALE
81   -extern "C"
82   -{
83   -#include <locale.h>
84   -}
85   -#endif
86   -
87   -#ifndef PICOJSON_ASSERT
88   -#define PICOJSON_ASSERT(e) \
89   - do \
90   - { \
91   - if(!(e)) throw std::runtime_error(#e); \
92   - } while(0)
93   -#endif
94   -
95   -#ifdef _MSC_VER
96   -#define SNPRINTF _snprintf_s
97   -#pragma warning(push)
98   -#pragma warning(disable : 4244) // conversion from int to char
99   -#pragma warning(disable : 4127) // conditional expression is constant
100   -#pragma warning(disable : 4702) // unreachable code
101   -#else
102   -#define SNPRINTF snprintf
103   -#endif
104   -
105   -namespace picojson
106   -{
107   -enum
108   -{
109   - null_type,
110   - boolean_type,
111   - number_type,
112   - string_type,
113   - array_type,
114   - object_type
115   -#ifdef PICOJSON_USE_INT64
116   - ,
117   - int64_type
118   -#endif
119   -};
120   -
121   -enum
122   -{
123   - INDENT_WIDTH = 2
124   -};
125   -
126   -struct null
127   -{
128   -};
129   -
130   -class value
131   -{
132   -public:
133   - typedef std::vector<value> array;
134   - typedef std::map<std::string, value> object;
135   - union _storage
136   - {
137   - bool boolean_;
138   - double number_;
139   -#ifdef PICOJSON_USE_INT64
140   - int64_t int64_;
141   -#endif
142   - std::string* string_;
143   - array* array_;
144   - object* object_;
145   - };
146   -
147   -protected:
148   - int type_;
149   - _storage u_;
150   -
151   -public:
152   - value();
153   - value(int type, bool);
154   - explicit value(bool b);
155   -#ifdef PICOJSON_USE_INT64
156   - explicit value(int64_t i);
157   -#endif
158   - explicit value(double n);
159   - explicit value(const std::string& s);
160   - explicit value(const array& a);
161   - explicit value(const object& o);
162   - explicit value(const char* s);
163   - value(const char* s, size_t len);
164   - ~value();
165   - value(const value& x);
166   - value& operator=(const value& x);
167   -#if PICOJSON_USE_RVALUE_REFERENCE
168   - value(value&& x) throw();
169   - value& operator=(value&& x) throw();
170   -#endif
171   - void swap(value& x) throw();
172   - template<typename T>
173   - bool is() const;
174   - template<typename T>
175   - const T& get() const;
176   - template<typename T>
177   - T& get();
178   - template<typename T>
179   - void set(const T&);
180   -#if PICOJSON_USE_RVALUE_REFERENCE
181   - template<typename T>
182   - void set(T&&);
183   -#endif
184   - bool evaluate_as_boolean() const;
185   - const value& get(size_t idx) const;
186   - const value& get(const std::string& key) const;
187   - value& get(size_t idx);
188   - value& get(const std::string& key);
189   -
190   - bool contains(size_t idx) const;
191   - bool contains(const std::string& key) const;
192   - std::string to_str() const;
193   - template<typename Iter>
194   - void serialize(Iter os, bool prettify = false) const;
195   - std::string serialize(bool prettify = false) const;
196   -
197   -private:
198   - template<typename T>
199   - value(const T*); // intentionally defined to block implicit conversion of pointer to bool
200   - template<typename Iter>
201   - static void _indent(Iter os, int indent);
202   - template<typename Iter>
203   - void _serialize(Iter os, int indent) const;
204   - std::string _serialize(int indent) const;
205   - void clear();
206   -};
207   -
208   -typedef value::array array;
209   -typedef value::object object;
210   -
211   -inline value::value()
212   -: type_(null_type)
213   -{
214   -}
215   -
216   -inline value::value(int type, bool)
217   -: type_(type)
218   -{
219   - switch(type)
220   - {
221   -#define INIT(p, v) \
222   - case p##type: \
223   - u_.p = v; \
224   - break
225   - INIT(boolean_, false);
226   - INIT(number_, 0.0);
227   -#ifdef PICOJSON_USE_INT64
228   - INIT(int64_, 0);
229   -#endif
230   - INIT(string_, new std::string());
231   - INIT(array_, new array());
232   - INIT(object_, new object());
233   -#undef INIT
234   - default:
235   - break;
236   - }
237   -}
238   -
239   -inline value::value(bool b)
240   -: type_(boolean_type)
241   -{
242   - u_.boolean_ = b;
243   -}
244   -
245   -#ifdef PICOJSON_USE_INT64
246   -inline value::value(int64_t i)
247   -: type_(int64_type)
248   -{
249   - u_.int64_ = i;
250   -}
251   -#endif
252   -
253   -inline value::value(double n)
254   -: type_(number_type)
255   -{
256   - if(
257   -#ifdef _MSC_VER
258   - !_finite(n)
259   -#elif __cplusplus >= 201103L || !(defined(isnan) && defined(isinf))
260   - std::isnan(n) || std::isinf(n)
261   -#else
262   - isnan(n) || isinf(n)
263   -#endif
264   - )
265   - {
266   - throw std::overflow_error("");
267   - }
268   - u_.number_ = n;
269   -}
270   -
271   -inline value::value(const std::string& s)
272   -: type_(string_type)
273   -{
274   - u_.string_ = new std::string(s);
275   -}
276   -
277   -inline value::value(const array& a)
278   -: type_(array_type)
279   -{
280   - u_.array_ = new array(a);
281   -}
282   -
283   -inline value::value(const object& o)
284   -: type_(object_type)
285   -{
286   - u_.object_ = new object(o);
287   -}
288   -
289   -inline value::value(const char* s)
290   -: type_(string_type)
291   -{
292   - u_.string_ = new std::string(s);
293   -}
294   -
295   -inline value::value(const char* s, size_t len)
296   -: type_(string_type)
297   -{
298   - u_.string_ = new std::string(s, len);
299   -}
300   -
301   -inline void value::clear()
302   -{
303   - switch(type_)
304   - {
305   -#define DEINIT(p) \
306   - case p##type: \
307   - delete u_.p; \
308   - break
309   - DEINIT(string_);
310   - DEINIT(array_);
311   - DEINIT(object_);
312   -#undef DEINIT
313   - default:
314   - break;
315   - }
316   -}
317   -
318   -inline value::~value()
319   -{
320   - clear();
321   -}
322   -
323   -inline value::value(const value& x)
324   -: type_(x.type_)
325   -{
326   - switch(type_)
327   - {
328   -#define INIT(p, v) \
329   - case p##type: \
330   - u_.p = v; \
331   - break
332   - INIT(string_, new std::string(*x.u_.string_));
333   - INIT(array_, new array(*x.u_.array_));
334   - INIT(object_, new object(*x.u_.object_));
335   -#undef INIT
336   - default:
337   - u_ = x.u_;
338   - break;
339   - }
340   -}
341   -
342   -inline value& value::operator=(const value& x)
343   -{
344   - if(this != &x)
345   - {
346   - value t(x);
347   - swap(t);
348   - }
349   - return *this;
350   -}
351   -
352   -#if PICOJSON_USE_RVALUE_REFERENCE
353   -inline value::value(value&& x) throw()
354   -: type_(null_type)
355   -{
356   - swap(x);
357   -}
358   -inline value& value::operator=(value&& x) throw()
359   -{
360   - swap(x);
361   - return *this;
362   -}
363   -#endif
364   -inline void value::swap(value& x) throw()
365   -{
366   - std::swap(type_, x.type_);
367   - std::swap(u_, x.u_);
368   -}
369   -
370   -#define IS(ctype, jtype) \
371   - template<> \
372   - inline bool value::is<ctype>() const \
373   - { \
374   - return type_ == jtype##_type; \
375   - }
376   -IS(null, null)
377   -IS(bool, boolean)
378   -#ifdef PICOJSON_USE_INT64
379   -IS(int64_t, int64)
380   -#endif
381   -IS(std::string, string)
382   -IS(array, array)
383   -IS(object, object)
384   -#undef IS
385   -template<>
386   -inline bool value::is<double>() const
387   -{
388   - return type_ == number_type
389   -#ifdef PICOJSON_USE_INT64
390   - || type_ == int64_type
391   -#endif
392   - ;
393   -}
394   -
395   -#define GET(ctype, var) \
396   - template<> \
397   - inline const ctype& value::get<ctype>() const \
398   - { \
399   - PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()" && is<ctype>()); \
400   - return var; \
401   - } \
402   - template<> \
403   - inline ctype& value::get<ctype>() \
404   - { \
405   - PICOJSON_ASSERT("type mismatch! call is<type>() before get<type>()" && is<ctype>()); \
406   - return var; \
407   - }
408   -GET(bool, u_.boolean_)
409   -GET(std::string, *u_.string_)
410   -GET(array, *u_.array_)
411   -GET(object, *u_.object_)
412   -#ifdef PICOJSON_USE_INT64
413   -GET(double, (type_ == int64_type && (const_cast<value*>(this)->type_ = number_type, const_cast<value*>(this)->u_.number_ = u_.int64_), u_.number_))
414   -GET(int64_t, u_.int64_)
415   -#else
416   -GET(double, u_.number_)
417   -#endif
418   -#undef GET
419   -
420   -#define SET(ctype, jtype, setter) \
421   - template<> \
422   - inline void value::set<ctype>(const ctype& _val) \
423   - { \
424   - clear(); \
425   - type_ = jtype##_type; \
426   - setter \
427   - }
428   -SET(bool, boolean, u_.boolean_ = _val;)
429   -SET(std::string, string, u_.string_ = new std::string(_val);)
430   -SET(array, array, u_.array_ = new array(_val);)
431   -SET(object, object, u_.object_ = new object(_val);)
432   -SET(double, number, u_.number_ = _val;)
433   -#ifdef PICOJSON_USE_INT64
434   -SET(int64_t, int64, u_.int64_ = _val;)
435   -#endif
436   -#undef SET
437   -
438   -#if PICOJSON_USE_RVALUE_REFERENCE
439   -#define MOVESET(ctype, jtype, setter) \
440   - template<> \
441   - inline void value::set<ctype>(ctype && _val) \
442   - { \
443   - clear(); \
444   - type_ = jtype##_type; \
445   - setter \
446   - }
447   -MOVESET(std::string, string, u_.string_ = new std::string(std::move(_val));)
448   -MOVESET(array, array, u_.array_ = new array(std::move(_val));)
449   -MOVESET(object, object, u_.object_ = new object(std::move(_val));)
450   -#undef MOVESET
451   -#endif
452   -
453   -inline bool value::evaluate_as_boolean() const
454   -{
455   - switch(type_)
456   - {
457   - case null_type:
458   - return false;
459   - case boolean_type:
460   - return u_.boolean_;
461   - case number_type:
462   - return u_.number_ != 0;
463   -#ifdef PICOJSON_USE_INT64
464   - case int64_type:
465   - return u_.int64_ != 0;
466   -#endif
467   - case string_type:
468   - return !u_.string_->empty();
469   - default:
470   - return true;
471   - }
472   -}
473   -
474   -inline const value& value::get(size_t idx) const
475   -{
476   - static value s_null;
477   - PICOJSON_ASSERT(is<array>());
478   - return idx < u_.array_->size() ? (*u_.array_)[idx] : s_null;
479   -}
480   -
481   -inline value& value::get(size_t idx)
482   -{
483   - static value s_null;
484   - PICOJSON_ASSERT(is<array>());
485   - return idx < u_.array_->size() ? (*u_.array_)[idx] : s_null;
486   -}
487   -
488   -inline const value& value::get(const std::string& key) const
489   -{
490   - static value s_null;
491   - PICOJSON_ASSERT(is<object>());
492   - object::const_iterator i = u_.object_->find(key);
493   - return i != u_.object_->end() ? i->second : s_null;
494   -}
495   -
496   -inline value& value::get(const std::string& key)
497   -{
498   - static value s_null;
499   - PICOJSON_ASSERT(is<object>());
500   - object::iterator i = u_.object_->find(key);
501   - return i != u_.object_->end() ? i->second : s_null;
502   -}
503   -
504   -inline bool value::contains(size_t idx) const
505   -{
506   - PICOJSON_ASSERT(is<array>());
507   - return idx < u_.array_->size();
508   -}
509   -
510   -inline bool value::contains(const std::string& key) const
511   -{
512   - PICOJSON_ASSERT(is<object>());
513   - object::const_iterator i = u_.object_->find(key);
514   - return i != u_.object_->end();
515   -}
516   -
517   -inline std::string value::to_str() const
518   -{
519   - switch(type_)
520   - {
521   - case null_type:
522   - return "null";
523   - case boolean_type:
524   - return u_.boolean_ ? "true" : "false";
525   -#ifdef PICOJSON_USE_INT64
526   - case int64_type:
527   - {
528   - char buf[sizeof("-9223372036854775808")];
529   - SNPRINTF(buf, sizeof(buf), "%" PRId64, u_.int64_);
530   - return buf;
531   - }
532   -#endif
533   - case number_type:
534   - {
535   - char buf[256];
536   - double tmp;
537   - SNPRINTF(buf, sizeof(buf), fabs(u_.number_) < (1ULL << 53) && modf(u_.number_, &tmp) == 0 ? "%.f" : "%.17g", u_.number_);
538   -#if PICOJSON_USE_LOCALE
539   - char* decimal_point = localeconv()->decimal_point;
540   - if(strcmp(decimal_point, ".") != 0)
541   - {
542   - size_t decimal_point_len = strlen(decimal_point);
543   - for(char* p = buf; *p != '\0'; ++p)
544   - {
545   - if(strncmp(p, decimal_point, decimal_point_len) == 0)
546   - {
547   - return std::string(buf, p) + "." + (p + decimal_point_len);
548   - }
549   - }
550   - }
551   -#endif
552   - return buf;
553   - }
554   - case string_type:
555   - return *u_.string_;
556   - case array_type:
557   - return "array";
558   - case object_type:
559   - return "object";
560   - default:
561   - PICOJSON_ASSERT(0);
562   -#ifdef _MSC_VER
563   - __assume(0);
564   -#endif
565   - }
566   - return std::string();
567   -}
568   -
569   -template<typename Iter>
570   -void copy(const std::string& s, Iter oi)
571   -{
572   - std::copy(s.begin(), s.end(), oi);
573   -}
574   -
575   -template<typename Iter>
576   -struct serialize_str_char
577   -{
578   - Iter oi;
579   - void operator()(char c)
580   - {
581   - switch(c)
582   - {
583   -#define MAP(val, sym) \
584   - case val: \
585   - copy(sym, oi); \
586   - break
587   - MAP('"', "\\\"");
588   - MAP('\\', "\\\\");
589   - MAP('/', "\\/");
590   - MAP('\b', "\\b");
591   - MAP('\f', "\\f");
592   - MAP('\n', "\\n");
593   - MAP('\r', "\\r");
594   - MAP('\t', "\\t");
595   -#undef MAP
596   - default:
597   - if(static_cast<unsigned char>(c) < 0x20 || c == 0x7f)
598   - {
599   - char buf[7];
600   - SNPRINTF(buf, sizeof(buf), "\\u%04x", c & 0xff);
601   - copy(buf, buf + 6, oi);
602   - }
603   - else
604   - {
605   - *oi++ = c;
606   - }
607   - break;
608   - }
609   - }
610   -};
611   -
612   -template<typename Iter>
613   -void serialize_str(const std::string& s, Iter oi)
614   -{
615   - *oi++ = '"';
616   - serialize_str_char<Iter> process_char = {oi};
617   - std::for_each(s.begin(), s.end(), process_char);
618   - *oi++ = '"';
619   -}
620   -
621   -template<typename Iter>
622   -void value::serialize(Iter oi, bool prettify) const
623   -{
624   - return _serialize(oi, prettify ? 0 : -1);
625   -}
626   -
627   -inline std::string value::serialize(bool prettify) const
628   -{
629   - return _serialize(prettify ? 0 : -1);
630   -}
631   -
632   -template<typename Iter>
633   -void value::_indent(Iter oi, int indent)
634   -{
635   - *oi++ = '\n';
636   - for(int i = 0; i < indent * INDENT_WIDTH; ++i)
637   - {
638   - *oi++ = ' ';
639   - }
640   -}
641   -
642   -template<typename Iter>
643   -void value::_serialize(Iter oi, int indent) const
644   -{
645   - switch(type_)
646   - {
647   - case string_type:
648   - serialize_str(*u_.string_, oi);
649   - break;
650   - case array_type:
651   - {
652   - *oi++ = '[';
653   - if(indent != -1)
654   - {
655   - ++indent;
656   - }
657   - for(array::const_iterator i = u_.array_->begin();
658   - i != u_.array_->end();
659   - ++i)
660   - {
661   - if(i != u_.array_->begin())
662   - {
663   - *oi++ = ',';
664   - }
665   - if(indent != -1)
666   - {
667   - _indent(oi, indent);
668   - }
669   - i->_serialize(oi, indent);
670   - }
671   - if(indent != -1)
672   - {
673   - --indent;
674   - if(!u_.array_->empty())
675   - {
676   - _indent(oi, indent);
677   - }
678   - }
679   - *oi++ = ']';
680   - break;
681   - }
682   - case object_type:
683   - {
684   - *oi++ = '{';
685   - if(indent != -1)
686   - {
687   - ++indent;
688   - }
689   - for(object::const_iterator i = u_.object_->begin();
690   - i != u_.object_->end();
691   - ++i)
692   - {
693   - if(i != u_.object_->begin())
694   - {
695   - *oi++ = ',';
696   - }
697   - if(indent != -1)
698   - {
699   - _indent(oi, indent);
700   - }
701   - serialize_str(i->first, oi);
702   - *oi++ = ':';
703   - if(indent != -1)
704   - {
705   - *oi++ = ' ';
706   - }
707   - i->second._serialize(oi, indent);
708   - }
709   - if(indent != -1)
710   - {
711   - --indent;
712   - if(!u_.object_->empty())
713   - {
714   - _indent(oi, indent);
715   - }
716   - }
717   - *oi++ = '}';
718   - break;
719   - }
720   - default:
721   - copy(to_str(), oi);
722   - break;
723   - }
724   - if(indent == 0)
725   - {
726   - *oi++ = '\n';
727   - }
728   -}
729   -
730   -inline std::string value::_serialize(int indent) const
731   -{
732   - std::string s;
733   - _serialize(std::back_inserter(s), indent);
734   - return s;
735   -}
736   -
737   -template<typename Iter>
738   -class input
739   -{
740   -protected:
741   - Iter cur_, end_;
742   - bool consumed_;
743   - int line_;
744   -
745   -public:
746   - input(const Iter& first, const Iter& last)
747   - : cur_(first),
748   - end_(last),
749   - consumed_(false),
750   - line_(1)
751   - {
752   - }
753   - int getc()
754   - {
755   - if(consumed_)
756   - {
757   - if(*cur_ == '\n')
758   - {
759   - ++line_;
760   - }
761   - ++cur_;
762   - }
763   - if(cur_ == end_)
764   - {
765   - consumed_ = false;
766   - return -1;
767   - }
768   - consumed_ = true;
769   - return *cur_ & 0xff;
770   - }
771   - void ungetc()
772   - {
773   - consumed_ = false;
774   - }
775   - Iter cur() const
776   - {
777   - if(consumed_)
778   - {
779   - input<Iter>* self = const_cast<input<Iter>*>(this);
780   - self->consumed_ = false;
781   - ++self->cur_;
782   - }
783   - return cur_;
784   - }
785   - int line() const
786   - {
787   - return line_;
788   - }
789   - void skip_ws()
790   - {
791   - while(1)
792   - {
793   - int ch = getc();
794   - if(!(ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'))
795   - {
796   - ungetc();
797   - break;
798   - }
799   - }
800   - }
801   - bool expect(int expect)
802   - {
803   - skip_ws();
804   - if(getc() != expect)
805   - {
806   - ungetc();
807   - return false;
808   - }
809   - return true;
810   - }
811   - bool match(const std::string& pattern)
812   - {
813   - for(std::string::const_iterator pi(pattern.begin());
814   - pi != pattern.end();
815   - ++pi)
816   - {
817   - if(getc() != *pi)
818   - {
819   - ungetc();
820   - return false;
821   - }
822   - }
823   - return true;
824   - }
825   -};
826   -
827   -template<typename Iter>
828   -inline int _parse_quadhex(input<Iter>& in)
829   -{
830   - int uni_ch = 0, hex;
831   - for(int i = 0; i < 4; i++)
832   - {
833   - if((hex = in.getc()) == -1)
834   - {
835   - return -1;
836   - }
837   - if('0' <= hex && hex <= '9')
838   - {
839   - hex -= '0';
840   - }
841   - else if('A' <= hex && hex <= 'F')
842   - {
843   - hex -= 'A' - 0xa;
844   - }
845   - else if('a' <= hex && hex <= 'f')
846   - {
847   - hex -= 'a' - 0xa;
848   - }
849   - else
850   - {
851   - in.ungetc();
852   - return -1;
853   - }
854   - uni_ch = uni_ch * 16 + hex;
855   - }
856   - return uni_ch;
857   -}
858   -
859   -template<typename String, typename Iter>
860   -inline bool _parse_codepoint(String& out, input<Iter>& in)
861   -{
862   - int uni_ch;
863   - if((uni_ch = _parse_quadhex(in)) == -1)
864   - {
865   - return false;
866   - }
867   - if(0xd800 <= uni_ch && uni_ch <= 0xdfff)
868   - {
869   - if(0xdc00 <= uni_ch)
870   - {
871   - // a second 16-bit of a surrogate pair appeared
872   - return false;
873   - }
874   - // first 16-bit of surrogate pair, get the next one
875   - if(in.getc() != '\\' || in.getc() != 'u')
876   - {
877   - in.ungetc();
878   - return false;
879   - }
880   - int second = _parse_quadhex(in);
881   - if(!(0xdc00 <= second && second <= 0xdfff))
882   - {
883   - return false;
884   - }
885   - uni_ch = ((uni_ch - 0xd800) << 10) | ((second - 0xdc00) & 0x3ff);
886   - uni_ch += 0x10000;
887   - }
888   - if(uni_ch < 0x80)
889   - {
890   - out.push_back(uni_ch);
891   - }
892   - else
893   - {
894   - if(uni_ch < 0x800)
895   - {
896   - out.push_back(0xc0 | (uni_ch >> 6));
897   - }
898   - else
899   - {
900   - if(uni_ch < 0x10000)
901   - {
902   - out.push_back(0xe0 | (uni_ch >> 12));
903   - }
904   - else
905   - {
906   - out.push_back(0xf0 | (uni_ch >> 18));
907   - out.push_back(0x80 | ((uni_ch >> 12) & 0x3f));
908   - }
909   - out.push_back(0x80 | ((uni_ch >> 6) & 0x3f));
910   - }
911   - out.push_back(0x80 | (uni_ch & 0x3f));
912   - }
913   - return true;
914   -}
915   -
916   -template<typename String, typename Iter>
917   -inline bool _parse_string(String& out, input<Iter>& in)
918   -{
919   - while(1)
920   - {
921   - int ch = in.getc();
922   - if(ch < ' ')
923   - {
924   - in.ungetc();
925   - return false;
926   - }
927   - else if(ch == '"')
928   - {
929   - return true;
930   - }
931   - else if(ch == '\\')
932   - {
933   - if((ch = in.getc()) == -1)
934   - {
935   - return false;
936   - }
937   - switch(ch)
938   - {
939   -#define MAP(sym, val) \
940   - case sym: \
941   - out.push_back(val); \
942   - break
943   - MAP('"', '\"');
944   - MAP('\\', '\\');
945   - MAP('/', '/');
946   - MAP('b', '\b');
947   - MAP('f', '\f');
948   - MAP('n', '\n');
949   - MAP('r', '\r');
950   - MAP('t', '\t');
951   -#undef MAP
952   - case 'u':
953   - if(!_parse_codepoint(out, in))
954   - {
955   - return false;
956   - }
957   - break;
958   - default:
959   - return false;
960   - }
961   - }
962   - else
963   - {
964   - out.push_back(ch);
965   - }
966   - }
967   - return false;
968   -}
969   -
970   -template<typename Context, typename Iter>
971   -inline bool _parse_array(Context& ctx, input<Iter>& in)
972   -{
973   - if(!ctx.parse_array_start())
974   - {
975   - return false;
976   - }
977   - size_t idx = 0;
978   - if(in.expect(']'))
979   - {
980   - return ctx.parse_array_stop(idx);
981   - }
982   - do
983   - {
984   - if(!ctx.parse_array_item(in, idx))
985   - {
986   - return false;
987   - }
988   - idx++;
989   - } while(in.expect(','));
990   - return in.expect(']') && ctx.parse_array_stop(idx);
991   -}
992   -
993   -template<typename Context, typename Iter>
994   -inline bool _parse_object(Context& ctx, input<Iter>& in)
995   -{
996   - if(!ctx.parse_object_start())
997   - {
998   - return false;
999   - }
1000   - if(in.expect('}'))
1001   - {
1002   - return true;
1003   - }
1004   - do
1005   - {
1006   - std::string key;
1007   - if(!in.expect('"') || !_parse_string(key, in) || !in.expect(':'))
1008   - {
1009   - return false;
1010   - }
1011   - if(!ctx.parse_object_item(in, key))
1012   - {
1013   - return false;
1014   - }
1015   - } while(in.expect(','));
1016   - return in.expect('}');
1017   -}
1018   -
1019   -template<typename Iter>
1020   -inline std::string _parse_number(input<Iter>& in)
1021   -{
1022   - std::string num_str;
1023   - while(1)
1024   - {
1025   - int ch = in.getc();
1026   - if(('0' <= ch && ch <= '9') || ch == '+' || ch == '-' || ch == 'e' || ch == 'E')
1027   - {
1028   - num_str.push_back(ch);
1029   - }
1030   - else if(ch == '.')
1031   - {
1032   -#if PICOJSON_USE_LOCALE
1033   - num_str += localeconv()->decimal_point;
1034   -#else
1035   - num_str.push_back('.');
1036   -#endif
1037   - }
1038   - else
1039   - {
1040   - in.ungetc();
1041   - break;
1042   - }
1043   - }
1044   - return num_str;
1045   -}
1046   -
1047   -template<typename Context, typename Iter>
1048   -inline bool _parse(Context& ctx, input<Iter>& in)
1049   -{
1050   - in.skip_ws();
1051   - int ch = in.getc();
1052   - switch(ch)
1053   - {
1054   -#define IS(ch, text, op) \
1055   - case ch: \
1056   - if(in.match(text) && op) \
1057   - { \
1058   - return true; \
1059   - } \
1060   - else \
1061   - { \
1062   - return false; \
1063   - }
1064   - IS('n', "ull", ctx.set_null());
1065   - IS('f', "alse", ctx.set_bool(false));
1066   - IS('t', "rue", ctx.set_bool(true));
1067   -#undef IS
1068   - case '"':
1069   - return ctx.parse_string(in);
1070   - case '[':
1071   - return _parse_array(ctx, in);
1072   - case '{':
1073   - return _parse_object(ctx, in);
1074   - default:
1075   - if(('0' <= ch && ch <= '9') || ch == '-')
1076   - {
1077   - double f;
1078   - char* endp;
1079   - in.ungetc();
1080   - std::string num_str = _parse_number(in);
1081   - if(num_str.empty())
1082   - {
1083   - return false;
1084   - }
1085   -#ifdef PICOJSON_USE_INT64
1086   - {
1087   - errno = 0;
1088   - intmax_t ival = strtoimax(num_str.c_str(), &endp, 10);
1089   - if(errno == 0 && std::numeric_limits<int64_t>::min() <= ival && ival <= std::numeric_limits<int64_t>::max() && endp == num_str.c_str() + num_str.size())
1090   - {
1091   - ctx.set_int64(ival);
1092   - return true;
1093   - }
1094   - }
1095   -#endif
1096   - f = strtod(num_str.c_str(), &endp);
1097   - if(endp == num_str.c_str() + num_str.size())
1098   - {
1099   - ctx.set_number(f);
1100   - return true;
1101   - }
1102   - return false;
1103   - }
1104   - break;
1105   - }
1106   - in.ungetc();
1107   - return false;
1108   -}
1109   -
1110   -class deny_parse_context
1111   -{
1112   -public:
1113   - bool set_null()
1114   - {
1115   - return false;
1116   - }
1117   - bool set_bool(bool)
1118   - {
1119   - return false;
1120   - }
1121   -#ifdef PICOJSON_USE_INT64
1122   - bool set_int64(int64_t)
1123   - {
1124   - return false;
1125   - }
1126   -#endif
1127   - bool set_number(double)
1128   - {
1129   - return false;
1130   - }
1131   - template<typename Iter>
1132   - bool parse_string(input<Iter>&)
1133   - {
1134   - return false;
1135   - }
1136   - bool parse_array_start()
1137   - {
1138   - return false;
1139   - }
1140   - template<typename Iter>
1141   - bool parse_array_item(input<Iter>&, size_t)
1142   - {
1143   - return false;
1144   - }
1145   - bool parse_array_stop(size_t)
1146   - {
1147   - return false;
1148   - }
1149   - bool parse_object_start()
1150   - {
1151   - return false;
1152   - }
1153   - template<typename Iter>
1154   - bool parse_object_item(input<Iter>&, const std::string&)
1155   - {
1156   - return false;
1157   - }
1158   -};
1159   -
1160   -class default_parse_context
1161   -{
1162   -protected:
1163   - value* out_;
1164   -
1165   -public:
1166   - default_parse_context(value* out)
1167   - : out_(out)
1168   - {
1169   - }
1170   - bool set_null()
1171   - {
1172   - *out_ = value();
1173   - return true;
1174   - }
1175   - bool set_bool(bool b)
1176   - {
1177   - *out_ = value(b);
1178   - return true;
1179   - }
1180   -#ifdef PICOJSON_USE_INT64
1181   - bool set_int64(int64_t i)
1182   - {
1183   - *out_ = value(i);
1184   - return true;
1185   - }
1186   -#endif
1187   - bool set_number(double f)
1188   - {
1189   - *out_ = value(f);
1190   - return true;
1191   - }
1192   - template<typename Iter>
1193   - bool parse_string(input<Iter>& in)
1194   - {
1195   - *out_ = value(string_type, false);
1196   - return _parse_string(out_->get<std::string>(), in);
1197   - }
1198   - bool parse_array_start()
1199   - {
1200   - *out_ = value(array_type, false);
1201   - return true;
1202   - }
1203   - template<typename Iter>
1204   - bool parse_array_item(input<Iter>& in, size_t)
1205   - {
1206   - array& a = out_->get<array>();
1207   - a.push_back(value());
1208   - default_parse_context ctx(&a.back());
1209   - return _parse(ctx, in);
1210   - }
1211   - bool parse_array_stop(size_t)
1212   - {
1213   - return true;
1214   - }
1215   - bool parse_object_start()
1216   - {
1217   - *out_ = value(object_type, false);
1218   - return true;
1219   - }
1220   - template<typename Iter>
1221   - bool parse_object_item(input<Iter>& in, const std::string& key)
1222   - {
1223   - object& o = out_->get<object>();
1224   - default_parse_context ctx(&o[key]);
1225   - return _parse(ctx, in);
1226   - }
1227   -
1228   -private:
1229   - default_parse_context(const default_parse_context&);
1230   - default_parse_context& operator=(const default_parse_context&);
1231   -};
1232   -
1233   -class null_parse_context
1234   -{
1235   -public:
1236   - struct dummy_str
1237   - {
1238   - void push_back(int)
1239   - {
1240   - }
1241   - };
1242   -
1243   -public:
1244   - null_parse_context()
1245   - {
1246   - }
1247   - bool set_null()
1248   - {
1249   - return true;
1250   - }
1251   - bool set_bool(bool)
1252   - {
1253   - return true;
1254   - }
1255   -#ifdef PICOJSON_USE_INT64
1256   - bool set_int64(int64_t)
1257   - {
1258   - return true;
1259   - }
1260   -#endif
1261   - bool set_number(double)
1262   - {
1263   - return true;
1264   - }
1265   - template<typename Iter>
1266   - bool parse_string(input<Iter>& in)
1267   - {
1268   - dummy_str s;
1269   - return _parse_string(s, in);
1270   - }
1271   - bool parse_array_start()
1272   - {
1273   - return true;
1274   - }
1275   - template<typename Iter>
1276   - bool parse_array_item(input<Iter>& in, size_t)
1277   - {
1278   - return _parse(*this, in);
1279   - }
1280   - bool parse_array_stop(size_t)
1281   - {
1282   - return true;
1283   - }
1284   - bool parse_object_start()
1285   - {
1286   - return true;
1287   - }
1288   - template<typename Iter>
1289   - bool parse_object_item(input<Iter>& in, const std::string&)
1290   - {
1291   - return _parse(*this, in);
1292   - }
1293   -
1294   -private:
1295   - null_parse_context(const null_parse_context&);
1296   - null_parse_context& operator=(const null_parse_context&);
1297   -};
1298   -
1299   -// obsolete, use the version below
1300   -template<typename Iter>
1301   -inline std::string parse(value& out, Iter& pos, const Iter& last)
1302   -{
1303   - std::string err;
1304   - pos = parse(out, pos, last, &err);
1305   - return err;
1306   -}
1307   -
1308   -template<typename Context, typename Iter>
1309   -inline Iter _parse(Context& ctx, const Iter& first, const Iter& last, std::string* err)
1310   -{
1311   - input<Iter> in(first, last);
1312   - if(!_parse(ctx, in) && err != NULL)
1313   - {
1314   - char buf[64];
1315   - SNPRINTF(buf, sizeof(buf), "syntax error at line %d near: ", in.line());
1316   - *err = buf;
1317   - while(1)
1318   - {
1319   - int ch = in.getc();
1320   - if(ch == -1 || ch == '\n')
1321   - {
1322   - break;
1323   - }
1324   - else if(ch >= ' ')
1325   - {
1326   - err->push_back(ch);
1327   - }
1328   - }
1329   - }
1330   - return in.cur();
1331   -}
1332   -
1333   -template<typename Iter>
1334   -inline Iter parse(value& out, const Iter& first, const Iter& last, std::string* err)
1335   -{
1336   - default_parse_context ctx(&out);
1337   - return _parse(ctx, first, last, err);
1338   -}
1339   -
1340   -inline std::string parse(value& out, const std::string& s)
1341   -{
1342   - std::string err;
1343   - parse(out, s.begin(), s.end(), &err);
1344   - return err;
1345   -}
1346   -
1347   -inline std::string parse(value& out, std::istream& is)
1348   -{
1349   - std::string err;
1350   - parse(out, std::istreambuf_iterator<char>(is.rdbuf()), std::istreambuf_iterator<char>(), &err);
1351   - return err;
1352   -}
1353   -
1354   -template<typename T>
1355   -struct last_error_t
1356   -{
1357   - static std::string s;
1358   -};
1359   -template<typename T>
1360   -std::string last_error_t<T>::s;
1361   -
1362   -inline void set_last_error(const std::string& s)
1363   -{
1364   - last_error_t<bool>::s = s;
1365   -}
1366   -
1367   -inline const std::string& get_last_error()
1368   -{
1369   - return last_error_t<bool>::s;
1370   -}
1371   -
1372   -inline bool operator==(const value& x, const value& y)
1373   -{
1374   - if(x.is<null>())
1375   - return y.is<null>();
1376   -#define PICOJSON_CMP(type) \
1377   - if(x.is<type>()) \
1378   - return y.is<type>() && x.get<type>() == y.get<type>()
1379   - PICOJSON_CMP(bool);
1380   - PICOJSON_CMP(double);
1381   - PICOJSON_CMP(std::string);
1382   - PICOJSON_CMP(array);
1383   - PICOJSON_CMP(object);
1384   -#undef PICOJSON_CMP
1385   - PICOJSON_ASSERT(0);
1386   -#ifdef _MSC_VER
1387   - __assume(0);
1388   -#endif
1389   - return false;
1390   -}
1391   -
1392   -inline bool operator!=(const value& x, const value& y)
1393   -{
1394   - return !(x == y);
1395   -}
1396   -} // namespace picojson
1397   -
1398   -#if !PICOJSON_USE_RVALUE_REFERENCE
1399   -namespace std
1400   -{
1401   -template<>
1402   -inline void swap(picojson::value& x, picojson::value& y)
1403   -{
1404   - x.swap(y);
1405   -}
1406   -} // namespace std
1407   -#endif
1408   -
1409   -inline std::istream& operator>>(std::istream& is, picojson::value& x)
1410   -{
1411   - picojson::set_last_error(std::string());
1412   - std::string err = picojson::parse(x, is);
1413   - if(!err.empty())
1414   - {
1415   - picojson::set_last_error(err);
1416   - is.setstate(std::ios::failbit);
1417   - }
1418   - return is;
1419   -}
1420   -
1421   -inline std::ostream& operator<<(std::ostream& os, const picojson::value& x)
1422   -{
1423   - x.serialize(std::ostream_iterator<char>(os));
1424   - return os;
1425   -}
1426   -#ifdef _MSC_VER
1427   -#pragma warning(pop)
1428   -#endif
1429   -
1430   -#endif
examples/reflection-demo/gltf-scene.cpp
  View file @4f2d9d0
... ... @@ -14,11 +14,12 @@
14 14 * limitations under the License.
15 15 *
16 16 */
17   -#include <dali/devel-api/adaptor-framework/file-stream.h>
18 17  
  18 +// HEADER
19 19 #include "gltf-scene.h"
20 20  
21   -#include "pico-json.h"
  21 +// EXTERNAL INCLUDES
  22 +#include <dali/devel-api/adaptor-framework/file-stream.h>
22 23  
23 24 namespace
24 25 {
... ...
examples/reflection-demo/gltf-scene.h
  View file @4f2d9d0
  1 +#ifndef GLTF_SCENE_H
  2 +#define GLTF_SCENE_H
  3 +
1 4 /*
2 5 * Copyright (c) 2020 Samsung Electronics Co., Ltd.
3 6 *
... ... @@ -15,14 +18,13 @@
15 18 *
16 19 */
17 20  
18   -#ifndef GLTF_SCENE_H
19   -#define GLTF_SCENE_H
20   -
21   -#include <dali/integration-api/debug.h>
22 21  
  22 +// EXTERNAL INCLUDES
23 23 #include <string>
  24 +#include <dali/integration-api/debug.h>
24 25  
25   -#include "pico-json.h"
  26 +// INTERNAL INCLUDES
  27 +#include "third-party/pico-json.h"
26 28  
27 29 #define GLTF_LOG(...) \
28 30 { \
... ...
examples/reflection-demo/pico-json.h renamed to third-party/pico-json.h
  View file @4f2d9d0