[geos-commits] [SCM] GEOS branch tinyxml2 updated. 74223ffb73bdfb0f32d04c9f84c99edb945cb59d
git at osgeo.org
git at osgeo.org
Tue Jun 26 00:03:56 PDT 2018
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GEOS".
The branch, tinyxml2 has been updated
discards a418f09eb1f4c9b4a7673f4ba7d486559ad9e33d (commit)
via 74223ffb73bdfb0f32d04c9f84c99edb945cb59d (commit)
via 5bf8baeea27e734711ed51215665c26127d7b995 (commit)
via 60fbafd7c2470781a022057610a85787ae98cc88 (commit)
via d9619c5605296175de81bf02e4aa4ab0b82c7d76 (commit)
via cb96f2162988f2692615841206fa1ef1c836e617 (commit)
via fd24ab482bf25cecc8cdd2520ae2c09867263624 (commit)
via 7eb3369032d42425fafd4defe799f43f352215ec (commit)
via fe5b4d41ed19fc8c076a6482f60e10c50b488e0f (commit)
via 681d852f9a12b3d0c03d90075f6c42aaf60a199f (commit)
via 028fcc1ef07a100bea8c5ed928dee87b7250928c (commit)
via 40314bb47e7f5025675ec833c8a8fa11c3ce313b (commit)
via 96c9e652edb8c1eef12d2e29d01c085aaf6d2c85 (commit)
via bf8bf78127902f7e4718c03e7fa8fec22ad6838c (commit)
via 851b9161b3291bd6c44ffddd83793bf6995409ec (commit)
via 94da3a382001f63b1516bf54df1ebbd4c6bc463a (commit)
via 8da8bcc68b6e397e586c88621c8eba2cb4611e5e (commit)
via 860bd02610613b452119a1b08fd68cdfeeead713 (commit)
via 5ac4db28a53cc8762afd976e57fe9ebd565fc8fd (commit)
via 4fa0c1c9ccca2ef15b7bd293324009c53399b109 (commit)
via 9eb81524a0619b71d095dc0b54a7fafa70722b4a (commit)
via 5eca48f4097054d0b2218ab2f6b7d817b6a9b0d6 (commit)
via 049a4b476aeedd485e29c1d729f1e8aa92298da8 (commit)
via f343847fe08ae05c692aaa1530eaf0d1e296b11a (commit)
via 1aef6fac1dc774118c3622cc83fc824a9d5daf9a (commit)
via d82729a76d6a6517df908281e8350d4ccdfc9dd3 (commit)
via 38202bd17f9c8687f579a2ac5017e0370969ff28 (commit)
via 0039c291ba1a153958ce64109402a0a42ccf7c29 (commit)
via d390b76990a899c6443a0aa4f35ea6e730332bd9 (commit)
via b727cfa6f38f6ea4ecabbfcf35a55909414aa7fc (commit)
via d501c436beabce50fe13ff887407d01b372a313c (commit)
via e222eda020dd26f960dda2007b8c37941b019835 (commit)
via b3c227ff6683f8b448eadb186f2ece456f67b22d (commit)
via ab283a7fe8949d360a61e82e422c52e8ad59d192 (commit)
via 594bd310efc129dcaf87afa4ae73ead3527bf75a (commit)
via 9da4e4d003c91413a055471a21fbd3b8fe6b3778 (commit)
via da94dc58e5363e3c2114794a65db5514a583c2d9 (commit)
via abbcf604cd5bb2463b3d9b17e086879495ffa671 (commit)
via 439fbb5c29367e096b4589934e2f66cf0f60d341 (commit)
via 9f935f78318c3edc8cd135d5805b94e74b4dcfe5 (commit)
via 9c1c5e09b08bf42d3e97836a09017068e602b6f3 (commit)
via d1614d44959322f27d01e863b778a658467f1807 (commit)
via 8eff799cd72b7892009f1ed5e30c5c3e81796bca (commit)
via 943a7f3c4ebe25ad2a75cd14661e2517a879872d (commit)
via 6c9463834edb712f315c18283e759a49b43b7759 (commit)
via 73abcca704c7859b68cb7ccc8e41c87ec741e7fc (commit)
via 6de003f688ec089b73580018d903abe9196263d3 (commit)
via 19e02ca9b21eed7f5d348fb2fd42fd89be86391f (commit)
via fc10eaac1b604d66879b2ff776313bd9a3900269 (commit)
via b40bd637f56242d5d4ad5ef2bf6a3ec12b328645 (commit)
via d10c844668c26edd8e4a377eff9bf031da5278a6 (commit)
via 084542e55d73822b7a00c67078c2f103d185679b (commit)
via db7514be906d1f26d39c34403fd41d520daa56de (commit)
via 99aeda0ea2ae41a5870bbc777dd5a4822ab43d7b (commit)
via 4c571e0090ebcf8db41e4776d554eddffb5a7be2 (commit)
via 3fe3c03ae6759611a6122a6e63ace82ca986af29 (commit)
via 0f722dc002ff8f907078193548b9ce8e028b5da2 (commit)
via 4b23f09c8e0ff3d178cc6538c3bf4e52b80e33cf (commit)
via 759255faaeb946e59266460d41a08e1eb70233e8 (commit)
via 227ad17e4a9ef8d009d16240de492d4b5df70bcc (commit)
via 667d3b0b649e86bc1de3cfdc574fdc885c20b2cf (commit)
via c6320119a03995d7f706fb63e133b9a4965ca17a (commit)
via 9a06fe132b15bc6d69ae6bad7e2cc97c09997b4a (commit)
via 79ad4b902708800bf6c9457135857801eddfb727 (commit)
via db5e2bc50f636ef47e53dfa9f3d8028ff44ef400 (commit)
via b01059bbc03199f3f6518cb5f400515d4802d4de (commit)
via e39d8dd2a615b3c552cc3b9ace41fabecf961aae (commit)
via 17664913c5fd5d34358fa59fc6de4a712bf95342 (commit)
via 409e612f920702f6e5f99d358e24b596823c6980 (commit)
via 61583e65112153e8248f1befee76ab4d7afd4ac5 (commit)
via c8418c4ac23d260b13a938f5aa473f1ca7519acc (commit)
via 40d9c6c0fd761cc10b42ccc572e9310f300a8891 (commit)
via 5ff02b274b93d7f41f8a247d86fefa85ae476286 (commit)
via da5f549ac67fb07d26d7625a39cad40e678fcda0 (commit)
via eb5aba7bc8383cc006f184132c42375fa97336d3 (commit)
via 4a13a7fc2485ca7af7ba973cdc3125b615a54bc7 (commit)
via 2d49b1b891723228d51518ed682dede3c15042cf (commit)
via d43e678578cfc60d02fbb051319d65e638474515 (commit)
via 62380be288dc5cd2e6b5e8afc69e7b9e716546dc (commit)
via ed57b476690b07f1e8b51b015ec35ac6970aac7e (commit)
via e99ed9d1996b6fd491a6462c54dfc83cacb5a997 (commit)
via c60c5e3d6a7da9d74a427798a59408067800b78b (commit)
via 94243cfcd1a2f7e9cadebbf2abaad05cefe7e5e5 (commit)
via 230f915b78ebc3b02eb273310d8dec1a72698dac (commit)
via c292ffd76375a8f725bb7d889e3206c29f76b6b6 (commit)
via b5c0141cf50bc5c9c5b9e0591ea3f4d937224a25 (commit)
via 11476b5c1aee62c7be5ecfab03389e240b7e0966 (commit)
via a51a06b1ca566363b023b79d296f636aa163d908 (commit)
via a606747995b4d38a7e63f436f8d5057a9917fe51 (commit)
via aae36582e743505c863c5767e5989da48f84d5a6 (commit)
via 3818e56d78dde30c1849341eabe67a5b809b74e2 (commit)
via 312ef8a895c81dce85e386500e6938fe9470810e (commit)
via 18ad844411880b3b15507ff21c7a452ab8694cc2 (commit)
via 3c6391825ac5f9fbd253995f685c8bcc0f4f9d2a (commit)
via 316c4bc51d9d860b67344e48519ef98fd3c28c16 (commit)
via b468a06bb0af4edde4fafec78661c8f3763b9764 (commit)
via 8d6139637af5263595c768dab91008d143d1db0d (commit)
via 15346db3c5a5148a6005fa842184d9fffcfeb801 (commit)
via 07b05035b5e5b6a4e9ce47249aa28b38c668dc8b (commit)
via d063c20e1c4c28374e04c37df1eb4d56790deca9 (commit)
via f16197b156541f5825a84f8262b5a3ee2007bf78 (commit)
via 2c8c5fd9fb237b48927618c9efc84062b1285af1 (commit)
via d78d4e4655afb4d71b12fd51b917e813bd57a6ff (commit)
via 344bbdefb7a08c9bb21d6ea88c9b850263d53f50 (commit)
via d7e6a0f995165a2099970997b0088dd292fb9a32 (commit)
via 780221a5aa171f247d097f95cfbbde2049811ab2 (commit)
via af73ed20ed0ec0a610551090fdd8c8da8a66727d (commit)
via 6731fd9002ad2f6cfbf0c97dfc469db3527899cb (commit)
via aeee1f3f1b8afa9c2ebb151f4dff3dc04a9a43c3 (commit)
via 6307e6ed87c3703cf50278ad4a96d3e55054313d (commit)
via e30c3fb95e71f74d8e80ef6810ade61f3edf44ba (commit)
via efca1e7e754f5a527a0ca7223d674591cc2e271a (commit)
via 2ebfdcc2e255f446326037652a5edf4f4b3ad430 (commit)
via b7101be6533a1273f715a3309889c23b7ae02e4f (commit)
via 6f0c2bac087180369760e9fed244bb797582a3b2 (commit)
via 661420a67efa46dd99fb1b990ee67d34abb1b965 (commit)
via e43016dd7397711e5bd64cdba92f2b6f671c4fbc (commit)
via c5892faf4bdc3777420a638ed265d1e521d074b7 (commit)
via 6b236e95faf8a3f52d2ee4158d1e7f57829fe42f (commit)
via f1c2215d560473fec89c0b047f299e9028be6533 (commit)
via a625517faf3871999fcbaee5cf0de61e0036d091 (commit)
via 77dfb8f781d00fb995c3481dca94bb508c4cf373 (commit)
via 1e2b2a2600c4ee31378842cc3c46d61cfad9efce (commit)
via 6d3f562f2935735296172dbe8a1362944b89a24a (commit)
via 4b2b6dff199ab4ebee30d7a8dfe078106ab6e9dd (commit)
via 8193383d7020b369205c79ba9021e8b1774a84ca (commit)
via b507095ff861fbe8642cd65660bf530e674efb2f (commit)
via 50860b7a7466e88510dac92b4c1a568ee807e5c4 (commit)
via 4c9b08743a31f3ecf3fee742cbaffcb69e00d2f7 (commit)
via d36e59c25334a9b06bb9b4007982766c5071f7dc (commit)
via 5d3e5a1c0e525b72481fdddec35f2929e8e4d665 (commit)
via 441dc93f8cd23dcdf204143d524e426f4ccb8bc3 (commit)
via f0a3f0002f5dd3c8308c21d95aa1eb4008cb06d6 (commit)
via 4d4474359b94f1ab04815b4131db44cdc0efe7ce (commit)
via 6932138816c720c5b90dd7490541274e40fb50f1 (commit)
via 16183469312aef329c096f1b8a5d95521575a9d8 (commit)
via 7d44838732a17bc7267b73d7c7f23c7be1a72860 (commit)
via 64e823b26bc6a771571f39af245b0e0f4e256df8 (commit)
via 080d94701ce900494898c5fe78c53a1db72a5f4c (commit)
via ec5e78da7c79bbb1a5c413ee62f0368776deda53 (commit)
via fd7db6161f4d0c2a862e719e0b1fa5b431da1adc (commit)
via 81c6d4ad592387ff8c918507862c1638d2d42b97 (commit)
via 63410b14d1ca1117a91b2e31928d893cf78fa1fb (commit)
via 869e009e6c9b9d0d570d09bc24e711acdffc6548 (commit)
via 999b297244a5e04f31b35163506532873fa7963a (commit)
via 049ae7afb895f78f64d98a782256b9d05e064393 (commit)
via f73910622e826b12e24fb31c7378ef8a08c07268 (commit)
via 03073476f4a07f0fe99e804a50fcdf87e550459a (commit)
via 335bfb8f3d21acd338820d6a36f0c0f218ec3dc2 (commit)
via d7bb07bcf25c8b22f453a809ca0eecdf689b1ea7 (commit)
via 88fbd4d41b0e3ac92bb170883f8153e0b10ffb6e (commit)
via b7ec17b493016dc0cf628682445e1041a2d9e096 (commit)
via 97843ef1bac3323503ee2001de6d276e2039d207 (commit)
via 0f26249a5808a09e97fda6b0ce4bdb1c0e8a5bcd (commit)
via 3def76e20a15b2cba5c4b991d320eb5ddd76797d (commit)
via a7b5e81c6a8ff7c790388a60fb43f27a04a41ce5 (commit)
via 281e59fc983f724b7a220531d4ea72f78fc7e5dd (commit)
via 8d171e4d47149666f1a10d4ee42ea445b8925c6e (commit)
via 28826db0e67354671725506084407e73bbc98003 (commit)
via 60abce68d5eab69188072c350ed03f18a7b6418a (commit)
via e15c245829ba240ef01d36c902fedb8424cc451c (commit)
via 8fe2ce6299de38b49971ce9a31fb7ef2675b3607 (commit)
via 27b5f998d5cab908ddf027e7b8f6844d0cbe77a1 (commit)
via f802c814a9cc011408698ea94fd3d7d875339657 (commit)
via f9d521efcfce8699c71c07f1c3a62391d905ca38 (commit)
via cb60e11603839d5d6e090720b40edfec7f53f692 (commit)
via bc3ce09bf9f7fdd16dc7ef1fd4a9f1e710d22753 (commit)
via 5a730fc50dab2610a9e6c037b521accc66b7777b (commit)
via e1f6205d2ed6fe317f9eccdbede8824561d196e8 (commit)
via 84477476f382c4d40860879dfbbc96b6e1d16f39 (commit)
via b8c7ea3e61f38f64edca2d5322c9ad14a10ff6a3 (commit)
via f825b41004b37fcb0dd4ea76f22b5b6aa447b2ac (commit)
via c505c8ac87e27a271f261f17e155598c9bcb2aaa (commit)
via 667d18feff7acc6fa35fddc26d5884fc67b710dc (commit)
via 133c801ff16a5755d915ef9a80cdb66ecf814730 (commit)
via 543532d1d272da03c74b6bda0b602a764d988675 (commit)
via 8259b0e266fbc77da2462e9644d10ff93f428658 (commit)
via c1caa8aeaaa06bc538a5377f54e721cb65e8734a (commit)
via a6756efe5d3eff9924c4a716a28bdbfd8b179176 (commit)
via 22e93b2a484da58af4756a53fbcfa08f9d8bb254 (commit)
via c626efb67203e092051b8dfcd33080117f682758 (commit)
via b797c4e172565283ba26a4a8528f320c1b2cf4f7 (commit)
via d50828b9644980563d09bf490d7ea5b74e95041f (commit)
via edbd47cbd83f1005f81a553a70a9d9f34a2d2d0f (commit)
via 39e18b5b15c34939cae59cb7bdd9cd24388ad541 (commit)
via 03f46a30e19d46de1ea748e8b0a44963f0845f26 (commit)
via 2e54be24bffc733989a8e9076f85ba3727f1800e (commit)
via 7f3a218283b76a51ef6c0c8ad3c75134acfe49fc (commit)
via ee134e7af15898a2cc6631d046851b50523cf437 (commit)
via 4091c89da51c4ee35882f995157e13bd5e4d7981 (commit)
via 0474abde402fa35535dae945f2329ac50ff09c60 (commit)
via b382bf130039cd686b73e86d4de395ce8a1c3d00 (commit)
via 82ee5697e2c4fdfbbeb3e4a572c2b5f589f6f03d (commit)
via 70a1bcd8c13111b9824a1bb4642534db6bc7f451 (commit)
via 7e455b9b824c5c4085309f2442ef1465a57d11cf (commit)
via a6221c09870678284aec7fcb6f00d7b0ff5e9a3f (commit)
via 4a2dc22c969c2339d522afadf6b0d5496a1c6cc6 (commit)
via 59f48eff99cec1a37303f935978a9d36ab4540f1 (commit)
via f10c91831c01dabcd87e296dfe21c2f8c98b32ff (commit)
via f3440ab9ede150590c1c7cefabeb360f78990f10 (commit)
via 2e58032c1c0d58b69a7fa6e698dd027ba72f9f30 (commit)
via d01487002587cbf4cb7e925b6ef208ad6922d36b (commit)
via 5e9aac46acfd4208a3a5d525e3f6d0fb17214f2a (commit)
via b4e548f49314e7e1cc8afc002f2712f21e82e66a (commit)
via 94d0830713c01300d03c458668b6c072be1577ee (commit)
via 96c598679cb72f7119528a492ac6ca9df84afb25 (commit)
via fd97b1b82e7d1f233f01a1875c5b82fe4b072d62 (commit)
via 377f7db436858fce453081e9e6a75f3b26e25e9b (commit)
via 343da94a9b8b2d717ec9e7b3856fbd678e87a2b5 (commit)
via 2f6082e07e3844513149c80609c956f0d339c1e7 (commit)
via a6eab69aeeeab775d57b6813c177dda9a0e437ed (commit)
via edb56d2a6241d4ce1896c78340176e1d426c17d5 (commit)
via 3eee41d7db7654118ccd2f0164321896b1bde1c0 (commit)
via 40da78037686fd531400d51f249aa6372f62cd00 (commit)
via 6e1127efa26429a56aaab9bcdd7fc42aeb81aede (commit)
via f4760740b8087c2eb5b5668ecba2d81bc4612a56 (commit)
via 5060bff1dd2804167754c0d2e780fb5886e5bef4 (commit)
via b99984585659fb6f33cdb458809204574746e924 (commit)
via e4330313224fa1bda70e01992f1f4b8b88df201b (commit)
via cfeb160dfd67fe746f47a2b3f9c3d0227b5f6c88 (commit)
via 135bbe6f461365822a1248de422960e7b3782c45 (commit)
via 02112e406b42ea463e05248e1ab7a3a00915cacb (commit)
via 2d2eddac691779685750da2b2cd02ad00adc9163 (commit)
via b64dd7cfe845f1b233622aee404d863807cfaff5 (commit)
via 0a21735e84407fdebde2ca2e2acd6e6122023282 (commit)
via a2e39931a3532a8f0f7a8ba8b1522d6de34200b3 (commit)
via 74699a90f7fc4a1a1c3a05e12b5973110510d50c (commit)
via b9925942666d1007f3af99f92ffcf80db5d6fb29 (commit)
via 90c52f550de2386a2477f796ed3de9d3303eca85 (commit)
via 4b738a5ff1fef369e789abd6c7b8459434f41456 (commit)
via c29d5e2b1aa561d3eaeec6c840089954a996a3fd (commit)
via fce21302a186d355128a7ff094992d0467a6c912 (commit)
via fbb4431f84ba516b873961b373567ae79a1d92e2 (commit)
via 11072acfb62ac5044125644385aea86c72e012a6 (commit)
via 9e3d3ed734ac14dbfa34493d80b88c760a42a439 (commit)
via 0931e724ca6610e0c181fa391889a40322a860ce (commit)
via 0393ea28581e8b7852d627771c41e40e146ade27 (commit)
via dbc52d41fd43bb9bdec31fc9969a66d05bc4bf95 (commit)
via 092486f18f8a17c048e679c573f5655f9852152a (commit)
via 0678a7ddc31e2f347e239b3e5c1ca66e99d28a0d (commit)
via 0e3fa7d0d45200c2096e532a5fc9048dfee60563 (commit)
via a52412dd70476292703e45c6def09078aaec2acb (commit)
via 502afd4eb0a3497e3a783a8d5d43d909cbad790f (commit)
via 4da5102b80d695fd15ffb039e39153b9967f11f5 (commit)
via 6bb7b349a7c7a095565abfe4a4a7bd65c3c5d8ae (commit)
via 341d8c9a5d3dc74184a262551a95fdbaa320ff85 (commit)
via aa22f4187ce5ba2945d265b473d3c07282bb1f43 (commit)
via 9c7b8936d51ceb4f25935a14aecfe3a640701beb (commit)
via 76af08c8d59f30fd2d7fb9428de30642fd4c6b33 (commit)
via bf7e9c23655e291ad4e93b4e287f2e153a838689 (commit)
via aa853a6982bcdaba24e71032cebde88373f70625 (commit)
via bd1b03ef5fe049ba43acbd53b136754bfd8a6043 (commit)
via 6cecfc14466e63b830183abfd72f29d3b3c75af9 (commit)
via f6c023c2fe5bb863ab387fee8c5619d0c32b8763 (commit)
via fb0b585c195c462f3ef938983697055e25b0a3aa (commit)
via 596e4fefa4561afeab9226eb8682ecd6136acc05 (commit)
via 4f943df80cc80fbad6c990f19c8cc6cf12446e0d (commit)
via e5d21b533d5d60a2076569b7f5e4e6002c22d6ea (commit)
via 4e507bbcd8c8d64068399061ae5c740d11f45bc5 (commit)
via c79f80eb6632bf451d06a758e2dafdf2672bab15 (commit)
via 3be87d11a3ebcd4b581eb15ee003354ec4f84698 (commit)
via 3049fb8ed8fcab199508c05e111acb9f8524111c (commit)
via 26c872f029c7f1d8f3070c871c2370517a925e0a (commit)
via b7943e7420f37027a332d3ab0ba7eda967c05687 (commit)
via 24ea7e6faba40f7a2f9eb8088795ba92389a5948 (commit)
via ff501d32a0b9b3fe33d10013d357b1e6ee78bd93 (commit)
via 5b6d5406c29534a8bc295afa7406da6af5ce0529 (commit)
via f74c634521e5a9071f75a03e25bad7bd80f248d0 (commit)
via aa4621aec3656d03d209cceffa82b33d3bb3b4fc (commit)
via cad3afeedbd1cc103ca6b463e0be49a2b2f42e61 (commit)
via 558635ffd1c2e2f0c2327c6f8aced09035532ede (commit)
via 96acf8af2066a5af4cb736ce9f5d66e89138e2c4 (commit)
via 88d8a54d7125987248365224b7506c7ea2e4a42e (commit)
via edd1fc79b0fe83383c8556b1b4c3c6d1d7f80bc1 (commit)
via 54dfbc97cc3cb0718adb8bea43c01cca97875f68 (commit)
via 946e3f2f0919355672e7527c98655a543b0b817f (commit)
via 0b5dda12e6840ed1725906f7dda8d9747a055ed6 (commit)
via add9f35b016d091ede3feef94fb56fb164d462a7 (commit)
via a3c776fbe73c0d20c56043193cd5691ee161ba7e (commit)
via 2709528b4902dfa3b06e3e8903c2ff2ba3ed9082 (commit)
via 2fa23d7c86f3efb506f6081287593d7a46a64894 (commit)
via 4399d2c02ef08b636bf6017675d9561dd7059884 (commit)
via 99f187fb3fd777440acb51fff371d20a80e6e1ed (commit)
via da6288d6299550973f090c34fe6066e71ea8fa59 (commit)
via 435a8d15e6ac18b2121df65d412738ebabaa6e51 (commit)
via 2b2645fd31cf881dbed0d2a1bc3f0013a57aa504 (commit)
via 706cbc61ff51ad32221c817ee54a2664b2a8052a (commit)
via 684349d20c47a4ff9e87127836ef6939f45d7f42 (commit)
via ff0d6034a58e5c9a53f3f3432db4535837fd393f (commit)
via b43f08627e733cbee903869000658047d0f5fcdd (commit)
via aad227e2cd9a98f0201f9f9d3185f6669d1245ec (commit)
via 4091cb47cacb8133897a4eb325e01e75238115d4 (commit)
via bfe7dd036bf3ead966e7a5c0097f96483a6c281e (commit)
via 2640d311ceb885414c56b41fb70fd64408b4f7d2 (commit)
via 9e6b1dd9f1bddac7599828fccc04199168208767 (commit)
via c0c2fee4087facc8dc4ba21a4227c48dd5c0e73a (commit)
via 33cf221808a7be08a7b5f6b7c5a11f5551c99e56 (commit)
via 85791dcce31edee3f3edd67379d5d229cde8870a (commit)
via 3d15551143c93f6916cb5f2f2a40cf9971975f89 (commit)
via 95413493cb7da1e5e2d62d5c40b505953df5c249 (commit)
via 9fbaac04629da0cd781c572baf9f26e433578587 (commit)
via edda2cbf387ab43ba91c5b29e8d74523991e4ff3 (commit)
via f889acbc51c551156918612285c1de647473f81b (commit)
via 9ca4f5badb78c287bf03d0b6987728cd1021a603 (commit)
via ab798ec6b8c797db5f7fab76e45fa4cbe8076898 (commit)
via 0ec98a5d1e2bfdf20ea8d972d04434a248bc028c (commit)
via a9bb3ed34e71f5f9d1d1b0bc3044555a0b3b932c (commit)
via 7ffad3678886886d9062a971551aeaccdb31e12f (commit)
via f3f014840a3f07f46c8ea081c0c688ea14a94d0d (commit)
via 43ea75e3feb2955e99038821dc794d666b17501c (commit)
via 714127ef49087634e7f6687424fdf041d18c3d0f (commit)
via 42425e53f71e262b5df90f70adecf58601d3c194 (commit)
via e350a696917a691d9db2acbae3b42781d702bd92 (commit)
via 5fda2d67bfacee177c2fe2fa854147d41d317d26 (commit)
via ac183801ca6da5c92c85f6a2f680737458b90abb (commit)
via a634548907e94afdbabd364b9dd850689d0ada15 (commit)
via 5b7daf155bfc0a86be019d720fdd9585e086ef3b (commit)
via f85d3c3c0b43fc1d95616e12a418cfdc75dc7588 (commit)
via 27b47da97ea6904155a71f4036e9abcc7e73021e (commit)
via 76bf247b8ed18366a67e1427daaea2d80b5b6fc0 (commit)
via 23d226b0cf2c9a22987b54b6d628a1728d33fb33 (commit)
via a4c01c69514289a6846ca8222212b007ed1121a7 (commit)
via c10a91ba936f355dffb827f92dbff648fd217621 (commit)
via 6741c5e725d90cc979b08d6337dd1cdce1ff59d1 (commit)
via e2fd09ac5d474bacba319545ec0a32eb6aa6feb0 (commit)
via cb38dfc98018b08ae373dc94ef2567034340ea83 (commit)
via e1c0c25689d8271cfc48fab0b8bbf64f3edfed2d (commit)
via 1352683f32f9e1e513033d03f66693d73b6b4d60 (commit)
via 60599f8795952d26395dd1ec896a061d5640d895 (commit)
via e332eb2eb562139916abdbf187a6abfbe7eef3a6 (commit)
via c1620fcf880e2c34a968c937dbdffcb41fa0e496 (commit)
via 635c9e865d7b9c45bfed2ff9862e6b05eafe123b (commit)
via 3f7290a2dd756d41f2edb0920ac495c955b52889 (commit)
via 8fa656d2bba66dce1141cef188b287f7f63edb05 (commit)
via 367de71830a03c041d5bec7e53d5bfb1b54b1aec (commit)
via 831db7847e9802f437dae163fad207abcaf1ff8c (commit)
via 42e766698ae1d4d712d78a0d1163f5be1f076429 (commit)
via 0b2eec2fb7cbe9580a382751086850b2aa4b6c00 (commit)
via 53796b0843896619a55dc8f7e45b8a98e6882ef6 (commit)
via 63d2554cf21c02362ab4c35e55ad03f90da003f2 (commit)
via ed75db63b6d794829bddf830fb5d9e66a009cefe (commit)
via 654b92ee4a85f050772487990c2de555c4fd9593 (commit)
via b31d086105a7802139e7e5faf268a95ad177bb19 (commit)
via 49687a4cfb879c66d2d18730b51a7a7c4fda1cb5 (commit)
via ea82e6058d43138810ce0a2787ba57c98a630dbf (commit)
via c13ce8e27965574289aa1529039d32bac751b1e5 (commit)
via 55c941abba55d5698829ab8bb4c69594dfebb086 (commit)
via 6c898dd23b9e2155684565922dcd7429d7def527 (commit)
via 739c34c4dd2e1b3afdab6fc91aab0ab09ae35838 (commit)
via a401440c6912713e6526f559fd825e305cd15061 (commit)
via 0ce35ad6f5d89d71bf578c7834dbe20658015628 (commit)
via e9c12542989ee9c69e58fcd9e1b1abfbf8d14c56 (commit)
via edbeee650287a4a36837e090eafed90a760bad83 (commit)
via b3b9e6ef95762dc662d625c2d70181461355a65e (commit)
via 470de948d2f4d7dc2c3468357e313e4a56edaf57 (commit)
via 5cd5e5b2b157badc31185fe8d9901903a7a98ad1 (commit)
via 43b35467e9601d4e519986373aecadcf612f61e7 (commit)
via dd8bc1a5c7b47318746a01cb0bce870949929382 (commit)
via 0871d2d5f08b57b1cb1f750cb7946b02a6d2433f (commit)
via 73e46b98a957c9c467e038ca545fb0b929bae6ea (commit)
via 149f7f01ba98ded05a3a90cc061dd94c71cae553 (commit)
via 3ccaa14528fd40bfec506e84afa97e37b35cd4bb (commit)
via 721fdb49a6983556508bebe51fdf26bd628d9a6a (commit)
via 17f05405289db3b58d472914988fccc641ce7c9d (commit)
via b3ef72cb4d9c90585710b335c57cf48ae8b21b5d (commit)
via bdb9e00148e7926a4813da193ad1bb2b4f44f300 (commit)
via 23d7ded1d71c5806482a328baf56117e01e1099a (commit)
via 6d46293a3d4ac814af9659c94fd0bced2fd2e532 (commit)
via d79e6a750a0ab87d6db18c1ecc4493223c57273a (commit)
via 07885ee12a5cd31574bfa60443b63c465a3baea9 (commit)
via d8e7ecbdc3fe2c1e2cd655bde3d66267e9c598c4 (commit)
via e22dbaec37501cca6f6f5b2567e1a836e2f55613 (commit)
via 336c286d70620d154ead77fffc99cd27594909ec (commit)
via 99fe6925af1747f53dfed0f8bb51f2e992814129 (commit)
via 1dc55a84e0e08fcd99a89b6b6b1945e3f9145579 (commit)
via 61b38e4bd6a37d6d57e7dc6ec3f4ada113f62e66 (commit)
via d13023c917dbd2ef99d3133948986959b78df753 (commit)
via 286e7ed97f89b8a076d57d88f06df5ea0a6aa7f0 (commit)
via 53de971ca197c8d33e4aff9056dd7d306da84aad (commit)
via f33f2c7dc8a660506da7654486b33c6a56e4c1ef (commit)
via 449a78c2e884799d2079b7cd3bc2bcc67e1913bb (commit)
via 0a6066cf7752f3e4fa7a60e077ee2014e8fc7bcf (commit)
via dc6ca2af492a421e3ba22ea9e50ad288891601a1 (commit)
via 5f9fd04e0a9e5ed2ce9cac73887a053ffa924b95 (commit)
via a291393068a45150313140d57972d9c914e21f21 (commit)
via 26bb29482f4a8ef4fd3d98e945e0a552808b18ec (commit)
via 7061e937cb164baf41b54e91045dfadd61f72ae9 (commit)
via 992c0c371aa4cf2ddc2d292c96de8d6cade18523 (commit)
via 0d0d6cf8590cf6c0d650599e8ed7463cf64200cf (commit)
via 80a475a35eb1d7501adb172ef7ec75042b34e9b6 (commit)
via 4517e557d1868dc200c3bbb37479f2ef2e337d80 (commit)
via e914650365d50646747a96ec3165b37035bc2323 (commit)
via eab22217d13032873e2350ac200d3e954de1568c (commit)
via 0bb875c5c41680a70b6cea0c47fb55baf86fb1b4 (commit)
via c1682daa78f2ab33c374572de98059b0b62027c7 (commit)
via eb1f2f8c3626e39a6186c9461a3bf8ed79dc4585 (commit)
via 77e76e79d1959ff52082f68232bfd37f9c6f6bd9 (commit)
via 7254f9706ca70ebaa06b2f78f867eba4330972b4 (commit)
via 15f4feebc5fca90c94a11804beecccea25a542b8 (commit)
via 3ab01dc116695a1a1d23b64ec2eee571f9a20545 (commit)
via dc3e573b42d333cbc3be748dab695bdb6ffc751c (commit)
via 339a4c30dbf35ab98408b0fe593e017a23667fad (commit)
via cf1dda17443ce0cf1cbf1376e2354fc549bb72b2 (commit)
via e05d87b3b57b0ca7dd39c401a71613c28ce4c200 (commit)
via 9125a0dac6f3206c4922e7e431ffe3a527001a88 (commit)
via 0af132c08e953b6d3d90c3dd5145e88aafc21839 (commit)
via b41dbee29d1b6a260a3f5c8e8be82686e5a412b5 (commit)
via 0884704fdc28aef65f7305875429e73a67310636 (commit)
via fcef363cd68854da1d371563efb6e33810570b73 (commit)
via ef8cdb2e6f492c43db106dcd6a19305a7afa6210 (commit)
via b520e11847a4ab78e2abda8c0b37fc776c3b930e (commit)
via 597a93df71c763205f5a021d35594b14db791a3f (commit)
via cf89e5c3669ca4b650a8eb51ed34904de31fe62e (commit)
via cc61ade8debee0bcfb996b7174e7989b7b175f30 (commit)
via 7017f79eb59b91d44a2fb4a50a8b329e720dacba (commit)
via bd643bd95f426ff539865fcbe1bae269c10d23ac (commit)
via 5fbfb9fc104bb62c6045c3f2347e2329e35e3526 (commit)
via f8e760589a90d71f220c3ed5d913e5c5188a37dd (commit)
via 5bbeb5fe10d3f783b191dbae685a45176f0e5591 (commit)
via 8f7c96920d3f856ba8996eb607ad07c4889b8958 (commit)
via 11f9d74053868d88d587371c21d8f248c7efff2d (commit)
via 7393aed0dab529f570284e2f667548ec32edcd69 (commit)
via 0f671ef73af8fe1b6903a4798b9fac128a4b405e (commit)
via 65b4e37acbacbd66c8bbee77d983c96345f7952a (commit)
via 0388c7b930955a11b38fbf1f596dd2daab37ea1c (commit)
via ba08c3eb048af1050a6fb09d521867f567c57ec7 (commit)
via 32ad7ab85410fee7d73fa3108c2055aebacf5685 (commit)
via ab9e83e024cf30d33211fbbf7142aecff11ccfa1 (commit)
via 0c8f844cb82f198c277eb10da5fc9dd415989e76 (commit)
via 3370ba5f04c543b00d86400828530e4e513be368 (commit)
via 19dbdc6bfa1bfbf5b455f28b317f22b9b9ba4dcf (commit)
via cc8c5a02f0f4318b336756882b1947e4b615419a (commit)
via c9d94c2ebb68b6b679f03dc7eabebfcd39136def (commit)
via 907d73f79973efc84af526719471f924eac33c8f (commit)
via 2c51e49c16147f43c5c89b748f9e3afc51d73626 (commit)
via 3a36e1ad241a0326001755ef59d7d433ab5a594d (commit)
via f6eda2c2737ec3e40f165b485491bcfc0dcf8eed (commit)
via e95fcc7d8b9b6b58ae1a04ff889bcf62c0c0b15b (commit)
via 418e5bcb1bce1fe37d588a3e7c683a1a40d078f0 (commit)
via 5feba83f888d840e3d7e5f6eaa90ab6e9c9f2efa (commit)
via aa57155d18f8cbb33b5090c5ea4bae349abf4db2 (commit)
via c3f213e924c6d801b58cbe2a7b829dd8fd5c3e1c (commit)
via 5ffc3e69c5078d1d990b3e6a0e583ea9835b8d7d (commit)
via 7196b9a2e5a3ebc393a1810f6c7d841a00b50844 (commit)
via 25eea8840e0330167eaf024b0c70e8dcb6f476d0 (commit)
via ab1cf8a673faf7674f6ec038216d529c54af0328 (commit)
via ff061d79783f18e387c70c06864b9e0c99f622d9 (commit)
via a9101801f5914adabfdba937a507c82bb69b58f8 (commit)
via 9dd4eca870fe1da8f43f06e7f8c35dd1dcca35cb (commit)
via c684dedd517ba56eb12d5791ba9e95ec0ed29cdc (commit)
via f1934087cdc173f3009bc8c5bf95c9f1e16de56a (commit)
via 422fa5bd3bbe6810b63be44a4cc003bfd5111590 (commit)
via a012eb513c8b355dbd2e4bf156ef8842e66f6b2c (commit)
via 73593ce402689f356ecef978901188586e4d1d3a (commit)
via 3e891de892ac1ee1cb0cb6cd474c22f4dcc02d74 (commit)
via 614635d7bf816a2df1d8491ad89c565fc58104da (commit)
via 75171838eaee9c433b217295354d79ef27a70e65 (commit)
via a9c083a35a68f231ba4d570ccd911997beb9b136 (commit)
via fed1a3a896297d72260d05da1ef1e235bb491d47 (commit)
via 055cf9bac1bfcf4cd3d32388121e4df9dbfb852c (commit)
via fe9d219b9b58f8a821b0c7239d8463a004a5b088 (commit)
via ef43007b281b1cb326d5a2ed42642d8319c7804c (commit)
via 93b5e3bbebc4642c75ca77f39d86aa7428baa3f5 (commit)
via 980cab7ce06f5f5d271ffcbdc60bec34a31d1478 (commit)
via 2f82b3bd2e9358c1fc408c56a80720021dc8904a (commit)
via 5a4bde372b27d4d4275904067666d4ad8aeef821 (commit)
This update added new revisions after undoing existing revisions. That is
to say, the old revision is not a strict subset of the new revision. This
situation occurs when you --force push a change and generate a repository
containing something like this:
* -- * -- B -- O -- O -- O (a418f09eb1f4c9b4a7673f4ba7d486559ad9e33d)
\
N -- N -- N (74223ffb73bdfb0f32d04c9f84c99edb945cb59d)
When this happens we assume that you've already had alert emails for all
of the O revisions, and so we here report only the revisions in the N
branch from the common base, B.
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 74223ffb73bdfb0f32d04c9f84c99edb945cb59d
Author: Sandro Santilli <strk at keybit.net>
Date: Fri Sep 19 09:26:56 2014 +0200
Switch from tinyxml to tinyxml2
diff --git a/tests/xmltester/Makefile.am b/tests/xmltester/Makefile.am
index b631260..eef563a 100644
--- a/tests/xmltester/Makefile.am
+++ b/tests/xmltester/Makefile.am
@@ -123,12 +123,8 @@ SimpleWKTTester_LDADD = $(LIBS)
XMLTester_SOURCES = \
XMLTester.cpp \
XMLTester.h \
- tinyxml/tinyxml.h \
- tinyxml/tinyxml.cpp \
- tinyxml/tinystr.h \
- tinyxml/tinystr.cpp \
- tinyxml/tinyxmlerror.cpp \
- tinyxml/tinyxmlparser.cpp \
+ tinyxml2/tinyxml2.h \
+ tinyxml2/tinyxml2.cpp \
BufferResultMatcher.h \
BufferResultMatcher.cpp \
SingleSidedBufferResultMatcher.h \
diff --git a/tests/xmltester/XMLTester.cpp b/tests/xmltester/XMLTester.cpp
index 8ffba8b..1e7f17d 100644
--- a/tests/xmltester/XMLTester.cpp
+++ b/tests/xmltester/XMLTester.cpp
@@ -136,38 +136,45 @@ const char * getIndent( unsigned int numIndents )
-void dump_to_stdout( const TiXmlNode * pParent, unsigned int indent = 0 )
+void dump_to_stdout( const tinyxml2::XMLNode * pParent, unsigned int indent = 0 )
{
if ( !pParent ) return;
- const TiXmlText *pText;
+ const tinyxml2::XMLText *pText;
+#if 0
int t = pParent->Type();
+#endif
printf( "%s", getIndent( indent));
+ tinyxml2::XMLPrinter printer;
+ pParent->Accept(&printer);
+
+#if 0
+
switch ( t )
{
- case TiXmlNode::DOCUMENT:
+ case tinyxml2::XMLNode::DOCUMENT:
printf( "Document" );
break;
- case TiXmlNode::ELEMENT:
+ case tinyxml2::XMLNode::ELEMENT:
printf( "Element \"%s\"", pParent->Value() );
break;
- case TiXmlNode::COMMENT:
+ case tinyxml2::XMLNode::COMMENT:
printf( "Comment: \"%s\"", pParent->Value());
break;
- case TiXmlNode::UNKNOWN:
+ case tinyxml2::XMLNode::UNKNOWN:
printf( "Unknown" );
break;
- case TiXmlNode::TEXT:
+ case tinyxml2::XMLNode::TEXT:
pText = pParent->ToText();
printf( "Text: [%s]", pText->Value() );
break;
- case TiXmlNode::DECLARATION:
+ case tinyxml2::XMLNode::DECLARATION:
printf( "Declaration" );
break;
default:
@@ -175,12 +182,13 @@ void dump_to_stdout( const TiXmlNode * pParent, unsigned int indent = 0 )
}
printf( "\n" );
- const TiXmlNode * pChild;
+ const tinyxml2::XMLNode * pChild;
for ( pChild = pParent->FirstChild(); pChild != nullptr; pChild = pChild->NextSibling())
{
dump_to_stdout( pChild, indent+2 );
}
+#endif
}
}
@@ -429,16 +437,17 @@ XMLTester::run(const std::string &source)
caseCount=0;
- if ( ! xml.LoadFile(source.c_str()) )
+ tinyxml2::XMLError e = xml.LoadFile(source.c_str());
+ if ( e )
{
std::stringstream err;
- err << "Could not load " << source << ": " << xml.ErrorDesc();
+ err << "Could not load " << source << ": " << e << std::endl;
throw runtime_error(err.str());
}
//dump_to_stdout(&xml);
- const TiXmlNode* node = xml.FirstChild("run");
+ const tinyxml2::XMLNode* node = xml.FirstChildElement("run");
if ( ! node )
throw(runtime_error("Document has no childs"));
@@ -463,7 +472,7 @@ XMLTester::resetCounters()
}
void
-XMLTester::parseRun(const TiXmlNode* node)
+XMLTester::parseRun(const tinyxml2::XMLNode* node)
{
using geos::geom::PrecisionModel;
@@ -472,7 +481,7 @@ XMLTester::parseRun(const TiXmlNode* node)
//dump_to_stdout(node);
// Look for precisionModel element
- const TiXmlElement* el = node->FirstChildElement("precisionModel");
+ const tinyxml2::XMLElement* el = node->FirstChildElement("precisionModel");
if ( el ) parsePrecisionModel(el);
else pm.reset(new PrecisionModel());
@@ -507,10 +516,10 @@ XMLTester::parseRun(const TiXmlNode* node)
wkbreader.reset(new io::WKBReader(*factory));
wkbwriter.reset(new io::WKBWriter());
- const TiXmlNode* casenode;
- for ( casenode = node->FirstChild("case");
+ const tinyxml2::XMLNode* casenode;
+ for ( casenode = node->FirstChildElement("case");
casenode;
- casenode = casenode->NextSibling("case") )
+ casenode = casenode->NextSiblingElement("case") )
{
try {
parseCase(casenode);
@@ -522,7 +531,7 @@ XMLTester::parseRun(const TiXmlNode* node)
}
void
-XMLTester::parsePrecisionModel(const TiXmlElement* el)
+XMLTester::parsePrecisionModel(const tinyxml2::XMLElement* el)
{
using geos::geom::PrecisionModel;
@@ -643,7 +652,7 @@ XMLTester::trimBlanks(const std::string &in)
}
void
-XMLTester::parseCase(const TiXmlNode* node)
+XMLTester::parseCase(const tinyxml2::XMLNode* node)
{
assert(node);
@@ -658,7 +667,7 @@ XMLTester::parseCase(const TiXmlNode* node)
//dump_to_stdout(node);
curr_case_desc.clear();
- const TiXmlNode* txt = node->FirstChild("desc");
+ const tinyxml2::XMLNode* txt = node->FirstChildElement("desc");
if ( txt ) {
txt = txt->FirstChild();
if ( txt ) curr_case_desc = trimBlanks(txt->Value());
@@ -668,12 +677,12 @@ XMLTester::parseCase(const TiXmlNode* node)
try {
- const TiXmlNode *el = node->FirstChild("a");
+ const tinyxml2::XMLNode *el = node->FirstChildElement("a");
geomAin = el->FirstChild()->Value();
geomAin = trimBlanks(geomAin);
gA = parseGeometry(geomAin, "Geometry A");
- if ( nullptr != (el = node->FirstChild("b")) )
+ if ( nullptr != (el = node->FirstChildElement("b")) )
{
geomBin = el->FirstChild()->Value();
geomBin = trimBlanks(geomBin);
@@ -702,10 +711,10 @@ XMLTester::parseCase(const TiXmlNode* node)
++caseCount;
testCount=0;
- const TiXmlNode* testnode;
- for ( testnode = node->FirstChild("test");
+ const tinyxml2::XMLNode* testnode;
+ for ( testnode = node->FirstChildElement("test");
testnode;
- testnode = testnode->NextSibling("test") )
+ testnode = testnode->NextSiblingElement("test") )
{
parseTest(testnode);
}
@@ -741,7 +750,7 @@ XMLTester::printGeom(const geom::Geometry *g)
}
void
-XMLTester::parseTest(const TiXmlNode* node)
+XMLTester::parseTest(const tinyxml2::XMLNode* node)
{
using namespace operation::overlay;
@@ -757,12 +766,12 @@ XMLTester::parseTest(const TiXmlNode* node)
++testCount;
- const TiXmlNode* opnode = node->FirstChild("op");
+ const tinyxml2::XMLNode* opnode = node->FirstChildElement("op");
if ( ! opnode ) throw(runtime_error("case has no op"));
//dump_to_stdout(opnode);
- const TiXmlElement* opel = opnode->ToElement();
+ const tinyxml2::XMLElement* opel = opnode->ToElement();
const char* tmp = opel->Attribute("name");
if ( tmp ) opName = tmp;
@@ -779,7 +788,7 @@ XMLTester::parseTest(const TiXmlNode* node)
tmp = opel->Attribute("arg4");
if ( tmp ) opArg4 = tmp;
- const TiXmlNode* resnode = opnode->FirstChild();
+ const tinyxml2::XMLNode* resnode = opnode->FirstChild();
if ( ! resnode )
{
std::stringstream tmp;
diff --git a/tests/xmltester/XMLTester.h b/tests/xmltester/XMLTester.h
index 1b0db32..e780721 100644
--- a/tests/xmltester/XMLTester.h
+++ b/tests/xmltester/XMLTester.h
@@ -18,7 +18,7 @@
#include <geos/geom/GeometryFactory.h>
#include <geos/geom/PrecisionModel.h>
#include <geos/profiler.h>
-#include "tinyxml/tinyxml.h"
+#include "tinyxml2/tinyxml2.h"
using namespace geos;
@@ -35,10 +35,10 @@ private:
PRED
};
- void parsePrecisionModel(const TiXmlElement* el);
- void parseRun(const TiXmlNode* node);
- void parseCase(const TiXmlNode* node);
- void parseTest(const TiXmlNode* node);
+ void parsePrecisionModel(const tinyxml2::XMLElement* el);
+ void parseRun(const tinyxml2::XMLNode* node);
+ void parseCase(const tinyxml2::XMLNode* node);
+ void parseTest(const tinyxml2::XMLNode* node);
void runPredicates(const geom::Geometry *a, const geom::Geometry *b);
geom::Geometry *parseGeometry(const std::string &in, const char* label="parsed");
static std::string trimBlanks(const std::string &in);
@@ -57,7 +57,7 @@ private:
std::unique_ptr<io::WKTWriter> wktwriter;
std::unique_ptr<io::WKBReader> wkbreader;
std::unique_ptr<io::WKBWriter> wkbwriter;
- TiXmlDocument xml;
+ tinyxml2::XMLDocument xml;
int verbose;
int test_predicates;
diff --git a/tests/xmltester/tinyxml2/README b/tests/xmltester/tinyxml2/README
new file mode 100644
index 0000000..7e40f48
--- /dev/null
+++ b/tests/xmltester/tinyxml2/README
@@ -0,0 +1 @@
+Code imported from https://github.com/leethomason/tinyxml2
diff --git a/tests/xmltester/tinyxml2/tinyxml2.cpp b/tests/xmltester/tinyxml2/tinyxml2.cpp
new file mode 100755
index 0000000..8297159
--- /dev/null
+++ b/tests/xmltester/tinyxml2/tinyxml2.cpp
@@ -0,0 +1,2244 @@
+/*
+Original code by Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+#include "tinyxml2.h"
+
+#include <new> // yes, this one new style header, is in the Android SDK.
+# ifdef ANDROID_NDK
+# include <stddef.h>
+#else
+# include <cstddef>
+#endif
+
+static const char LINE_FEED = (char)0x0a; // all line endings are normalized to LF
+static const char LF = LINE_FEED;
+static const char CARRIAGE_RETURN = (char)0x0d; // CR gets filtered out
+static const char CR = CARRIAGE_RETURN;
+static const char SINGLE_QUOTE = '\'';
+static const char DOUBLE_QUOTE = '\"';
+
+// Bunch of unicode info at:
+// http://www.unicode.org/faq/utf_bom.html
+// ef bb bf (Microsoft "lead bytes") - designates UTF-8
+
+static const unsigned char TIXML_UTF_LEAD_0 = 0xefU;
+static const unsigned char TIXML_UTF_LEAD_1 = 0xbbU;
+static const unsigned char TIXML_UTF_LEAD_2 = 0xbfU;
+
+namespace tinyxml2
+{
+
+struct Entity {
+ const char* pattern;
+ int length;
+ char value;
+};
+
+static const int NUM_ENTITIES = 5;
+static const Entity entities[NUM_ENTITIES] = {
+ { "quot", 4, DOUBLE_QUOTE },
+ { "amp", 3, '&' },
+ { "apos", 4, SINGLE_QUOTE },
+ { "lt", 2, '<' },
+ { "gt", 2, '>' }
+};
+
+
+StrPair::~StrPair()
+{
+ Reset();
+}
+
+
+void StrPair::Reset()
+{
+ if ( _flags & NEEDS_DELETE ) {
+ delete [] _start;
+ }
+ _flags = 0;
+ _start = 0;
+ _end = 0;
+}
+
+
+void StrPair::SetStr( const char* str, int flags )
+{
+ Reset();
+ size_t len = strlen( str );
+ _start = new char[ len+1 ];
+ memcpy( _start, str, len+1 );
+ _end = _start + len;
+ _flags = flags | NEEDS_DELETE;
+}
+
+
+char* StrPair::ParseText( char* p, const char* endTag, int strFlags )
+{
+ TIXMLASSERT( endTag && *endTag );
+
+ char* start = p;
+ char endChar = *endTag;
+ size_t length = strlen( endTag );
+
+ // Inner loop of text parsing.
+ while ( *p ) {
+ if ( *p == endChar && strncmp( p, endTag, length ) == 0 ) {
+ Set( start, p, strFlags );
+ return p + length;
+ }
+ ++p;
+ }
+ return 0;
+}
+
+
+char* StrPair::ParseName( char* p )
+{
+ char* start = p;
+
+ if ( !start || !(*start) ) {
+ return 0;
+ }
+
+ while( *p && ( p == start ? XMLUtil::IsNameStartChar( *p ) : XMLUtil::IsNameChar( *p ) )) {
+ ++p;
+ }
+
+ if ( p > start ) {
+ Set( start, p, 0 );
+ return p;
+ }
+ return 0;
+}
+
+
+void StrPair::CollapseWhitespace()
+{
+ // Adjusting _start would cause undefined behavior on delete[]
+ TIXMLASSERT( ( _flags & NEEDS_DELETE ) == 0 );
+ // Trim leading space.
+ _start = XMLUtil::SkipWhiteSpace( _start );
+
+ if ( _start && *_start ) {
+ char* p = _start; // the read pointer
+ char* q = _start; // the write pointer
+
+ while( *p ) {
+ if ( XMLUtil::IsWhiteSpace( *p )) {
+ p = XMLUtil::SkipWhiteSpace( p );
+ if ( *p == 0 ) {
+ break; // don't write to q; this trims the trailing space.
+ }
+ *q = ' ';
+ ++q;
+ }
+ *q = *p;
+ ++q;
+ ++p;
+ }
+ *q = 0;
+ }
+}
+
+
+const char* StrPair::GetStr()
+{
+ if ( _flags & NEEDS_FLUSH ) {
+ *_end = 0;
+ _flags ^= NEEDS_FLUSH;
+
+ if ( _flags ) {
+ char* p = _start; // the read pointer
+ char* q = _start; // the write pointer
+
+ while( p < _end ) {
+ if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == CR ) {
+ // CR-LF pair becomes LF
+ // CR alone becomes LF
+ // LF-CR becomes LF
+ if ( *(p+1) == LF ) {
+ p += 2;
+ }
+ else {
+ ++p;
+ }
+ *q++ = LF;
+ }
+ else if ( (_flags & NEEDS_NEWLINE_NORMALIZATION) && *p == LF ) {
+ if ( *(p+1) == CR ) {
+ p += 2;
+ }
+ else {
+ ++p;
+ }
+ *q++ = LF;
+ }
+ else if ( (_flags & NEEDS_ENTITY_PROCESSING) && *p == '&' ) {
+ // Entities handled by tinyXML2:
+ // - special entities in the entity table [in/out]
+ // - numeric character reference [in]
+ // 中 or 中
+
+ if ( *(p+1) == '#' ) {
+ const int buflen = 10;
+ char buf[buflen] = { 0 };
+ int len = 0;
+ p = const_cast<char*>( XMLUtil::GetCharacterRef( p, buf, &len ) );
+ TIXMLASSERT( 0 <= len && len <= buflen );
+ TIXMLASSERT( q + len <= p );
+ memcpy( q, buf, len );
+ q += len;
+ }
+ else {
+ int i=0;
+ for(; i<NUM_ENTITIES; ++i ) {
+ if ( strncmp( p+1, entities[i].pattern, entities[i].length ) == 0
+ && *(p+entities[i].length+1) == ';' ) {
+ // Found an entity convert;
+ *q = entities[i].value;
+ ++q;
+ p += entities[i].length + 2;
+ break;
+ }
+ }
+ if ( i == NUM_ENTITIES ) {
+ // fixme: treat as error?
+ ++p;
+ ++q;
+ }
+ }
+ }
+ else {
+ *q = *p;
+ ++p;
+ ++q;
+ }
+ }
+ *q = 0;
+ }
+ // The loop below has plenty going on, and this
+ // is a less useful mode. Break it out.
+ if ( _flags & COLLAPSE_WHITESPACE ) {
+ CollapseWhitespace();
+ }
+ _flags = (_flags & NEEDS_DELETE);
+ }
+ return _start;
+}
+
+
+
+
+// --------- XMLUtil ----------- //
+
+const char* XMLUtil::ReadBOM( const char* p, bool* bom )
+{
+ *bom = false;
+ const unsigned char* pu = reinterpret_cast<const unsigned char*>(p);
+ // Check for BOM:
+ if ( *(pu+0) == TIXML_UTF_LEAD_0
+ && *(pu+1) == TIXML_UTF_LEAD_1
+ && *(pu+2) == TIXML_UTF_LEAD_2 ) {
+ *bom = true;
+ p += 3;
+ }
+ return p;
+}
+
+
+void XMLUtil::ConvertUTF32ToUTF8( unsigned long input, char* output, int* length )
+{
+ const unsigned long BYTE_MASK = 0xBF;
+ const unsigned long BYTE_MARK = 0x80;
+ const unsigned long FIRST_BYTE_MARK[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+ if (input < 0x80) {
+ *length = 1;
+ }
+ else if ( input < 0x800 ) {
+ *length = 2;
+ }
+ else if ( input < 0x10000 ) {
+ *length = 3;
+ }
+ else if ( input < 0x200000 ) {
+ *length = 4;
+ }
+ else {
+ *length = 0; // This code won't covert this correctly anyway.
+ return;
+ }
+
+ output += *length;
+
+ // Scary scary fall throughs.
+ switch (*length) {
+ case 4:
+ --output;
+ *output = (char)((input | BYTE_MARK) & BYTE_MASK);
+ input >>= 6;
+ case 3:
+ --output;
+ *output = (char)((input | BYTE_MARK) & BYTE_MASK);
+ input >>= 6;
+ case 2:
+ --output;
+ *output = (char)((input | BYTE_MARK) & BYTE_MASK);
+ input >>= 6;
+ case 1:
+ --output;
+ *output = (char)(input | FIRST_BYTE_MARK[*length]);
+ default:
+ break;
+ }
+}
+
+
+const char* XMLUtil::GetCharacterRef( const char* p, char* value, int* length )
+{
+ // Presume an entity, and pull it out.
+ *length = 0;
+
+ if ( *(p+1) == '#' && *(p+2) ) {
+ unsigned long ucs = 0;
+ ptrdiff_t delta = 0;
+ unsigned mult = 1;
+
+ if ( *(p+2) == 'x' ) {
+ // Hexadecimal.
+ if ( !*(p+3) ) {
+ return 0;
+ }
+
+ const char* q = p+3;
+ q = strchr( q, ';' );
+
+ if ( !q || !*q ) {
+ return 0;
+ }
+
+ delta = q-p;
+ --q;
+
+ while ( *q != 'x' ) {
+ if ( *q >= '0' && *q <= '9' ) {
+ ucs += mult * (*q - '0');
+ }
+ else if ( *q >= 'a' && *q <= 'f' ) {
+ ucs += mult * (*q - 'a' + 10);
+ }
+ else if ( *q >= 'A' && *q <= 'F' ) {
+ ucs += mult * (*q - 'A' + 10 );
+ }
+ else {
+ return 0;
+ }
+ mult *= 16;
+ --q;
+ }
+ }
+ else {
+ // Decimal.
+ if ( !*(p+2) ) {
+ return 0;
+ }
+
+ const char* q = p+2;
+ q = strchr( q, ';' );
+
+ if ( !q || !*q ) {
+ return 0;
+ }
+
+ delta = q-p;
+ --q;
+
+ while ( *q != '#' ) {
+ if ( *q >= '0' && *q <= '9' ) {
+ ucs += mult * (*q - '0');
+ }
+ else {
+ return 0;
+ }
+ mult *= 10;
+ --q;
+ }
+ }
+ // convert the UCS to UTF-8
+ ConvertUTF32ToUTF8( ucs, value, length );
+ return p + delta + 1;
+ }
+ return p+1;
+}
+
+
+void XMLUtil::ToStr( int v, char* buffer, int bufferSize )
+{
+ TIXML_SNPRINTF( buffer, bufferSize, "%d", v );
+}
+
+
+void XMLUtil::ToStr( unsigned v, char* buffer, int bufferSize )
+{
+ TIXML_SNPRINTF( buffer, bufferSize, "%u", v );
+}
+
+
+void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
+{
+ TIXML_SNPRINTF( buffer, bufferSize, "%d", v ? 1 : 0 );
+}
+
+/*
+ ToStr() of a number is a very tricky topic.
+ https://github.com/leethomason/tinyxml2/issues/106
+*/
+void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
+{
+ TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );
+}
+
+
+void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
+{
+ TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );
+}
+
+
+bool XMLUtil::ToInt( const char* str, int* value )
+{
+ if ( TIXML_SSCANF( str, "%d", value ) == 1 ) {
+ return true;
+ }
+ return false;
+}
+
+bool XMLUtil::ToUnsigned( const char* str, unsigned *value )
+{
+ if ( TIXML_SSCANF( str, "%u", value ) == 1 ) {
+ return true;
+ }
+ return false;
+}
+
+bool XMLUtil::ToBool( const char* str, bool* value )
+{
+ int ival = 0;
+ if ( ToInt( str, &ival )) {
+ *value = (ival==0) ? false : true;
+ return true;
+ }
+ if ( StringEqual( str, "true" ) ) {
+ *value = true;
+ return true;
+ }
+ else if ( StringEqual( str, "false" ) ) {
+ *value = false;
+ return true;
+ }
+ return false;
+}
+
+
+bool XMLUtil::ToFloat( const char* str, float* value )
+{
+ if ( TIXML_SSCANF( str, "%f", value ) == 1 ) {
+ return true;
+ }
+ return false;
+}
+
+bool XMLUtil::ToDouble( const char* str, double* value )
+{
+ if ( TIXML_SSCANF( str, "%lf", value ) == 1 ) {
+ return true;
+ }
+ return false;
+}
+
+
+char* XMLDocument::Identify( char* p, XMLNode** node )
+{
+ XMLNode* returnNode = 0;
+ char* start = p;
+ p = XMLUtil::SkipWhiteSpace( p );
+ if( !p || !*p ) {
+ return p;
+ }
+
+ // What is this thing?
+ // These strings define the matching patters:
+ static const char* xmlHeader = { "<?" };
+ static const char* commentHeader = { "<!--" };
+ static const char* dtdHeader = { "<!" };
+ static const char* cdataHeader = { "<![CDATA[" };
+ static const char* elementHeader = { "<" }; // and a header for everything else; check last.
+
+ static const int xmlHeaderLen = 2;
+ static const int commentHeaderLen = 4;
+ static const int dtdHeaderLen = 2;
+ static const int cdataHeaderLen = 9;
+ static const int elementHeaderLen = 1;
+
+#if defined(_MSC_VER)
+#pragma warning ( push )
+#pragma warning ( disable : 4127 )
+#endif
+ TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLUnknown ) ); // use same memory pool
+ TIXMLASSERT( sizeof( XMLComment ) == sizeof( XMLDeclaration ) ); // use same memory pool
+#if defined(_MSC_VER)
+#pragma warning (pop)
+#endif
+ if ( XMLUtil::StringEqual( p, xmlHeader, xmlHeaderLen ) ) {
+ returnNode = new (_commentPool.Alloc()) XMLDeclaration( this );
+ returnNode->_memPool = &_commentPool;
+ p += xmlHeaderLen;
+ }
+ else if ( XMLUtil::StringEqual( p, commentHeader, commentHeaderLen ) ) {
+ returnNode = new (_commentPool.Alloc()) XMLComment( this );
+ returnNode->_memPool = &_commentPool;
+ p += commentHeaderLen;
+ }
+ else if ( XMLUtil::StringEqual( p, cdataHeader, cdataHeaderLen ) ) {
+ XMLText* text = new (_textPool.Alloc()) XMLText( this );
+ returnNode = text;
+ returnNode->_memPool = &_textPool;
+ p += cdataHeaderLen;
+ text->SetCData( true );
+ }
+ else if ( XMLUtil::StringEqual( p, dtdHeader, dtdHeaderLen ) ) {
+ returnNode = new (_commentPool.Alloc()) XMLUnknown( this );
+ returnNode->_memPool = &_commentPool;
+ p += dtdHeaderLen;
+ }
+ else if ( XMLUtil::StringEqual( p, elementHeader, elementHeaderLen ) ) {
+ returnNode = new (_elementPool.Alloc()) XMLElement( this );
+ returnNode->_memPool = &_elementPool;
+ p += elementHeaderLen;
+ }
+ else {
+ returnNode = new (_textPool.Alloc()) XMLText( this );
+ returnNode->_memPool = &_textPool;
+ p = start; // Back it up, all the text counts.
+ }
+
+ *node = returnNode;
+ return p;
+}
+
+
+bool XMLDocument::Accept( XMLVisitor* visitor ) const
+{
+ if ( visitor->VisitEnter( *this ) ) {
+ for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
+ if ( !node->Accept( visitor ) ) {
+ break;
+ }
+ }
+ }
+ return visitor->VisitExit( *this );
+}
+
+
+// --------- XMLNode ----------- //
+
+XMLNode::XMLNode( XMLDocument* doc ) :
+ _document( doc ),
+ _parent( 0 ),
+ _firstChild( 0 ), _lastChild( 0 ),
+ _prev( 0 ), _next( 0 ),
+ _memPool( 0 )
+{
+}
+
+
+XMLNode::~XMLNode()
+{
+ DeleteChildren();
+ if ( _parent ) {
+ _parent->Unlink( this );
+ }
+}
+
+const char* XMLNode::Value() const
+{
+ return _value.GetStr();
+}
+
+void XMLNode::SetValue( const char* str, bool staticMem )
+{
+ if ( staticMem ) {
+ _value.SetInternedStr( str );
+ }
+ else {
+ _value.SetStr( str );
+ }
+}
+
+
+void XMLNode::DeleteChildren()
+{
+ while( _firstChild ) {
+ XMLNode* node = _firstChild;
+ Unlink( node );
+
+ DeleteNode( node );
+ }
+ _firstChild = _lastChild = 0;
+}
+
+
+void XMLNode::Unlink( XMLNode* child )
+{
+ if ( child == _firstChild ) {
+ _firstChild = _firstChild->_next;
+ }
+ if ( child == _lastChild ) {
+ _lastChild = _lastChild->_prev;
+ }
+
+ if ( child->_prev ) {
+ child->_prev->_next = child->_next;
+ }
+ if ( child->_next ) {
+ child->_next->_prev = child->_prev;
+ }
+ child->_parent = 0;
+}
+
+
+void XMLNode::DeleteChild( XMLNode* node )
+{
+ TIXMLASSERT( node->_parent == this );
+ DeleteNode( node );
+}
+
+
+XMLNode* XMLNode::InsertEndChild( XMLNode* addThis )
+{
+ if (addThis->_document != _document)
+ return 0;
+
+ if (addThis->_parent)
+ addThis->_parent->Unlink( addThis );
+ else
+ addThis->_memPool->SetTracked();
+
+ if ( _lastChild ) {
+ TIXMLASSERT( _firstChild );
+ TIXMLASSERT( _lastChild->_next == 0 );
+ _lastChild->_next = addThis;
+ addThis->_prev = _lastChild;
+ _lastChild = addThis;
+
+ addThis->_next = 0;
+ }
+ else {
+ TIXMLASSERT( _firstChild == 0 );
+ _firstChild = _lastChild = addThis;
+
+ addThis->_prev = 0;
+ addThis->_next = 0;
+ }
+ addThis->_parent = this;
+ return addThis;
+}
+
+
+XMLNode* XMLNode::InsertFirstChild( XMLNode* addThis )
+{
+ if (addThis->_document != _document)
+ return 0;
+
+ if (addThis->_parent)
+ addThis->_parent->Unlink( addThis );
+ else
+ addThis->_memPool->SetTracked();
+
+ if ( _firstChild ) {
+ TIXMLASSERT( _lastChild );
+ TIXMLASSERT( _firstChild->_prev == 0 );
+
+ _firstChild->_prev = addThis;
+ addThis->_next = _firstChild;
+ _firstChild = addThis;
+
+ addThis->_prev = 0;
+ }
+ else {
+ TIXMLASSERT( _lastChild == 0 );
+ _firstChild = _lastChild = addThis;
+
+ addThis->_prev = 0;
+ addThis->_next = 0;
+ }
+ addThis->_parent = this;
+ return addThis;
+}
+
+
+XMLNode* XMLNode::InsertAfterChild( XMLNode* afterThis, XMLNode* addThis )
+{
+ if (addThis->_document != _document)
+ return 0;
+
+ TIXMLASSERT( afterThis->_parent == this );
+
+ if ( afterThis->_parent != this ) {
+ return 0;
+ }
+
+ if ( afterThis->_next == 0 ) {
+ // The last node or the only node.
+ return InsertEndChild( addThis );
+ }
+ if (addThis->_parent)
+ addThis->_parent->Unlink( addThis );
+ else
+ addThis->_memPool->SetTracked();
+ addThis->_prev = afterThis;
+ addThis->_next = afterThis->_next;
+ afterThis->_next->_prev = addThis;
+ afterThis->_next = addThis;
+ addThis->_parent = this;
+ return addThis;
+}
+
+
+
+
+const XMLElement* XMLNode::FirstChildElement( const char* value ) const
+{
+ for( XMLNode* node=_firstChild; node; node=node->_next ) {
+ XMLElement* element = node->ToElement();
+ if ( element ) {
+ if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {
+ return element;
+ }
+ }
+ }
+ return 0;
+}
+
+
+const XMLElement* XMLNode::LastChildElement( const char* value ) const
+{
+ for( XMLNode* node=_lastChild; node; node=node->_prev ) {
+ XMLElement* element = node->ToElement();
+ if ( element ) {
+ if ( !value || XMLUtil::StringEqual( element->Name(), value ) ) {
+ return element;
+ }
+ }
+ }
+ return 0;
+}
+
+
+const XMLElement* XMLNode::NextSiblingElement( const char* value ) const
+{
+ for( XMLNode* node=this->_next; node; node = node->_next ) {
+ const XMLElement* element = node->ToElement();
+ if ( element
+ && (!value || XMLUtil::StringEqual( value, node->Value() ))) {
+ return element;
+ }
+ }
+ return 0;
+}
+
+
+const XMLElement* XMLNode::PreviousSiblingElement( const char* value ) const
+{
+ for( XMLNode* node=_prev; node; node = node->_prev ) {
+ const XMLElement* element = node->ToElement();
+ if ( element
+ && (!value || XMLUtil::StringEqual( value, node->Value() ))) {
+ return element;
+ }
+ }
+ return 0;
+}
+
+
+char* XMLNode::ParseDeep( char* p, StrPair* parentEnd )
+{
+ // This is a recursive method, but thinking about it "at the current level"
+ // it is a pretty simple flat list:
+ // <foo/>
+ // <!-- comment -->
+ //
+ // With a special case:
+ // <foo>
+ // </foo>
+ // <!-- comment -->
+ //
+ // Where the closing element (/foo) *must* be the next thing after the opening
+ // element, and the names must match. BUT the tricky bit is that the closing
+ // element will be read by the child.
+ //
+ // 'endTag' is the end tag for this node, it is returned by a call to a child.
+ // 'parentEnd' is the end tag for the parent, which is filled in and returned.
+
+ while( p && *p ) {
+ XMLNode* node = 0;
+
+ p = _document->Identify( p, &node );
+ if ( p == 0 || node == 0 ) {
+ break;
+ }
+
+ StrPair endTag;
+ p = node->ParseDeep( p, &endTag );
+ if ( !p ) {
+ DeleteNode( node );
+ node = 0;
+ if ( !_document->Error() ) {
+ _document->SetError( XML_ERROR_PARSING, 0, 0 );
+ }
+ break;
+ }
+
+ XMLElement* ele = node->ToElement();
+ // We read the end tag. Return it to the parent.
+ if ( ele && ele->ClosingType() == XMLElement::CLOSING ) {
+ if ( parentEnd ) {
+ *parentEnd = static_cast<XMLElement*>(node)->_value;
+ }
+ node->_memPool->SetTracked(); // created and then immediately deleted.
+ DeleteNode( node );
+ return p;
+ }
+
+ // Handle an end tag returned to this level.
+ // And handle a bunch of annoying errors.
+ if ( ele ) {
+ if ( endTag.Empty() && ele->ClosingType() == XMLElement::OPEN ) {
+ _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );
+ p = 0;
+ }
+ else if ( !endTag.Empty() && ele->ClosingType() != XMLElement::OPEN ) {
+ _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );
+ p = 0;
+ }
+ else if ( !endTag.Empty() ) {
+ if ( !XMLUtil::StringEqual( endTag.GetStr(), node->Value() )) {
+ _document->SetError( XML_ERROR_MISMATCHED_ELEMENT, node->Value(), 0 );
+ p = 0;
+ }
+ }
+ }
+ if ( p == 0 ) {
+ DeleteNode( node );
+ node = 0;
+ }
+ if ( node ) {
+ this->InsertEndChild( node );
+ }
+ }
+ return 0;
+}
+
+void XMLNode::DeleteNode( XMLNode* node )
+{
+ if ( node == 0 ) {
+ return;
+ }
+ MemPool* pool = node->_memPool;
+ node->~XMLNode();
+ pool->Free( node );
+}
+
+// --------- XMLText ---------- //
+char* XMLText::ParseDeep( char* p, StrPair* )
+{
+ const char* start = p;
+ if ( this->CData() ) {
+ p = _value.ParseText( p, "]]>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
+ if ( !p ) {
+ _document->SetError( XML_ERROR_PARSING_CDATA, start, 0 );
+ }
+ return p;
+ }
+ else {
+ int flags = _document->ProcessEntities() ? StrPair::TEXT_ELEMENT : StrPair::TEXT_ELEMENT_LEAVE_ENTITIES;
+ if ( _document->WhitespaceMode() == COLLAPSE_WHITESPACE ) {
+ flags |= StrPair::COLLAPSE_WHITESPACE;
+ }
+
+ p = _value.ParseText( p, "<", flags );
+ if ( !p ) {
+ _document->SetError( XML_ERROR_PARSING_TEXT, start, 0 );
+ }
+ if ( p && *p ) {
+ return p-1;
+ }
+ }
+ return 0;
+}
+
+
+XMLNode* XMLText::ShallowClone( XMLDocument* doc ) const
+{
+ if ( !doc ) {
+ doc = _document;
+ }
+ XMLText* text = doc->NewText( Value() ); // fixme: this will always allocate memory. Intern?
+ text->SetCData( this->CData() );
+ return text;
+}
+
+
+bool XMLText::ShallowEqual( const XMLNode* compare ) const
+{
+ return ( compare->ToText() && XMLUtil::StringEqual( compare->ToText()->Value(), Value() ));
+}
+
+
+bool XMLText::Accept( XMLVisitor* visitor ) const
+{
+ return visitor->Visit( *this );
+}
+
+
+// --------- XMLComment ---------- //
+
+XMLComment::XMLComment( XMLDocument* doc ) : XMLNode( doc )
+{
+}
+
+
+XMLComment::~XMLComment()
+{
+}
+
+
+char* XMLComment::ParseDeep( char* p, StrPair* )
+{
+ // Comment parses as text.
+ const char* start = p;
+ p = _value.ParseText( p, "-->", StrPair::COMMENT );
+ if ( p == 0 ) {
+ _document->SetError( XML_ERROR_PARSING_COMMENT, start, 0 );
+ }
+ return p;
+}
+
+
+XMLNode* XMLComment::ShallowClone( XMLDocument* doc ) const
+{
+ if ( !doc ) {
+ doc = _document;
+ }
+ XMLComment* comment = doc->NewComment( Value() ); // fixme: this will always allocate memory. Intern?
+ return comment;
+}
+
+
+bool XMLComment::ShallowEqual( const XMLNode* compare ) const
+{
+ const XMLComment* comment = compare->ToComment();
+ return ( comment && XMLUtil::StringEqual( comment->Value(), Value() ));
+}
+
+
+bool XMLComment::Accept( XMLVisitor* visitor ) const
+{
+ return visitor->Visit( *this );
+}
+
+
+// --------- XMLDeclaration ---------- //
+
+XMLDeclaration::XMLDeclaration( XMLDocument* doc ) : XMLNode( doc )
+{
+}
+
+
+XMLDeclaration::~XMLDeclaration()
+{
+ //printf( "~XMLDeclaration\n" );
+}
+
+
+char* XMLDeclaration::ParseDeep( char* p, StrPair* )
+{
+ // Declaration parses as text.
+ const char* start = p;
+ p = _value.ParseText( p, "?>", StrPair::NEEDS_NEWLINE_NORMALIZATION );
+ if ( p == 0 ) {
+ _document->SetError( XML_ERROR_PARSING_DECLARATION, start, 0 );
+ }
+ return p;
+}
+
+
+XMLNode* XMLDeclaration::ShallowClone( XMLDocument* doc ) const
+{
+ if ( !doc ) {
+ doc = _document;
+ }
+ XMLDeclaration* dec = doc->NewDeclaration( Value() ); // fixme: this will always allocate memory. Intern?
+ return dec;
+}
+
+
+bool XMLDeclaration::ShallowEqual( const XMLNode* compare ) const
+{
+ const XMLDeclaration* declaration = compare->ToDeclaration();
+ return ( declaration && XMLUtil::StringEqual( declaration->Value(), Value() ));
+}
+
+
+
+bool XMLDeclaration::Accept( XMLVisitor* visitor ) const
+{
+ return visitor->Visit( *this );
+}
+
+// --------- XMLUnknown ---------- //
+
+XMLUnknown::XMLUnknown( XMLDocument* doc ) : XMLNode( doc )
+{
+}
+
+
+XMLUnknown::~XMLUnknown()
+{
+}
+
+
+char* XMLUnknown::ParseDeep( char* p, StrPair* )
+{
+ // Unknown parses as text.
+ const char* start = p;
+
+ p = _value.ParseText( p, ">", StrPair::NEEDS_NEWLINE_NORMALIZATION );
+ if ( !p ) {
+ _document->SetError( XML_ERROR_PARSING_UNKNOWN, start, 0 );
+ }
+ return p;
+}
+
+
+XMLNode* XMLUnknown::ShallowClone( XMLDocument* doc ) const
+{
+ if ( !doc ) {
+ doc = _document;
+ }
+ XMLUnknown* text = doc->NewUnknown( Value() ); // fixme: this will always allocate memory. Intern?
+ return text;
+}
+
+
+bool XMLUnknown::ShallowEqual( const XMLNode* compare ) const
+{
+ const XMLUnknown* unknown = compare->ToUnknown();
+ return ( unknown && XMLUtil::StringEqual( unknown->Value(), Value() ));
+}
+
+
+bool XMLUnknown::Accept( XMLVisitor* visitor ) const
+{
+ return visitor->Visit( *this );
+}
+
+// --------- XMLAttribute ---------- //
+
+const char* XMLAttribute::Name() const
+{
+ return _name.GetStr();
+}
+
+const char* XMLAttribute::Value() const
+{
+ return _value.GetStr();
+}
+
+char* XMLAttribute::ParseDeep( char* p, bool processEntities )
+{
+ // Parse using the name rules: bug fix, was using ParseText before
+ p = _name.ParseName( p );
+ if ( !p || !*p ) {
+ return 0;
+ }
+
+ // Skip white space before =
+ p = XMLUtil::SkipWhiteSpace( p );
+ if ( !p || *p != '=' ) {
+ return 0;
+ }
+
+ ++p; // move up to opening quote
+ p = XMLUtil::SkipWhiteSpace( p );
+ if ( *p != '\"' && *p != '\'' ) {
+ return 0;
+ }
+
+ char endTag[2] = { *p, 0 };
+ ++p; // move past opening quote
+
+ p = _value.ParseText( p, endTag, processEntities ? StrPair::ATTRIBUTE_VALUE : StrPair::ATTRIBUTE_VALUE_LEAVE_ENTITIES );
+ return p;
+}
+
+
+void XMLAttribute::SetName( const char* n )
+{
+ _name.SetStr( n );
+}
+
+
+XMLError XMLAttribute::QueryIntValue( int* value ) const
+{
+ if ( XMLUtil::ToInt( Value(), value )) {
+ return XML_NO_ERROR;
+ }
+ return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryUnsignedValue( unsigned int* value ) const
+{
+ if ( XMLUtil::ToUnsigned( Value(), value )) {
+ return XML_NO_ERROR;
+ }
+ return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryBoolValue( bool* value ) const
+{
+ if ( XMLUtil::ToBool( Value(), value )) {
+ return XML_NO_ERROR;
+ }
+ return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryFloatValue( float* value ) const
+{
+ if ( XMLUtil::ToFloat( Value(), value )) {
+ return XML_NO_ERROR;
+ }
+ return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+XMLError XMLAttribute::QueryDoubleValue( double* value ) const
+{
+ if ( XMLUtil::ToDouble( Value(), value )) {
+ return XML_NO_ERROR;
+ }
+ return XML_WRONG_ATTRIBUTE_TYPE;
+}
+
+
+void XMLAttribute::SetAttribute( const char* v )
+{
+ _value.SetStr( v );
+}
+
+
+void XMLAttribute::SetAttribute( int v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ _value.SetStr( buf );
+}
+
+
+void XMLAttribute::SetAttribute( unsigned v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ _value.SetStr( buf );
+}
+
+
+void XMLAttribute::SetAttribute( bool v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ _value.SetStr( buf );
+}
+
+void XMLAttribute::SetAttribute( double v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ _value.SetStr( buf );
+}
+
+void XMLAttribute::SetAttribute( float v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ _value.SetStr( buf );
+}
+
+
+// --------- XMLElement ---------- //
+XMLElement::XMLElement( XMLDocument* doc ) : XMLNode( doc ),
+ _closingType( 0 ),
+ _rootAttribute( 0 )
+{
+}
+
+
+XMLElement::~XMLElement()
+{
+ while( _rootAttribute ) {
+ XMLAttribute* next = _rootAttribute->_next;
+ DeleteAttribute( _rootAttribute );
+ _rootAttribute = next;
+ }
+}
+
+
+XMLAttribute* XMLElement::FindAttribute( const char* name )
+{
+ for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
+ if ( XMLUtil::StringEqual( a->Name(), name ) ) {
+ return a;
+ }
+ }
+ return 0;
+}
+
+
+const XMLAttribute* XMLElement::FindAttribute( const char* name ) const
+{
+ for( XMLAttribute* a = _rootAttribute; a; a = a->_next ) {
+ if ( XMLUtil::StringEqual( a->Name(), name ) ) {
+ return a;
+ }
+ }
+ return 0;
+}
+
+
+const char* XMLElement::Attribute( const char* name, const char* value ) const
+{
+ const XMLAttribute* a = FindAttribute( name );
+ if ( !a ) {
+ return 0;
+ }
+ if ( !value || XMLUtil::StringEqual( a->Value(), value )) {
+ return a->Value();
+ }
+ return 0;
+}
+
+
+const char* XMLElement::GetText() const
+{
+ if ( FirstChild() && FirstChild()->ToText() ) {
+ return FirstChild()->ToText()->Value();
+ }
+ return 0;
+}
+
+
+void XMLElement::SetText( const char* inText )
+{
+ if ( FirstChild() && FirstChild()->ToText() )
+ FirstChild()->SetValue( inText );
+ else {
+ XMLText* theText = GetDocument()->NewText( inText );
+ InsertFirstChild( theText );
+ }
+}
+
+
+void XMLElement::SetText( int v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ SetText( buf );
+}
+
+
+void XMLElement::SetText( unsigned v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ SetText( buf );
+}
+
+
+void XMLElement::SetText( bool v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ SetText( buf );
+}
+
+
+void XMLElement::SetText( float v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ SetText( buf );
+}
+
+
+void XMLElement::SetText( double v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ SetText( buf );
+}
+
+
+XMLError XMLElement::QueryIntText( int* ival ) const
+{
+ if ( FirstChild() && FirstChild()->ToText() ) {
+ const char* t = FirstChild()->ToText()->Value();
+ if ( XMLUtil::ToInt( t, ival ) ) {
+ return XML_SUCCESS;
+ }
+ return XML_CAN_NOT_CONVERT_TEXT;
+ }
+ return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryUnsignedText( unsigned* uval ) const
+{
+ if ( FirstChild() && FirstChild()->ToText() ) {
+ const char* t = FirstChild()->ToText()->Value();
+ if ( XMLUtil::ToUnsigned( t, uval ) ) {
+ return XML_SUCCESS;
+ }
+ return XML_CAN_NOT_CONVERT_TEXT;
+ }
+ return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryBoolText( bool* bval ) const
+{
+ if ( FirstChild() && FirstChild()->ToText() ) {
+ const char* t = FirstChild()->ToText()->Value();
+ if ( XMLUtil::ToBool( t, bval ) ) {
+ return XML_SUCCESS;
+ }
+ return XML_CAN_NOT_CONVERT_TEXT;
+ }
+ return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryDoubleText( double* dval ) const
+{
+ if ( FirstChild() && FirstChild()->ToText() ) {
+ const char* t = FirstChild()->ToText()->Value();
+ if ( XMLUtil::ToDouble( t, dval ) ) {
+ return XML_SUCCESS;
+ }
+ return XML_CAN_NOT_CONVERT_TEXT;
+ }
+ return XML_NO_TEXT_NODE;
+}
+
+
+XMLError XMLElement::QueryFloatText( float* fval ) const
+{
+ if ( FirstChild() && FirstChild()->ToText() ) {
+ const char* t = FirstChild()->ToText()->Value();
+ if ( XMLUtil::ToFloat( t, fval ) ) {
+ return XML_SUCCESS;
+ }
+ return XML_CAN_NOT_CONVERT_TEXT;
+ }
+ return XML_NO_TEXT_NODE;
+}
+
+
+
+XMLAttribute* XMLElement::FindOrCreateAttribute( const char* name )
+{
+ XMLAttribute* last = 0;
+ XMLAttribute* attrib = 0;
+ for( attrib = _rootAttribute;
+ attrib;
+ last = attrib, attrib = attrib->_next ) {
+ if ( XMLUtil::StringEqual( attrib->Name(), name ) ) {
+ break;
+ }
+ }
+ if ( !attrib ) {
+ attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
+ attrib->_memPool = &_document->_attributePool;
+ if ( last ) {
+ last->_next = attrib;
+ }
+ else {
+ _rootAttribute = attrib;
+ }
+ attrib->SetName( name );
+ attrib->_memPool->SetTracked(); // always created and linked.
+ }
+ return attrib;
+}
+
+
+void XMLElement::DeleteAttribute( const char* name )
+{
+ XMLAttribute* prev = 0;
+ for( XMLAttribute* a=_rootAttribute; a; a=a->_next ) {
+ if ( XMLUtil::StringEqual( name, a->Name() ) ) {
+ if ( prev ) {
+ prev->_next = a->_next;
+ }
+ else {
+ _rootAttribute = a->_next;
+ }
+ DeleteAttribute( a );
+ break;
+ }
+ prev = a;
+ }
+}
+
+
+char* XMLElement::ParseAttributes( char* p )
+{
+ const char* start = p;
+ XMLAttribute* prevAttribute = 0;
+
+ // Read the attributes.
+ while( p ) {
+ p = XMLUtil::SkipWhiteSpace( p );
+ if ( !p || !(*p) ) {
+ _document->SetError( XML_ERROR_PARSING_ELEMENT, start, Name() );
+ return 0;
+ }
+
+ // attribute.
+ if (XMLUtil::IsNameStartChar( *p ) ) {
+ XMLAttribute* attrib = new (_document->_attributePool.Alloc() ) XMLAttribute();
+ attrib->_memPool = &_document->_attributePool;
+ attrib->_memPool->SetTracked();
+
+ p = attrib->ParseDeep( p, _document->ProcessEntities() );
+ if ( !p || Attribute( attrib->Name() ) ) {
+ DeleteAttribute( attrib );
+ _document->SetError( XML_ERROR_PARSING_ATTRIBUTE, start, p );
+ return 0;
+ }
+ // There is a minor bug here: if the attribute in the source xml
+ // document is duplicated, it will not be detected and the
+ // attribute will be doubly added. However, tracking the 'prevAttribute'
+ // avoids re-scanning the attribute list. Preferring performance for
+ // now, may reconsider in the future.
+ if ( prevAttribute ) {
+ prevAttribute->_next = attrib;
+ }
+ else {
+ _rootAttribute = attrib;
+ }
+ prevAttribute = attrib;
+ }
+ // end of the tag
+ else if ( *p == '/' && *(p+1) == '>' ) {
+ _closingType = CLOSED;
+ return p+2; // done; sealed element.
+ }
+ // end of the tag
+ else if ( *p == '>' ) {
+ ++p;
+ break;
+ }
+ else {
+ _document->SetError( XML_ERROR_PARSING_ELEMENT, start, p );
+ return 0;
+ }
+ }
+ return p;
+}
+
+void XMLElement::DeleteAttribute( XMLAttribute* attribute )
+{
+ if ( attribute == 0 ) {
+ return;
+ }
+ MemPool* pool = attribute->_memPool;
+ attribute->~XMLAttribute();
+ pool->Free( attribute );
+}
+
+//
+// <ele></ele>
+// <ele>foo<b>bar</b></ele>
+//
+char* XMLElement::ParseDeep( char* p, StrPair* strPair )
+{
+ // Read the element name.
+ p = XMLUtil::SkipWhiteSpace( p );
+ if ( !p ) {
+ return 0;
+ }
+
+ // The closing element is the </element> form. It is
+ // parsed just like a regular element then deleted from
+ // the DOM.
+ if ( *p == '/' ) {
+ _closingType = CLOSING;
+ ++p;
+ }
+
+ p = _value.ParseName( p );
+ if ( _value.Empty() ) {
+ return 0;
+ }
+
+ p = ParseAttributes( p );
+ if ( !p || !*p || _closingType ) {
+ return p;
+ }
+
+ p = XMLNode::ParseDeep( p, strPair );
+ return p;
+}
+
+
+
+XMLNode* XMLElement::ShallowClone( XMLDocument* doc ) const
+{
+ if ( !doc ) {
+ doc = _document;
+ }
+ XMLElement* element = doc->NewElement( Value() ); // fixme: this will always allocate memory. Intern?
+ for( const XMLAttribute* a=FirstAttribute(); a; a=a->Next() ) {
+ element->SetAttribute( a->Name(), a->Value() ); // fixme: this will always allocate memory. Intern?
+ }
+ return element;
+}
+
+
+bool XMLElement::ShallowEqual( const XMLNode* compare ) const
+{
+ const XMLElement* other = compare->ToElement();
+ if ( other && XMLUtil::StringEqual( other->Value(), Value() )) {
+
+ const XMLAttribute* a=FirstAttribute();
+ const XMLAttribute* b=other->FirstAttribute();
+
+ while ( a && b ) {
+ if ( !XMLUtil::StringEqual( a->Value(), b->Value() ) ) {
+ return false;
+ }
+ a = a->Next();
+ b = b->Next();
+ }
+ if ( a || b ) {
+ // different count
+ return false;
+ }
+ return true;
+ }
+ return false;
+}
+
+
+bool XMLElement::Accept( XMLVisitor* visitor ) const
+{
+ if ( visitor->VisitEnter( *this, _rootAttribute ) ) {
+ for ( const XMLNode* node=FirstChild(); node; node=node->NextSibling() ) {
+ if ( !node->Accept( visitor ) ) {
+ break;
+ }
+ }
+ }
+ return visitor->VisitExit( *this );
+}
+
+
+// --------- XMLDocument ----------- //
+
+// Warning: List must match 'enum XMLError'
+const char* XMLDocument::_errorNames[XML_ERROR_COUNT] = {
+ "XML_SUCCESS",
+ "XML_NO_ATTRIBUTE",
+ "XML_WRONG_ATTRIBUTE_TYPE",
+ "XML_ERROR_FILE_NOT_FOUND",
+ "XML_ERROR_FILE_COULD_NOT_BE_OPENED",
+ "XML_ERROR_FILE_READ_ERROR",
+ "XML_ERROR_ELEMENT_MISMATCH",
+ "XML_ERROR_PARSING_ELEMENT",
+ "XML_ERROR_PARSING_ATTRIBUTE",
+ "XML_ERROR_IDENTIFYING_TAG",
+ "XML_ERROR_PARSING_TEXT",
+ "XML_ERROR_PARSING_CDATA",
+ "XML_ERROR_PARSING_COMMENT",
+ "XML_ERROR_PARSING_DECLARATION",
+ "XML_ERROR_PARSING_UNKNOWN",
+ "XML_ERROR_EMPTY_DOCUMENT",
+ "XML_ERROR_MISMATCHED_ELEMENT",
+ "XML_ERROR_PARSING",
+ "XML_CAN_NOT_CONVERT_TEXT",
+ "XML_NO_TEXT_NODE"
+};
+
+
+XMLDocument::XMLDocument( bool processEntities, Whitespace whitespace ) :
+ XMLNode( 0 ),
+ _writeBOM( false ),
+ _processEntities( processEntities ),
+ _errorID( XML_NO_ERROR ),
+ _whitespace( whitespace ),
+ _errorStr1( 0 ),
+ _errorStr2( 0 ),
+ _charBuffer( 0 )
+{
+ _document = this; // avoid warning about 'this' in initializer list
+}
+
+
+XMLDocument::~XMLDocument()
+{
+ DeleteChildren();
+ delete [] _charBuffer;
+
+#if 0
+ _textPool.Trace( "text" );
+ _elementPool.Trace( "element" );
+ _commentPool.Trace( "comment" );
+ _attributePool.Trace( "attribute" );
+#endif
+
+#ifdef DEBUG
+ if ( Error() == false ) {
+ TIXMLASSERT( _elementPool.CurrentAllocs() == _elementPool.Untracked() );
+ TIXMLASSERT( _attributePool.CurrentAllocs() == _attributePool.Untracked() );
+ TIXMLASSERT( _textPool.CurrentAllocs() == _textPool.Untracked() );
+ TIXMLASSERT( _commentPool.CurrentAllocs() == _commentPool.Untracked() );
+ }
+#endif
+}
+
+
+void XMLDocument::Clear()
+{
+ DeleteChildren();
+
+ _errorID = XML_NO_ERROR;
+ _errorStr1 = 0;
+ _errorStr2 = 0;
+
+ delete [] _charBuffer;
+ _charBuffer = 0;
+}
+
+
+XMLElement* XMLDocument::NewElement( const char* name )
+{
+ XMLElement* ele = new (_elementPool.Alloc()) XMLElement( this );
+ ele->_memPool = &_elementPool;
+ ele->SetName( name );
+ return ele;
+}
+
+
+XMLComment* XMLDocument::NewComment( const char* str )
+{
+ XMLComment* comment = new (_commentPool.Alloc()) XMLComment( this );
+ comment->_memPool = &_commentPool;
+ comment->SetValue( str );
+ return comment;
+}
+
+
+XMLText* XMLDocument::NewText( const char* str )
+{
+ XMLText* text = new (_textPool.Alloc()) XMLText( this );
+ text->_memPool = &_textPool;
+ text->SetValue( str );
+ return text;
+}
+
+
+XMLDeclaration* XMLDocument::NewDeclaration( const char* str )
+{
+ XMLDeclaration* dec = new (_commentPool.Alloc()) XMLDeclaration( this );
+ dec->_memPool = &_commentPool;
+ dec->SetValue( str ? str : "xml version=\"1.0\" encoding=\"UTF-8\"" );
+ return dec;
+}
+
+
+XMLUnknown* XMLDocument::NewUnknown( const char* str )
+{
+ XMLUnknown* unk = new (_commentPool.Alloc()) XMLUnknown( this );
+ unk->_memPool = &_commentPool;
+ unk->SetValue( str );
+ return unk;
+}
+
+static FILE* callfopen( const char* filepath, const char* mode )
+{
+#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
+ FILE* fp = 0;
+ errno_t err = fopen_s( &fp, filepath, mode );
+ if ( err ) {
+ return 0;
+ }
+#else
+ FILE* fp = fopen( filepath, mode );
+#endif
+ return fp;
+}
+
+XMLError XMLDocument::LoadFile( const char* filename )
+{
+ Clear();
+ FILE* fp = callfopen( filename, "rb" );
+ if ( !fp ) {
+ SetError( XML_ERROR_FILE_NOT_FOUND, filename, 0 );
+ return _errorID;
+ }
+ LoadFile( fp );
+ fclose( fp );
+ return _errorID;
+}
+
+
+XMLError XMLDocument::LoadFile( FILE* fp )
+{
+ Clear();
+
+ fseek( fp, 0, SEEK_SET );
+ if ( fgetc( fp ) == EOF && ferror( fp ) != 0 ) {
+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+ return _errorID;
+ }
+
+ fseek( fp, 0, SEEK_END );
+ const long filelength = ftell( fp );
+ fseek( fp, 0, SEEK_SET );
+ if ( filelength == -1L ) {
+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+ return _errorID;
+ }
+
+ const size_t size = filelength;
+ if ( size == 0 ) {
+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+ return _errorID;
+ }
+
+ _charBuffer = new char[size+1];
+ size_t read = fread( _charBuffer, 1, size, fp );
+ if ( read != size ) {
+ SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+ return _errorID;
+ }
+
+ _charBuffer[size] = 0;
+
+ const char* p = _charBuffer;
+ p = XMLUtil::SkipWhiteSpace( p );
+ p = XMLUtil::ReadBOM( p, &_writeBOM );
+ if ( !p || !*p ) {
+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+ return _errorID;
+ }
+
+ ParseDeep( _charBuffer + (p-_charBuffer), 0 );
+ return _errorID;
+}
+
+
+XMLError XMLDocument::SaveFile( const char* filename, bool compact )
+{
+ FILE* fp = callfopen( filename, "w" );
+ if ( !fp ) {
+ SetError( XML_ERROR_FILE_COULD_NOT_BE_OPENED, filename, 0 );
+ return _errorID;
+ }
+ SaveFile(fp, compact);
+ fclose( fp );
+ return _errorID;
+}
+
+
+XMLError XMLDocument::SaveFile( FILE* fp, bool compact )
+{
+ XMLPrinter stream( fp, compact );
+ Print( &stream );
+ return _errorID;
+}
+
+
+XMLError XMLDocument::Parse( const char* p, size_t len )
+{
+ const char* start = p;
+ Clear();
+
+ if ( len == 0 || !p || !*p ) {
+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+ return _errorID;
+ }
+ if ( len == (size_t)(-1) ) {
+ len = strlen( p );
+ }
+ _charBuffer = new char[ len+1 ];
+ memcpy( _charBuffer, p, len );
+ _charBuffer[len] = 0;
+
+ p = XMLUtil::SkipWhiteSpace( p );
+ p = XMLUtil::ReadBOM( p, &_writeBOM );
+ if ( !p || !*p ) {
+ SetError( XML_ERROR_EMPTY_DOCUMENT, 0, 0 );
+ return _errorID;
+ }
+
+ ptrdiff_t delta = p - start; // skip initial whitespace, BOM, etc.
+ ParseDeep( _charBuffer+delta, 0 );
+ return _errorID;
+}
+
+
+void XMLDocument::Print( XMLPrinter* streamer ) const
+{
+ XMLPrinter stdStreamer( stdout );
+ if ( !streamer ) {
+ streamer = &stdStreamer;
+ }
+ Accept( streamer );
+}
+
+
+void XMLDocument::SetError( XMLError error, const char* str1, const char* str2 )
+{
+ _errorID = error;
+ _errorStr1 = str1;
+ _errorStr2 = str2;
+}
+
+const char* XMLDocument::ErrorName() const
+{
+ TIXMLASSERT(_errorID >= 0 && _errorID < XML_ERROR_COUNT );
+ return _errorNames[_errorID];
+}
+
+void XMLDocument::PrintError() const
+{
+ if ( _errorID ) {
+ static const int LEN = 20;
+ char buf1[LEN] = { 0 };
+ char buf2[LEN] = { 0 };
+
+ if ( _errorStr1 ) {
+ TIXML_SNPRINTF( buf1, LEN, "%s", _errorStr1 );
+ }
+ if ( _errorStr2 ) {
+ TIXML_SNPRINTF( buf2, LEN, "%s", _errorStr2 );
+ }
+
+ printf( "XMLDocument error id=%d '%s' str1=%s str2=%s\n",
+ _errorID, ErrorName(), buf1, buf2 );
+ }
+}
+
+
+XMLPrinter::XMLPrinter( FILE* file, bool compact, int depth ) :
+ _elementJustOpened( false ),
+ _firstElement( true ),
+ _fp( file ),
+ _depth( depth ),
+ _textDepth( -1 ),
+ _processEntities( true ),
+ _compactMode( compact )
+{
+ for( int i=0; i<ENTITY_RANGE; ++i ) {
+ _entityFlag[i] = false;
+ _restrictedEntityFlag[i] = false;
+ }
+ for( int i=0; i<NUM_ENTITIES; ++i ) {
+ TIXMLASSERT( entities[i].value < ENTITY_RANGE );
+ if ( entities[i].value < ENTITY_RANGE ) {
+ _entityFlag[ (int)entities[i].value ] = true;
+ }
+ }
+ _restrictedEntityFlag[(int)'&'] = true;
+ _restrictedEntityFlag[(int)'<'] = true;
+ _restrictedEntityFlag[(int)'>'] = true; // not required, but consistency is nice
+ _buffer.Push( 0 );
+}
+
+
+void XMLPrinter::Print( const char* format, ... )
+{
+ va_list va;
+ va_start( va, format );
+
+ if ( _fp ) {
+ vfprintf( _fp, format, va );
+ }
+ else {
+#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
+ #if defined(WINCE)
+ int len = 512;
+ do {
+ len = len*2;
+ char* str = new char[len]();
+ len = _vsnprintf(str, len, format, va);
+ delete[] str;
+ }while (len < 0);
+ #else
+ int len = _vscprintf( format, va );
+ #endif
+#else
+ int len = vsnprintf( 0, 0, format, va );
+#endif
+ // Close out and re-start the va-args
+ va_end( va );
+ va_start( va, format );
+ char* p = _buffer.PushArr( len ) - 1; // back up over the null terminator.
+#if defined(_MSC_VER) && (_MSC_VER >= 1400 )
+ #if defined(WINCE)
+ _vsnprintf( p, len+1, format, va );
+ #else
+ vsnprintf_s( p, len+1, _TRUNCATE, format, va );
+ #endif
+#else
+ vsnprintf( p, len+1, format, va );
+#endif
+ }
+ va_end( va );
+}
+
+
+void XMLPrinter::PrintSpace( int depth )
+{
+ for( int i=0; i<depth; ++i ) {
+ Print( " " );
+ }
+}
+
+
+void XMLPrinter::PrintString( const char* p, bool restricted )
+{
+ // Look for runs of bytes between entities to print.
+ const char* q = p;
+ const bool* flag = restricted ? _restrictedEntityFlag : _entityFlag;
+
+ if ( _processEntities ) {
+ while ( *q ) {
+ // Remember, char is sometimes signed. (How many times has that bitten me?)
+ if ( *q > 0 && *q < ENTITY_RANGE ) {
+ // Check for entities. If one is found, flush
+ // the stream up until the entity, write the
+ // entity, and keep looking.
+ if ( flag[(unsigned)(*q)] ) {
+ while ( p < q ) {
+ Print( "%c", *p );
+ ++p;
+ }
+ for( int i=0; i<NUM_ENTITIES; ++i ) {
+ if ( entities[i].value == *q ) {
+ Print( "&%s;", entities[i].pattern );
+ break;
+ }
+ }
+ ++p;
+ }
+ }
+ ++q;
+ }
+ }
+ // Flush the remaining string. This will be the entire
+ // string if an entity wasn't found.
+ if ( !_processEntities || (q-p > 0) ) {
+ Print( "%s", p );
+ }
+}
+
+
+void XMLPrinter::PushHeader( bool writeBOM, bool writeDec )
+{
+ if ( writeBOM ) {
+ static const unsigned char bom[] = { TIXML_UTF_LEAD_0, TIXML_UTF_LEAD_1, TIXML_UTF_LEAD_2, 0 };
+ Print( "%s", bom );
+ }
+ if ( writeDec ) {
+ PushDeclaration( "xml version=\"1.0\"" );
+ }
+}
+
+
+void XMLPrinter::OpenElement( const char* name, bool compactMode )
+{
+ if ( _elementJustOpened ) {
+ SealElement();
+ }
+ _stack.Push( name );
+
+ if ( _textDepth < 0 && !_firstElement && !compactMode ) {
+ Print( "\n" );
+ }
+ if ( !compactMode ) {
+ PrintSpace( _depth );
+ }
+
+ Print( "<%s", name );
+ _elementJustOpened = true;
+ _firstElement = false;
+ ++_depth;
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, const char* value )
+{
+ TIXMLASSERT( _elementJustOpened );
+ Print( " %s=\"", name );
+ PrintString( value, false );
+ Print( "\"" );
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, int v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ PushAttribute( name, buf );
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, unsigned v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ PushAttribute( name, buf );
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, bool v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ PushAttribute( name, buf );
+}
+
+
+void XMLPrinter::PushAttribute( const char* name, double v )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( v, buf, BUF_SIZE );
+ PushAttribute( name, buf );
+}
+
+
+void XMLPrinter::CloseElement( bool compactMode )
+{
+ --_depth;
+ const char* name = _stack.Pop();
+
+ if ( _elementJustOpened ) {
+ Print( "/>" );
+ }
+ else {
+ if ( _textDepth < 0 && !compactMode) {
+ Print( "\n" );
+ PrintSpace( _depth );
+ }
+ Print( "</%s>", name );
+ }
+
+ if ( _textDepth == _depth ) {
+ _textDepth = -1;
+ }
+ if ( _depth == 0 && !compactMode) {
+ Print( "\n" );
+ }
+ _elementJustOpened = false;
+}
+
+
+void XMLPrinter::SealElement()
+{
+ _elementJustOpened = false;
+ Print( ">" );
+}
+
+
+void XMLPrinter::PushText( const char* text, bool cdata )
+{
+ _textDepth = _depth-1;
+
+ if ( _elementJustOpened ) {
+ SealElement();
+ }
+ if ( cdata ) {
+ Print( "<![CDATA[" );
+ Print( "%s", text );
+ Print( "]]>" );
+ }
+ else {
+ PrintString( text, true );
+ }
+}
+
+void XMLPrinter::PushText( int value )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( value, buf, BUF_SIZE );
+ PushText( buf, false );
+}
+
+
+void XMLPrinter::PushText( unsigned value )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( value, buf, BUF_SIZE );
+ PushText( buf, false );
+}
+
+
+void XMLPrinter::PushText( bool value )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( value, buf, BUF_SIZE );
+ PushText( buf, false );
+}
+
+
+void XMLPrinter::PushText( float value )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( value, buf, BUF_SIZE );
+ PushText( buf, false );
+}
+
+
+void XMLPrinter::PushText( double value )
+{
+ char buf[BUF_SIZE];
+ XMLUtil::ToStr( value, buf, BUF_SIZE );
+ PushText( buf, false );
+}
+
+
+void XMLPrinter::PushComment( const char* comment )
+{
+ if ( _elementJustOpened ) {
+ SealElement();
+ }
+ if ( _textDepth < 0 && !_firstElement && !_compactMode) {
+ Print( "\n" );
+ PrintSpace( _depth );
+ }
+ _firstElement = false;
+ Print( "<!--%s-->", comment );
+}
+
+
+void XMLPrinter::PushDeclaration( const char* value )
+{
+ if ( _elementJustOpened ) {
+ SealElement();
+ }
+ if ( _textDepth < 0 && !_firstElement && !_compactMode) {
+ Print( "\n" );
+ PrintSpace( _depth );
+ }
+ _firstElement = false;
+ Print( "<?%s?>", value );
+}
+
+
+void XMLPrinter::PushUnknown( const char* value )
+{
+ if ( _elementJustOpened ) {
+ SealElement();
+ }
+ if ( _textDepth < 0 && !_firstElement && !_compactMode) {
+ Print( "\n" );
+ PrintSpace( _depth );
+ }
+ _firstElement = false;
+ Print( "<!%s>", value );
+}
+
+
+bool XMLPrinter::VisitEnter( const XMLDocument& doc )
+{
+ _processEntities = doc.ProcessEntities();
+ if ( doc.HasBOM() ) {
+ PushHeader( true, false );
+ }
+ return true;
+}
+
+
+bool XMLPrinter::VisitEnter( const XMLElement& element, const XMLAttribute* attribute )
+{
+ const XMLElement* parentElem = element.Parent()->ToElement();
+ bool compactMode = parentElem ? CompactMode(*parentElem) : _compactMode;
+ OpenElement( element.Name(), compactMode );
+ while ( attribute ) {
+ PushAttribute( attribute->Name(), attribute->Value() );
+ attribute = attribute->Next();
+ }
+ return true;
+}
+
+
+bool XMLPrinter::VisitExit( const XMLElement& element )
+{
+ CloseElement( CompactMode(element) );
+ return true;
+}
+
+
+bool XMLPrinter::Visit( const XMLText& text )
+{
+ PushText( text.Value(), text.CData() );
+ return true;
+}
+
+
+bool XMLPrinter::Visit( const XMLComment& comment )
+{
+ PushComment( comment.Value() );
+ return true;
+}
+
+bool XMLPrinter::Visit( const XMLDeclaration& declaration )
+{
+ PushDeclaration( declaration.Value() );
+ return true;
+}
+
+
+bool XMLPrinter::Visit( const XMLUnknown& unknown )
+{
+ PushUnknown( unknown.Value() );
+ return true;
+}
+
+} // namespace tinyxml2
+
diff --git a/tests/xmltester/tinyxml2/tinyxml2.h b/tests/xmltester/tinyxml2/tinyxml2.h
new file mode 100755
index 0000000..cfb2d65
--- /dev/null
+++ b/tests/xmltester/tinyxml2/tinyxml2.h
@@ -0,0 +1,2082 @@
+/*
+Original code by Lee Thomason (www.grinninglizard.com)
+
+This software is provided 'as-is', without any express or implied
+warranty. In no event will the authors be held liable for any
+damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any
+purpose, including commercial applications, and to alter it and
+redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must
+not claim that you wrote the original software. If you use this
+software in a product, an acknowledgment in the product documentation
+would be appreciated but is not required.
+
+
+2. Altered source versions must be plainly marked as such, and
+must not be misrepresented as being the original software.
+
+3. This notice may not be removed or altered from any source
+distribution.
+*/
+
+#ifndef TINYXML2_INCLUDED
+#define TINYXML2_INCLUDED
+
+#if defined(ANDROID_NDK) || defined(__BORLANDC__)
+# include <ctype.h>
+# include <limits.h>
+# include <stdio.h>
+# include <stdlib.h>
+# include <string.h>
+# include <stdarg.h>
+#else
+# include <cctype>
+# include <climits>
+# include <cstdio>
+# include <cstdlib>
+# include <cstring>
+# include <cstdarg>
+#endif
+
+/*
+ TODO: intern strings instead of allocation.
+*/
+/*
+ gcc:
+ g++ -Wall -DDEBUG tinyxml2.cpp xmltest.cpp -o gccxmltest.exe
+
+ Formatting, Artistic Style:
+ AStyle.exe --style=1tbs --indent-switches --break-closing-brackets --indent-preprocessor tinyxml2.cpp tinyxml2.h
+*/
+
+#if defined( _DEBUG ) || defined( DEBUG ) || defined (__DEBUG__)
+# ifndef DEBUG
+# define DEBUG
+# endif
+#endif
+
+#ifdef _MSC_VER
+# pragma warning(push)
+# pragma warning(disable: 4251)
+#endif
+
+#ifdef _WIN32
+# ifdef TINYXML2_EXPORT
+# define TINYXML2_LIB __declspec(dllexport)
+# elif defined(TINYXML2_IMPORT)
+# define TINYXML2_LIB __declspec(dllimport)
+# else
+# define TINYXML2_LIB
+# endif
+#else
+# define TINYXML2_LIB
+#endif
+
+
+#if defined(DEBUG)
+# if defined(_MSC_VER)
+# define TIXMLASSERT( x ) if ( !(x)) { __debugbreak(); } //if ( !(x)) WinDebugBreak()
+# elif defined (ANDROID_NDK)
+# include <android/log.h>
+# define TIXMLASSERT( x ) if ( !(x)) { __android_log_assert( "assert", "grinliz", "ASSERT in '%s' at %d.", __FILE__, __LINE__ ); }
+# else
+# include <assert.h>
+# define TIXMLASSERT assert
+# endif
+# else
+# define TIXMLASSERT( x ) {}
+#endif
+
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400 ) && (!defined WINCE)
+// Microsoft visual studio, version 2005 and higher.
+/*int _snprintf_s(
+ char *buffer,
+ size_t sizeOfBuffer,
+ size_t count,
+ const char *format [,
+ argument] ...
+);*/
+inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
+{
+ va_list va;
+ va_start( va, format );
+ int result = vsnprintf_s( buffer, size, _TRUNCATE, format, va );
+ va_end( va );
+ return result;
+}
+#define TIXML_SSCANF sscanf_s
+#elif defined WINCE
+#define TIXML_SNPRINTF _snprintf
+#define TIXML_SSCANF sscanf
+#else
+// GCC version 3 and higher
+//#warning( "Using sn* functions." )
+#define TIXML_SNPRINTF snprintf
+#define TIXML_SSCANF sscanf
+#endif
+
+/* Versioning, past 1.0.14:
+ http://semver.org/
+*/
+static const int TIXML2_MAJOR_VERSION = 2;
+static const int TIXML2_MINOR_VERSION = 2;
+static const int TIXML2_PATCH_VERSION = 0;
+
+namespace tinyxml2
+{
+class XMLDocument;
+class XMLElement;
+class XMLAttribute;
+class XMLComment;
+class XMLText;
+class XMLDeclaration;
+class XMLUnknown;
+class XMLPrinter;
+
+/*
+ A class that wraps strings. Normally stores the start and end
+ pointers into the XML file itself, and will apply normalization
+ and entity translation if actually read. Can also store (and memory
+ manage) a traditional char[]
+*/
+class StrPair
+{
+public:
+ enum {
+ NEEDS_ENTITY_PROCESSING = 0x01,
+ NEEDS_NEWLINE_NORMALIZATION = 0x02,
+ COLLAPSE_WHITESPACE = 0x04,
+
+ TEXT_ELEMENT = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+ TEXT_ELEMENT_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
+ ATTRIBUTE_NAME = 0,
+ ATTRIBUTE_VALUE = NEEDS_ENTITY_PROCESSING | NEEDS_NEWLINE_NORMALIZATION,
+ ATTRIBUTE_VALUE_LEAVE_ENTITIES = NEEDS_NEWLINE_NORMALIZATION,
+ COMMENT = NEEDS_NEWLINE_NORMALIZATION
+ };
+
+ StrPair() : _flags( 0 ), _start( 0 ), _end( 0 ) {}
+ ~StrPair();
+
+ void Set( char* start, char* end, int flags ) {
+ Reset();
+ _start = start;
+ _end = end;
+ _flags = flags | NEEDS_FLUSH;
+ }
+
+ const char* GetStr();
+
+ bool Empty() const {
+ return _start == _end;
+ }
+
+ void SetInternedStr( const char* str ) {
+ Reset();
+ _start = const_cast<char*>(str);
+ }
+
+ void SetStr( const char* str, int flags=0 );
+
+ char* ParseText( char* in, const char* endTag, int strFlags );
+ char* ParseName( char* in );
+
+private:
+ void Reset();
+ void CollapseWhitespace();
+
+ enum {
+ NEEDS_FLUSH = 0x100,
+ NEEDS_DELETE = 0x200
+ };
+
+ // After parsing, if *_end != 0, it can be set to zero.
+ int _flags;
+ char* _start;
+ char* _end;
+};
+
+
+/*
+ A dynamic array of Plain Old Data. Doesn't support constructors, etc.
+ Has a small initial memory pool, so that low or no usage will not
+ cause a call to new/delete
+*/
+template <class T, int INIT>
+class DynArray
+{
+public:
+ DynArray< T, INIT >() {
+ _mem = _pool;
+ _allocated = INIT;
+ _size = 0;
+ }
+
+ ~DynArray() {
+ if ( _mem != _pool ) {
+ delete [] _mem;
+ }
+ }
+
+ void Clear() {
+ _size = 0;
+ }
+
+ void Push( T t ) {
+ EnsureCapacity( _size+1 );
+ _mem[_size++] = t;
+ }
+
+ T* PushArr( int count ) {
+ EnsureCapacity( _size+count );
+ T* ret = &_mem[_size];
+ _size += count;
+ return ret;
+ }
+
+ T Pop() {
+ return _mem[--_size];
+ }
+
+ void PopArr( int count ) {
+ TIXMLASSERT( _size >= count );
+ _size -= count;
+ }
+
+ bool Empty() const {
+ return _size == 0;
+ }
+
+ T& operator[](int i) {
+ TIXMLASSERT( i>= 0 && i < _size );
+ return _mem[i];
+ }
+
+ const T& operator[](int i) const {
+ TIXMLASSERT( i>= 0 && i < _size );
+ return _mem[i];
+ }
+
+ const T& PeekTop() const {
+ TIXMLASSERT( _size > 0 );
+ return _mem[ _size - 1];
+ }
+
+ int Size() const {
+ return _size;
+ }
+
+ int Capacity() const {
+ return _allocated;
+ }
+
+ const T* Mem() const {
+ return _mem;
+ }
+
+ T* Mem() {
+ return _mem;
+ }
+
+private:
+ void EnsureCapacity( int cap ) {
+ if ( cap > _allocated ) {
+ int newAllocated = cap * 2;
+ T* newMem = new T[newAllocated];
+ memcpy( newMem, _mem, sizeof(T)*_size ); // warning: not using constructors, only works for PODs
+ if ( _mem != _pool ) {
+ delete [] _mem;
+ }
+ _mem = newMem;
+ _allocated = newAllocated;
+ }
+ }
+
+ T* _mem;
+ T _pool[INIT];
+ int _allocated; // objects allocated
+ int _size; // number objects in use
+};
+
+
+/*
+ Parent virtual class of a pool for fast allocation
+ and deallocation of objects.
+*/
+class MemPool
+{
+public:
+ MemPool() {}
+ virtual ~MemPool() {}
+
+ virtual int ItemSize() const = 0;
+ virtual void* Alloc() = 0;
+ virtual void Free( void* ) = 0;
+ virtual void SetTracked() = 0;
+};
+
+
+/*
+ Template child class to create pools of the correct type.
+*/
+template< int SIZE >
+class MemPoolT : public MemPool
+{
+public:
+ MemPoolT() : _root(0), _currentAllocs(0), _nAllocs(0), _maxAllocs(0), _nUntracked(0) {}
+ ~MemPoolT() {
+ // Delete the blocks.
+ for( int i=0; i<_blockPtrs.Size(); ++i ) {
+ delete _blockPtrs[i];
+ }
+ }
+
+ virtual int ItemSize() const {
+ return SIZE;
+ }
+ int CurrentAllocs() const {
+ return _currentAllocs;
+ }
+
+ virtual void* Alloc() {
+ if ( !_root ) {
+ // Need a new block.
+ Block* block = new Block();
+ _blockPtrs.Push( block );
+
+ for( int i=0; i<COUNT-1; ++i ) {
+ block->chunk[i].next = &block->chunk[i+1];
+ }
+ block->chunk[COUNT-1].next = 0;
+ _root = block->chunk;
+ }
+ void* result = _root;
+ _root = _root->next;
+
+ ++_currentAllocs;
+ if ( _currentAllocs > _maxAllocs ) {
+ _maxAllocs = _currentAllocs;
+ }
+ _nAllocs++;
+ _nUntracked++;
+ return result;
+ }
+ virtual void Free( void* mem ) {
+ if ( !mem ) {
+ return;
+ }
+ --_currentAllocs;
+ Chunk* chunk = static_cast<Chunk*>( mem );
+#ifdef DEBUG
+ memset( chunk, 0xfe, sizeof(Chunk) );
+#endif
+ chunk->next = _root;
+ _root = chunk;
+ }
+ void Trace( const char* name ) {
+ printf( "Mempool %s watermark=%d [%dk] current=%d size=%d nAlloc=%d blocks=%d\n",
+ name, _maxAllocs, _maxAllocs*SIZE/1024, _currentAllocs, SIZE, _nAllocs, _blockPtrs.Size() );
+ }
+
+ void SetTracked() {
+ _nUntracked--;
+ }
+
+ int Untracked() const {
+ return _nUntracked;
+ }
+
+ // This number is perf sensitive. 4k seems like a good tradeoff on my machine.
+ // The test file is large, 170k.
+ // Release: VS2010 gcc(no opt)
+ // 1k: 4000
+ // 2k: 4000
+ // 4k: 3900 21000
+ // 16k: 5200
+ // 32k: 4300
+ // 64k: 4000 21000
+ enum { COUNT = (4*1024)/SIZE }; // Some compilers do not accept to use COUNT in private part if COUNT is private
+
+private:
+ union Chunk {
+ Chunk* next;
+ char mem[SIZE];
+ };
+ struct Block {
+ Chunk chunk[COUNT];
+ };
+ DynArray< Block*, 10 > _blockPtrs;
+ Chunk* _root;
+
+ int _currentAllocs;
+ int _nAllocs;
+ int _maxAllocs;
+ int _nUntracked;
+};
+
+
+
+/**
+ Implements the interface to the "Visitor pattern" (see the Accept() method.)
+ If you call the Accept() method, it requires being passed a XMLVisitor
+ class to handle callbacks. For nodes that contain other nodes (Document, Element)
+ you will get called with a VisitEnter/VisitExit pair. Nodes that are always leafs
+ are simply called with Visit().
+
+ If you return 'true' from a Visit method, recursive parsing will continue. If you return
+ false, <b>no children of this node or its siblings</b> will be visited.
+
+ All flavors of Visit methods have a default implementation that returns 'true' (continue
+ visiting). You need to only override methods that are interesting to you.
+
+ Generally Accept() is called on the XMLDocument, although all nodes support visiting.
+
+ You should never change the document from a callback.
+
+ @sa XMLNode::Accept()
+*/
+class TINYXML2_LIB XMLVisitor
+{
+public:
+ virtual ~XMLVisitor() {}
+
+ /// Visit a document.
+ virtual bool VisitEnter( const XMLDocument& /*doc*/ ) {
+ return true;
+ }
+ /// Visit a document.
+ virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
+ return true;
+ }
+
+ /// Visit an element.
+ virtual bool VisitEnter( const XMLElement& /*element*/, const XMLAttribute* /*firstAttribute*/ ) {
+ return true;
+ }
+ /// Visit an element.
+ virtual bool VisitExit( const XMLElement& /*element*/ ) {
+ return true;
+ }
+
+ /// Visit a declaration.
+ virtual bool Visit( const XMLDeclaration& /*declaration*/ ) {
+ return true;
+ }
+ /// Visit a text node.
+ virtual bool Visit( const XMLText& /*text*/ ) {
+ return true;
+ }
+ /// Visit a comment node.
+ virtual bool Visit( const XMLComment& /*comment*/ ) {
+ return true;
+ }
+ /// Visit an unknown node.
+ virtual bool Visit( const XMLUnknown& /*unknown*/ ) {
+ return true;
+ }
+};
+
+// WARNING: must match XMLErrorNames[]
+enum XMLError {
+ XML_SUCCESS = 0,
+ XML_NO_ERROR = 0,
+ XML_NO_ATTRIBUTE,
+ XML_WRONG_ATTRIBUTE_TYPE,
+ XML_ERROR_FILE_NOT_FOUND,
+ XML_ERROR_FILE_COULD_NOT_BE_OPENED,
+ XML_ERROR_FILE_READ_ERROR,
+ XML_ERROR_ELEMENT_MISMATCH,
+ XML_ERROR_PARSING_ELEMENT,
+ XML_ERROR_PARSING_ATTRIBUTE,
+ XML_ERROR_IDENTIFYING_TAG,
+ XML_ERROR_PARSING_TEXT,
+ XML_ERROR_PARSING_CDATA,
+ XML_ERROR_PARSING_COMMENT,
+ XML_ERROR_PARSING_DECLARATION,
+ XML_ERROR_PARSING_UNKNOWN,
+ XML_ERROR_EMPTY_DOCUMENT,
+ XML_ERROR_MISMATCHED_ELEMENT,
+ XML_ERROR_PARSING,
+ XML_CAN_NOT_CONVERT_TEXT,
+ XML_NO_TEXT_NODE,
+
+ XML_ERROR_COUNT
+};
+
+
+/*
+ Utility functionality.
+*/
+class XMLUtil
+{
+public:
+ // Anything in the high order range of UTF-8 is assumed to not be whitespace. This isn't
+ // correct, but simple, and usually works.
+ static const char* SkipWhiteSpace( const char* p ) {
+ while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<const unsigned char*>(p) ) ) {
+ ++p;
+ }
+ return p;
+ }
+ static char* SkipWhiteSpace( char* p ) {
+ while( !IsUTF8Continuation(*p) && isspace( *reinterpret_cast<unsigned char*>(p) ) ) {
+ ++p;
+ }
+ return p;
+ }
+ static bool IsWhiteSpace( char p ) {
+ return !IsUTF8Continuation(p) && isspace( static_cast<unsigned char>(p) );
+ }
+
+ inline static bool IsNameStartChar( unsigned char ch ) {
+ return ( ( ch < 128 ) ? isalpha( ch ) : 1 )
+ || ch == ':'
+ || ch == '_';
+ }
+
+ inline static bool IsNameChar( unsigned char ch ) {
+ return IsNameStartChar( ch )
+ || isdigit( ch )
+ || ch == '.'
+ || ch == '-';
+ }
+
+ inline static bool StringEqual( const char* p, const char* q, int nChar=INT_MAX ) {
+ int n = 0;
+ if ( p == q ) {
+ return true;
+ }
+ while( *p && *q && *p == *q && n<nChar ) {
+ ++p;
+ ++q;
+ ++n;
+ }
+ if ( (n == nChar) || ( *p == 0 && *q == 0 ) ) {
+ return true;
+ }
+ return false;
+ }
+
+ inline static int IsUTF8Continuation( const char p ) {
+ return p & 0x80;
+ }
+
+ static const char* ReadBOM( const char* p, bool* hasBOM );
+ // p is the starting location,
+ // the UTF-8 value of the entity will be placed in value, and length filled in.
+ static const char* GetCharacterRef( const char* p, char* value, int* length );
+ static void ConvertUTF32ToUTF8( unsigned long input, char* output, int* length );
+
+ // converts primitive types to strings
+ static void ToStr( int v, char* buffer, int bufferSize );
+ static void ToStr( unsigned v, char* buffer, int bufferSize );
+ static void ToStr( bool v, char* buffer, int bufferSize );
+ static void ToStr( float v, char* buffer, int bufferSize );
+ static void ToStr( double v, char* buffer, int bufferSize );
+
+ // converts strings to primitive types
+ static bool ToInt( const char* str, int* value );
+ static bool ToUnsigned( const char* str, unsigned* value );
+ static bool ToBool( const char* str, bool* value );
+ static bool ToFloat( const char* str, float* value );
+ static bool ToDouble( const char* str, double* value );
+};
+
+
+/** XMLNode is a base class for every object that is in the
+ XML Document Object Model (DOM), except XMLAttributes.
+ Nodes have siblings, a parent, and children which can
+ be navigated. A node is always in a XMLDocument.
+ The type of a XMLNode can be queried, and it can
+ be cast to its more defined type.
+
+ A XMLDocument allocates memory for all its Nodes.
+ When the XMLDocument gets deleted, all its Nodes
+ will also be deleted.
+
+ @verbatim
+ A Document can contain: Element (container or leaf)
+ Comment (leaf)
+ Unknown (leaf)
+ Declaration( leaf )
+
+ An Element can contain: Element (container or leaf)
+ Text (leaf)
+ Attributes (not on tree)
+ Comment (leaf)
+ Unknown (leaf)
+
+ @endverbatim
+*/
+class TINYXML2_LIB XMLNode
+{
+ friend class XMLDocument;
+ friend class XMLElement;
+public:
+
+ /// Get the XMLDocument that owns this XMLNode.
+ const XMLDocument* GetDocument() const {
+ return _document;
+ }
+ /// Get the XMLDocument that owns this XMLNode.
+ XMLDocument* GetDocument() {
+ return _document;
+ }
+
+ /// Safely cast to an Element, or null.
+ virtual XMLElement* ToElement() {
+ return 0;
+ }
+ /// Safely cast to Text, or null.
+ virtual XMLText* ToText() {
+ return 0;
+ }
+ /// Safely cast to a Comment, or null.
+ virtual XMLComment* ToComment() {
+ return 0;
+ }
+ /// Safely cast to a Document, or null.
+ virtual XMLDocument* ToDocument() {
+ return 0;
+ }
+ /// Safely cast to a Declaration, or null.
+ virtual XMLDeclaration* ToDeclaration() {
+ return 0;
+ }
+ /// Safely cast to an Unknown, or null.
+ virtual XMLUnknown* ToUnknown() {
+ return 0;
+ }
+
+ virtual const XMLElement* ToElement() const {
+ return 0;
+ }
+ virtual const XMLText* ToText() const {
+ return 0;
+ }
+ virtual const XMLComment* ToComment() const {
+ return 0;
+ }
+ virtual const XMLDocument* ToDocument() const {
+ return 0;
+ }
+ virtual const XMLDeclaration* ToDeclaration() const {
+ return 0;
+ }
+ virtual const XMLUnknown* ToUnknown() const {
+ return 0;
+ }
+
+ /** The meaning of 'value' changes for the specific type.
+ @verbatim
+ Document: empty
+ Element: name of the element
+ Comment: the comment text
+ Unknown: the tag contents
+ Text: the text string
+ @endverbatim
+ */
+ const char* Value() const;
+
+ /** Set the Value of an XML node.
+ @sa Value()
+ */
+ void SetValue( const char* val, bool staticMem=false );
+
+ /// Get the parent of this node on the DOM.
+ const XMLNode* Parent() const {
+ return _parent;
+ }
+
+ XMLNode* Parent() {
+ return _parent;
+ }
+
+ /// Returns true if this node has no children.
+ bool NoChildren() const {
+ return !_firstChild;
+ }
+
+ /// Get the first child node, or null if none exists.
+ const XMLNode* FirstChild() const {
+ return _firstChild;
+ }
+
+ XMLNode* FirstChild() {
+ return _firstChild;
+ }
+
+ /** Get the first child element, or optionally the first child
+ element with the specified name.
+ */
+ const XMLElement* FirstChildElement( const char* value=0 ) const;
+
+ XMLElement* FirstChildElement( const char* value=0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->FirstChildElement( value ));
+ }
+
+ /// Get the last child node, or null if none exists.
+ const XMLNode* LastChild() const {
+ return _lastChild;
+ }
+
+ XMLNode* LastChild() {
+ return const_cast<XMLNode*>(const_cast<const XMLNode*>(this)->LastChild() );
+ }
+
+ /** Get the last child element or optionally the last child
+ element with the specified name.
+ */
+ const XMLElement* LastChildElement( const char* value=0 ) const;
+
+ XMLElement* LastChildElement( const char* value=0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->LastChildElement(value) );
+ }
+
+ /// Get the previous (left) sibling node of this node.
+ const XMLNode* PreviousSibling() const {
+ return _prev;
+ }
+
+ XMLNode* PreviousSibling() {
+ return _prev;
+ }
+
+ /// Get the previous (left) sibling element of this node, with an optionally supplied name.
+ const XMLElement* PreviousSiblingElement( const char* value=0 ) const ;
+
+ XMLElement* PreviousSiblingElement( const char* value=0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->PreviousSiblingElement( value ) );
+ }
+
+ /// Get the next (right) sibling node of this node.
+ const XMLNode* NextSibling() const {
+ return _next;
+ }
+
+ XMLNode* NextSibling() {
+ return _next;
+ }
+
+ /// Get the next (right) sibling element of this node, with an optionally supplied name.
+ const XMLElement* NextSiblingElement( const char* value=0 ) const;
+
+ XMLElement* NextSiblingElement( const char* value=0 ) {
+ return const_cast<XMLElement*>(const_cast<const XMLNode*>(this)->NextSiblingElement( value ) );
+ }
+
+ /**
+ Add a child node as the last (right) child.
+ If the child node is already part of the document,
+ it is moved from its old location to the new location.
+ Returns the addThis argument or 0 if the node does not
+ belong to the same document.
+ */
+ XMLNode* InsertEndChild( XMLNode* addThis );
+
+ XMLNode* LinkEndChild( XMLNode* addThis ) {
+ return InsertEndChild( addThis );
+ }
+ /**
+ Add a child node as the first (left) child.
+ If the child node is already part of the document,
+ it is moved from its old location to the new location.
+ Returns the addThis argument or 0 if the node does not
+ belong to the same document.
+ */
+ XMLNode* InsertFirstChild( XMLNode* addThis );
+ /**
+ Add a node after the specified child node.
+ If the child node is already part of the document,
+ it is moved from its old location to the new location.
+ Returns the addThis argument or 0 if the afterThis node
+ is not a child of this node, or if the node does not
+ belong to the same document.
+ */
+ XMLNode* InsertAfterChild( XMLNode* afterThis, XMLNode* addThis );
+
+ /**
+ Delete all the children of this node.
+ */
+ void DeleteChildren();
+
+ /**
+ Delete a child of this node.
+ */
+ void DeleteChild( XMLNode* node );
+
+ /**
+ Make a copy of this node, but not its children.
+ You may pass in a Document pointer that will be
+ the owner of the new Node. If the 'document' is
+ null, then the node returned will be allocated
+ from the current Document. (this->GetDocument())
+
+ Note: if called on a XMLDocument, this will return null.
+ */
+ virtual XMLNode* ShallowClone( XMLDocument* document ) const = 0;
+
+ /**
+ Test if 2 nodes are the same, but don't test children.
+ The 2 nodes do not need to be in the same Document.
+
+ Note: if called on a XMLDocument, this will return false.
+ */
+ virtual bool ShallowEqual( const XMLNode* compare ) const = 0;
+
+ /** Accept a hierarchical visit of the nodes in the TinyXML-2 DOM. Every node in the
+ XML tree will be conditionally visited and the host will be called back
+ via the XMLVisitor interface.
+
+ This is essentially a SAX interface for TinyXML-2. (Note however it doesn't re-parse
+ the XML for the callbacks, so the performance of TinyXML-2 is unchanged by using this
+ interface versus any other.)
+
+ The interface has been based on ideas from:
+
+ - http://www.saxproject.org/
+ - http://c2.com/cgi/wiki?HierarchicalVisitorPattern
+
+ Which are both good references for "visiting".
+
+ An example of using Accept():
+ @verbatim
+ XMLPrinter printer;
+ tinyxmlDoc.Accept( &printer );
+ const char* xmlcstr = printer.CStr();
+ @endverbatim
+ */
+ virtual bool Accept( XMLVisitor* visitor ) const = 0;
+
+ // internal
+ virtual char* ParseDeep( char*, StrPair* );
+
+protected:
+ XMLNode( XMLDocument* );
+ virtual ~XMLNode();
+ XMLNode( const XMLNode& ); // not supported
+ XMLNode& operator=( const XMLNode& ); // not supported
+
+ XMLDocument* _document;
+ XMLNode* _parent;
+ mutable StrPair _value;
+
+ XMLNode* _firstChild;
+ XMLNode* _lastChild;
+
+ XMLNode* _prev;
+ XMLNode* _next;
+
+private:
+ MemPool* _memPool;
+ void Unlink( XMLNode* child );
+ static void DeleteNode( XMLNode* node );
+};
+
+
+/** XML text.
+
+ Note that a text node can have child element nodes, for example:
+ @verbatim
+ <root>This is <b>bold</b></root>
+ @endverbatim
+
+ A text node can have 2 ways to output the next. "normal" output
+ and CDATA. It will default to the mode it was parsed from the XML file and
+ you generally want to leave it alone, but you can change the output mode with
+ SetCData() and query it with CData().
+*/
+class TINYXML2_LIB XMLText : public XMLNode
+{
+ friend class XMLBase;
+ friend class XMLDocument;
+public:
+ virtual bool Accept( XMLVisitor* visitor ) const;
+
+ virtual XMLText* ToText() {
+ return this;
+ }
+ virtual const XMLText* ToText() const {
+ return this;
+ }
+
+ /// Declare whether this should be CDATA or standard text.
+ void SetCData( bool isCData ) {
+ _isCData = isCData;
+ }
+ /// Returns true if this is a CDATA text element.
+ bool CData() const {
+ return _isCData;
+ }
+
+ char* ParseDeep( char*, StrPair* endTag );
+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
+ virtual bool ShallowEqual( const XMLNode* compare ) const;
+
+protected:
+ XMLText( XMLDocument* doc ) : XMLNode( doc ), _isCData( false ) {}
+ virtual ~XMLText() {}
+ XMLText( const XMLText& ); // not supported
+ XMLText& operator=( const XMLText& ); // not supported
+
+private:
+ bool _isCData;
+};
+
+
+/** An XML Comment. */
+class TINYXML2_LIB XMLComment : public XMLNode
+{
+ friend class XMLDocument;
+public:
+ virtual XMLComment* ToComment() {
+ return this;
+ }
+ virtual const XMLComment* ToComment() const {
+ return this;
+ }
+
+ virtual bool Accept( XMLVisitor* visitor ) const;
+
+ char* ParseDeep( char*, StrPair* endTag );
+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
+ virtual bool ShallowEqual( const XMLNode* compare ) const;
+
+protected:
+ XMLComment( XMLDocument* doc );
+ virtual ~XMLComment();
+ XMLComment( const XMLComment& ); // not supported
+ XMLComment& operator=( const XMLComment& ); // not supported
+
+private:
+};
+
+
+/** In correct XML the declaration is the first entry in the file.
+ @verbatim
+ <?xml version="1.0" standalone="yes"?>
+ @endverbatim
+
+ TinyXML-2 will happily read or write files without a declaration,
+ however.
+
+ The text of the declaration isn't interpreted. It is parsed
+ and written as a string.
+*/
+class TINYXML2_LIB XMLDeclaration : public XMLNode
+{
+ friend class XMLDocument;
+public:
+ virtual XMLDeclaration* ToDeclaration() {
+ return this;
+ }
+ virtual const XMLDeclaration* ToDeclaration() const {
+ return this;
+ }
+
+ virtual bool Accept( XMLVisitor* visitor ) const;
+
+ char* ParseDeep( char*, StrPair* endTag );
+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
+ virtual bool ShallowEqual( const XMLNode* compare ) const;
+
+protected:
+ XMLDeclaration( XMLDocument* doc );
+ virtual ~XMLDeclaration();
+ XMLDeclaration( const XMLDeclaration& ); // not supported
+ XMLDeclaration& operator=( const XMLDeclaration& ); // not supported
+};
+
+
+/** Any tag that TinyXML-2 doesn't recognize is saved as an
+ unknown. It is a tag of text, but should not be modified.
+ It will be written back to the XML, unchanged, when the file
+ is saved.
+
+ DTD tags get thrown into XMLUnknowns.
+*/
+class TINYXML2_LIB XMLUnknown : public XMLNode
+{
+ friend class XMLDocument;
+public:
+ virtual XMLUnknown* ToUnknown() {
+ return this;
+ }
+ virtual const XMLUnknown* ToUnknown() const {
+ return this;
+ }
+
+ virtual bool Accept( XMLVisitor* visitor ) const;
+
+ char* ParseDeep( char*, StrPair* endTag );
+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
+ virtual bool ShallowEqual( const XMLNode* compare ) const;
+
+protected:
+ XMLUnknown( XMLDocument* doc );
+ virtual ~XMLUnknown();
+ XMLUnknown( const XMLUnknown& ); // not supported
+ XMLUnknown& operator=( const XMLUnknown& ); // not supported
+};
+
+
+
+/** An attribute is a name-value pair. Elements have an arbitrary
+ number of attributes, each with a unique name.
+
+ @note The attributes are not XMLNodes. You may only query the
+ Next() attribute in a list.
+*/
+class TINYXML2_LIB XMLAttribute
+{
+ friend class XMLElement;
+public:
+ /// The name of the attribute.
+ const char* Name() const;
+
+ /// The value of the attribute.
+ const char* Value() const;
+
+ /// The next attribute in the list.
+ const XMLAttribute* Next() const {
+ return _next;
+ }
+
+ /** IntValue interprets the attribute as an integer, and returns the value.
+ If the value isn't an integer, 0 will be returned. There is no error checking;
+ use QueryIntValue() if you need error checking.
+ */
+ int IntValue() const {
+ int i=0;
+ QueryIntValue( &i );
+ return i;
+ }
+ /// Query as an unsigned integer. See IntValue()
+ unsigned UnsignedValue() const {
+ unsigned i=0;
+ QueryUnsignedValue( &i );
+ return i;
+ }
+ /// Query as a boolean. See IntValue()
+ bool BoolValue() const {
+ bool b=false;
+ QueryBoolValue( &b );
+ return b;
+ }
+ /// Query as a double. See IntValue()
+ double DoubleValue() const {
+ double d=0;
+ QueryDoubleValue( &d );
+ return d;
+ }
+ /// Query as a float. See IntValue()
+ float FloatValue() const {
+ float f=0;
+ QueryFloatValue( &f );
+ return f;
+ }
+
+ /** QueryIntValue interprets the attribute as an integer, and returns the value
+ in the provided parameter. The function will return XML_NO_ERROR on success,
+ and XML_WRONG_ATTRIBUTE_TYPE if the conversion is not successful.
+ */
+ XMLError QueryIntValue( int* value ) const;
+ /// See QueryIntValue
+ XMLError QueryUnsignedValue( unsigned int* value ) const;
+ /// See QueryIntValue
+ XMLError QueryBoolValue( bool* value ) const;
+ /// See QueryIntValue
+ XMLError QueryDoubleValue( double* value ) const;
+ /// See QueryIntValue
+ XMLError QueryFloatValue( float* value ) const;
+
+ /// Set the attribute to a string value.
+ void SetAttribute( const char* value );
+ /// Set the attribute to value.
+ void SetAttribute( int value );
+ /// Set the attribute to value.
+ void SetAttribute( unsigned value );
+ /// Set the attribute to value.
+ void SetAttribute( bool value );
+ /// Set the attribute to value.
+ void SetAttribute( double value );
+ /// Set the attribute to value.
+ void SetAttribute( float value );
+
+private:
+ enum { BUF_SIZE = 200 };
+
+ XMLAttribute() : _next( 0 ), _memPool( 0 ) {}
+ virtual ~XMLAttribute() {}
+
+ XMLAttribute( const XMLAttribute& ); // not supported
+ void operator=( const XMLAttribute& ); // not supported
+ void SetName( const char* name );
+
+ char* ParseDeep( char* p, bool processEntities );
+
+ mutable StrPair _name;
+ mutable StrPair _value;
+ XMLAttribute* _next;
+ MemPool* _memPool;
+};
+
+
+/** The element is a container class. It has a value, the element name,
+ and can contain other elements, text, comments, and unknowns.
+ Elements also contain an arbitrary number of attributes.
+*/
+class TINYXML2_LIB XMLElement : public XMLNode
+{
+ friend class XMLBase;
+ friend class XMLDocument;
+public:
+ /// Get the name of an element (which is the Value() of the node.)
+ const char* Name() const {
+ return Value();
+ }
+ /// Set the name of the element.
+ void SetName( const char* str, bool staticMem=false ) {
+ SetValue( str, staticMem );
+ }
+
+ virtual XMLElement* ToElement() {
+ return this;
+ }
+ virtual const XMLElement* ToElement() const {
+ return this;
+ }
+ virtual bool Accept( XMLVisitor* visitor ) const;
+
+ /** Given an attribute name, Attribute() returns the value
+ for the attribute of that name, or null if none
+ exists. For example:
+
+ @verbatim
+ const char* value = ele->Attribute( "foo" );
+ @endverbatim
+
+ The 'value' parameter is normally null. However, if specified,
+ the attribute will only be returned if the 'name' and 'value'
+ match. This allow you to write code:
+
+ @verbatim
+ if ( ele->Attribute( "foo", "bar" ) ) callFooIsBar();
+ @endverbatim
+
+ rather than:
+ @verbatim
+ if ( ele->Attribute( "foo" ) ) {
+ if ( strcmp( ele->Attribute( "foo" ), "bar" ) == 0 ) callFooIsBar();
+ }
+ @endverbatim
+ */
+ const char* Attribute( const char* name, const char* value=0 ) const;
+
+ /** Given an attribute name, IntAttribute() returns the value
+ of the attribute interpreted as an integer. 0 will be
+ returned if there is an error. For a method with error
+ checking, see QueryIntAttribute()
+ */
+ int IntAttribute( const char* name ) const {
+ int i=0;
+ QueryIntAttribute( name, &i );
+ return i;
+ }
+ /// See IntAttribute()
+ unsigned UnsignedAttribute( const char* name ) const {
+ unsigned i=0;
+ QueryUnsignedAttribute( name, &i );
+ return i;
+ }
+ /// See IntAttribute()
+ bool BoolAttribute( const char* name ) const {
+ bool b=false;
+ QueryBoolAttribute( name, &b );
+ return b;
+ }
+ /// See IntAttribute()
+ double DoubleAttribute( const char* name ) const {
+ double d=0;
+ QueryDoubleAttribute( name, &d );
+ return d;
+ }
+ /// See IntAttribute()
+ float FloatAttribute( const char* name ) const {
+ float f=0;
+ QueryFloatAttribute( name, &f );
+ return f;
+ }
+
+ /** Given an attribute name, QueryIntAttribute() returns
+ XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+ can't be performed, or XML_NO_ATTRIBUTE if the attribute
+ doesn't exist. If successful, the result of the conversion
+ will be written to 'value'. If not successful, nothing will
+ be written to 'value'. This allows you to provide default
+ value:
+
+ @verbatim
+ int value = 10;
+ QueryIntAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
+ @endverbatim
+ */
+ XMLError QueryIntAttribute( const char* name, int* value ) const {
+ const XMLAttribute* a = FindAttribute( name );
+ if ( !a ) {
+ return XML_NO_ATTRIBUTE;
+ }
+ return a->QueryIntValue( value );
+ }
+ /// See QueryIntAttribute()
+ XMLError QueryUnsignedAttribute( const char* name, unsigned int* value ) const {
+ const XMLAttribute* a = FindAttribute( name );
+ if ( !a ) {
+ return XML_NO_ATTRIBUTE;
+ }
+ return a->QueryUnsignedValue( value );
+ }
+ /// See QueryIntAttribute()
+ XMLError QueryBoolAttribute( const char* name, bool* value ) const {
+ const XMLAttribute* a = FindAttribute( name );
+ if ( !a ) {
+ return XML_NO_ATTRIBUTE;
+ }
+ return a->QueryBoolValue( value );
+ }
+ /// See QueryIntAttribute()
+ XMLError QueryDoubleAttribute( const char* name, double* value ) const {
+ const XMLAttribute* a = FindAttribute( name );
+ if ( !a ) {
+ return XML_NO_ATTRIBUTE;
+ }
+ return a->QueryDoubleValue( value );
+ }
+ /// See QueryIntAttribute()
+ XMLError QueryFloatAttribute( const char* name, float* value ) const {
+ const XMLAttribute* a = FindAttribute( name );
+ if ( !a ) {
+ return XML_NO_ATTRIBUTE;
+ }
+ return a->QueryFloatValue( value );
+ }
+
+
+ /** Given an attribute name, QueryAttribute() returns
+ XML_NO_ERROR, XML_WRONG_ATTRIBUTE_TYPE if the conversion
+ can't be performed, or XML_NO_ATTRIBUTE if the attribute
+ doesn't exist. It is overloaded for the primitive types,
+ and is a generally more convenient replacement of
+ QueryIntAttribute() and related functions.
+
+ If successful, the result of the conversion
+ will be written to 'value'. If not successful, nothing will
+ be written to 'value'. This allows you to provide default
+ value:
+
+ @verbatim
+ int value = 10;
+ QueryAttribute( "foo", &value ); // if "foo" isn't found, value will still be 10
+ @endverbatim
+ */
+ int QueryAttribute( const char* name, int* value ) const {
+ return QueryIntAttribute( name, value );
+ }
+
+ int QueryAttribute( const char* name, unsigned int* value ) const {
+ return QueryUnsignedAttribute( name, value );
+ }
+
+ int QueryAttribute( const char* name, bool* value ) const {
+ return QueryBoolAttribute( name, value );
+ }
+
+ int QueryAttribute( const char* name, double* value ) const {
+ return QueryDoubleAttribute( name, value );
+ }
+
+ int QueryAttribute( const char* name, float* value ) const {
+ return QueryFloatAttribute( name, value );
+ }
+
+ /// Sets the named attribute to value.
+ void SetAttribute( const char* name, const char* value ) {
+ XMLAttribute* a = FindOrCreateAttribute( name );
+ a->SetAttribute( value );
+ }
+ /// Sets the named attribute to value.
+ void SetAttribute( const char* name, int value ) {
+ XMLAttribute* a = FindOrCreateAttribute( name );
+ a->SetAttribute( value );
+ }
+ /// Sets the named attribute to value.
+ void SetAttribute( const char* name, unsigned value ) {
+ XMLAttribute* a = FindOrCreateAttribute( name );
+ a->SetAttribute( value );
+ }
+ /// Sets the named attribute to value.
+ void SetAttribute( const char* name, bool value ) {
+ XMLAttribute* a = FindOrCreateAttribute( name );
+ a->SetAttribute( value );
+ }
+ /// Sets the named attribute to value.
+ void SetAttribute( const char* name, double value ) {
+ XMLAttribute* a = FindOrCreateAttribute( name );
+ a->SetAttribute( value );
+ }
+ /// Sets the named attribute to value.
+ void SetAttribute( const char* name, float value ) {
+ XMLAttribute* a = FindOrCreateAttribute( name );
+ a->SetAttribute( value );
+ }
+
+ /**
+ Delete an attribute.
+ */
+ void DeleteAttribute( const char* name );
+
+ /// Return the first attribute in the list.
+ const XMLAttribute* FirstAttribute() const {
+ return _rootAttribute;
+ }
+ /// Query a specific attribute in the list.
+ const XMLAttribute* FindAttribute( const char* name ) const;
+
+ /** Convenience function for easy access to the text inside an element. Although easy
+ and concise, GetText() is limited compared to getting the XMLText child
+ and accessing it directly.
+
+ If the first child of 'this' is a XMLText, the GetText()
+ returns the character string of the Text node, else null is returned.
+
+ This is a convenient method for getting the text of simple contained text:
+ @verbatim
+ <foo>This is text</foo>
+ const char* str = fooElement->GetText();
+ @endverbatim
+
+ 'str' will be a pointer to "This is text".
+
+ Note that this function can be misleading. If the element foo was created from
+ this XML:
+ @verbatim
+ <foo><b>This is text</b></foo>
+ @endverbatim
+
+ then the value of str would be null. The first child node isn't a text node, it is
+ another element. From this XML:
+ @verbatim
+ <foo>This is <b>text</b></foo>
+ @endverbatim
+ GetText() will return "This is ".
+ */
+ const char* GetText() const;
+
+ /** Convenience function for easy access to the text inside an element. Although easy
+ and concise, SetText() is limited compared to creating an XMLText child
+ and mutating it directly.
+
+ If the first child of 'this' is a XMLText, SetText() sets its value to
+ the given string, otherwise it will create a first child that is an XMLText.
+
+ This is a convenient method for setting the text of simple contained text:
+ @verbatim
+ <foo>This is text</foo>
+ fooElement->SetText( "Hullaballoo!" );
+ <foo>Hullaballoo!</foo>
+ @endverbatim
+
+ Note that this function can be misleading. If the element foo was created from
+ this XML:
+ @verbatim
+ <foo><b>This is text</b></foo>
+ @endverbatim
+
+ then it will not change "This is text", but rather prefix it with a text element:
+ @verbatim
+ <foo>Hullaballoo!<b>This is text</b></foo>
+ @endverbatim
+
+ For this XML:
+ @verbatim
+ <foo />
+ @endverbatim
+ SetText() will generate
+ @verbatim
+ <foo>Hullaballoo!</foo>
+ @endverbatim
+ */
+ void SetText( const char* inText );
+ /// Convenience method for setting text inside and element. See SetText() for important limitations.
+ void SetText( int value );
+ /// Convenience method for setting text inside and element. See SetText() for important limitations.
+ void SetText( unsigned value );
+ /// Convenience method for setting text inside and element. See SetText() for important limitations.
+ void SetText( bool value );
+ /// Convenience method for setting text inside and element. See SetText() for important limitations.
+ void SetText( double value );
+ /// Convenience method for setting text inside and element. See SetText() for important limitations.
+ void SetText( float value );
+
+ /**
+ Convenience method to query the value of a child text node. This is probably best
+ shown by example. Given you have a document is this form:
+ @verbatim
+ <point>
+ <x>1</x>
+ <y>1.4</y>
+ </point>
+ @endverbatim
+
+ The QueryIntText() and similar functions provide a safe and easier way to get to the
+ "value" of x and y.
+
+ @verbatim
+ int x = 0;
+ float y = 0; // types of x and y are contrived for example
+ const XMLElement* xElement = pointElement->FirstChildElement( "x" );
+ const XMLElement* yElement = pointElement->FirstChildElement( "y" );
+ xElement->QueryIntText( &x );
+ yElement->QueryFloatText( &y );
+ @endverbatim
+
+ @returns XML_SUCCESS (0) on success, XML_CAN_NOT_CONVERT_TEXT if the text cannot be converted
+ to the requested type, and XML_NO_TEXT_NODE if there is no child text to query.
+
+ */
+ XMLError QueryIntText( int* ival ) const;
+ /// See QueryIntText()
+ XMLError QueryUnsignedText( unsigned* uval ) const;
+ /// See QueryIntText()
+ XMLError QueryBoolText( bool* bval ) const;
+ /// See QueryIntText()
+ XMLError QueryDoubleText( double* dval ) const;
+ /// See QueryIntText()
+ XMLError QueryFloatText( float* fval ) const;
+
+ // internal:
+ enum {
+ OPEN, // <foo>
+ CLOSED, // <foo/>
+ CLOSING // </foo>
+ };
+ int ClosingType() const {
+ return _closingType;
+ }
+ char* ParseDeep( char* p, StrPair* endTag );
+ virtual XMLNode* ShallowClone( XMLDocument* document ) const;
+ virtual bool ShallowEqual( const XMLNode* compare ) const;
+
+private:
+ XMLElement( XMLDocument* doc );
+ virtual ~XMLElement();
+ XMLElement( const XMLElement& ); // not supported
+ void operator=( const XMLElement& ); // not supported
+
+ XMLAttribute* FindAttribute( const char* name );
+ XMLAttribute* FindOrCreateAttribute( const char* name );
+ //void LinkAttribute( XMLAttribute* attrib );
+ char* ParseAttributes( char* p );
+ static void DeleteAttribute( XMLAttribute* attribute );
+
+ enum { BUF_SIZE = 200 };
+ int _closingType;
+ // The attribute list is ordered; there is no 'lastAttribute'
+ // because the list needs to be scanned for dupes before adding
+ // a new attribute.
+ XMLAttribute* _rootAttribute;
+};
+
+
+enum Whitespace {
+ PRESERVE_WHITESPACE,
+ COLLAPSE_WHITESPACE
+};
+
+
+/** A Document binds together all the functionality.
+ It can be saved, loaded, and printed to the screen.
+ All Nodes are connected and allocated to a Document.
+ If the Document is deleted, all its Nodes are also deleted.
+*/
+class TINYXML2_LIB XMLDocument : public XMLNode
+{
+ friend class XMLElement;
+public:
+ /// constructor
+ XMLDocument( bool processEntities = true, Whitespace = PRESERVE_WHITESPACE );
+ ~XMLDocument();
+
+ virtual XMLDocument* ToDocument() {
+ return this;
+ }
+ virtual const XMLDocument* ToDocument() const {
+ return this;
+ }
+
+ /**
+ Parse an XML file from a character string.
+ Returns XML_NO_ERROR (0) on success, or
+ an errorID.
+
+ You may optionally pass in the 'nBytes', which is
+ the number of bytes which will be parsed. If not
+ specified, TinyXML-2 will assume 'xml' points to a
+ null terminated string.
+ */
+ XMLError Parse( const char* xml, size_t nBytes=(size_t)(-1) );
+
+ /**
+ Load an XML file from disk.
+ Returns XML_NO_ERROR (0) on success, or
+ an errorID.
+ */
+ XMLError LoadFile( const char* filename );
+
+ /**
+ Load an XML file from disk. You are responsible
+ for providing and closing the FILE*.
+
+ Returns XML_NO_ERROR (0) on success, or
+ an errorID.
+ */
+ XMLError LoadFile( FILE* );
+
+ /**
+ Save the XML file to disk.
+ Returns XML_NO_ERROR (0) on success, or
+ an errorID.
+ */
+ XMLError SaveFile( const char* filename, bool compact = false );
+
+ /**
+ Save the XML file to disk. You are responsible
+ for providing and closing the FILE*.
+
+ Returns XML_NO_ERROR (0) on success, or
+ an errorID.
+ */
+ XMLError SaveFile( FILE* fp, bool compact = false );
+
+ bool ProcessEntities() const {
+ return _processEntities;
+ }
+ Whitespace WhitespaceMode() const {
+ return _whitespace;
+ }
+
+ /**
+ Returns true if this document has a leading Byte Order Mark of UTF8.
+ */
+ bool HasBOM() const {
+ return _writeBOM;
+ }
+ /** Sets whether to write the BOM when writing the file.
+ */
+ void SetBOM( bool useBOM ) {
+ _writeBOM = useBOM;
+ }
+
+ /** Return the root element of DOM. Equivalent to FirstChildElement().
+ To get the first node, use FirstChild().
+ */
+ XMLElement* RootElement() {
+ return FirstChildElement();
+ }
+ const XMLElement* RootElement() const {
+ return FirstChildElement();
+ }
+
+ /** Print the Document. If the Printer is not provided, it will
+ print to stdout. If you provide Printer, this can print to a file:
+ @verbatim
+ XMLPrinter printer( fp );
+ doc.Print( &printer );
+ @endverbatim
+
+ Or you can use a printer to print to memory:
+ @verbatim
+ XMLPrinter printer;
+ doc.Print( &printer );
+ // printer.CStr() has a const char* to the XML
+ @endverbatim
+ */
+ void Print( XMLPrinter* streamer=0 ) const;
+ virtual bool Accept( XMLVisitor* visitor ) const;
+
+ /**
+ Create a new Element associated with
+ this Document. The memory for the Element
+ is managed by the Document.
+ */
+ XMLElement* NewElement( const char* name );
+ /**
+ Create a new Comment associated with
+ this Document. The memory for the Comment
+ is managed by the Document.
+ */
+ XMLComment* NewComment( const char* comment );
+ /**
+ Create a new Text associated with
+ this Document. The memory for the Text
+ is managed by the Document.
+ */
+ XMLText* NewText( const char* text );
+ /**
+ Create a new Declaration associated with
+ this Document. The memory for the object
+ is managed by the Document.
+
+ If the 'text' param is null, the standard
+ declaration is used.:
+ @verbatim
+ <?xml version="1.0" encoding="UTF-8"?>
+ @endverbatim
+ */
+ XMLDeclaration* NewDeclaration( const char* text=0 );
+ /**
+ Create a new Unknown associated with
+ this Document. The memory for the object
+ is managed by the Document.
+ */
+ XMLUnknown* NewUnknown( const char* text );
+
+ /**
+ Delete a node associated with this document.
+ It will be unlinked from the DOM.
+ */
+ void DeleteNode( XMLNode* node ) {
+ node->_parent->DeleteChild( node );
+ }
+
+ void SetError( XMLError error, const char* str1, const char* str2 );
+
+ /// Return true if there was an error parsing the document.
+ bool Error() const {
+ return _errorID != XML_NO_ERROR;
+ }
+ /// Return the errorID.
+ XMLError ErrorID() const {
+ return _errorID;
+ }
+ const char* ErrorName() const;
+
+ /// Return a possibly helpful diagnostic location or string.
+ const char* GetErrorStr1() const {
+ return _errorStr1;
+ }
+ /// Return a possibly helpful secondary diagnostic location or string.
+ const char* GetErrorStr2() const {
+ return _errorStr2;
+ }
+ /// If there is an error, print it to stdout.
+ void PrintError() const;
+
+ /// Clear the document, resetting it to the initial state.
+ void Clear();
+
+ // internal
+ char* Identify( char* p, XMLNode** node );
+
+ virtual XMLNode* ShallowClone( XMLDocument* /*document*/ ) const {
+ return 0;
+ }
+ virtual bool ShallowEqual( const XMLNode* /*compare*/ ) const {
+ return false;
+ }
+
+private:
+ XMLDocument( const XMLDocument& ); // not supported
+ void operator=( const XMLDocument& ); // not supported
+
+ bool _writeBOM;
+ bool _processEntities;
+ XMLError _errorID;
+ Whitespace _whitespace;
+ const char* _errorStr1;
+ const char* _errorStr2;
+ char* _charBuffer;
+
+ MemPoolT< sizeof(XMLElement) > _elementPool;
+ MemPoolT< sizeof(XMLAttribute) > _attributePool;
+ MemPoolT< sizeof(XMLText) > _textPool;
+ MemPoolT< sizeof(XMLComment) > _commentPool;
+
+ static const char* _errorNames[XML_ERROR_COUNT];
+};
+
+
+/**
+ A XMLHandle is a class that wraps a node pointer with null checks; this is
+ an incredibly useful thing. Note that XMLHandle is not part of the TinyXML-2
+ DOM structure. It is a separate utility class.
+
+ Take an example:
+ @verbatim
+ <Document>
+ <Element attributeA = "valueA">
+ <Child attributeB = "value1" />
+ <Child attributeB = "value2" />
+ </Element>
+ </Document>
+ @endverbatim
+
+ Assuming you want the value of "attributeB" in the 2nd "Child" element, it's very
+ easy to write a *lot* of code that looks like:
+
+ @verbatim
+ XMLElement* root = document.FirstChildElement( "Document" );
+ if ( root )
+ {
+ XMLElement* element = root->FirstChildElement( "Element" );
+ if ( element )
+ {
+ XMLElement* child = element->FirstChildElement( "Child" );
+ if ( child )
+ {
+ XMLElement* child2 = child->NextSiblingElement( "Child" );
+ if ( child2 )
+ {
+ // Finally do something useful.
+ @endverbatim
+
+ And that doesn't even cover "else" cases. XMLHandle addresses the verbosity
+ of such code. A XMLHandle checks for null pointers so it is perfectly safe
+ and correct to use:
+
+ @verbatim
+ XMLHandle docHandle( &document );
+ XMLElement* child2 = docHandle.FirstChild( "Document" ).FirstChild( "Element" ).FirstChild().NextSibling().ToElement();
+ if ( child2 )
+ {
+ // do something useful
+ @endverbatim
+
+ Which is MUCH more concise and useful.
+
+ It is also safe to copy handles - internally they are nothing more than node pointers.
+ @verbatim
+ XMLHandle handleCopy = handle;
+ @endverbatim
+
+ See also XMLConstHandle, which is the same as XMLHandle, but operates on const objects.
+*/
+class TINYXML2_LIB XMLHandle
+{
+public:
+ /// Create a handle from any node (at any depth of the tree.) This can be a null pointer.
+ XMLHandle( XMLNode* node ) {
+ _node = node;
+ }
+ /// Create a handle from a node.
+ XMLHandle( XMLNode& node ) {
+ _node = &node;
+ }
+ /// Copy constructor
+ XMLHandle( const XMLHandle& ref ) {
+ _node = ref._node;
+ }
+ /// Assignment
+ XMLHandle& operator=( const XMLHandle& ref ) {
+ _node = ref._node;
+ return *this;
+ }
+
+ /// Get the first child of this handle.
+ XMLHandle FirstChild() {
+ return XMLHandle( _node ? _node->FirstChild() : 0 );
+ }
+ /// Get the first child element of this handle.
+ XMLHandle FirstChildElement( const char* value=0 ) {
+ return XMLHandle( _node ? _node->FirstChildElement( value ) : 0 );
+ }
+ /// Get the last child of this handle.
+ XMLHandle LastChild() {
+ return XMLHandle( _node ? _node->LastChild() : 0 );
+ }
+ /// Get the last child element of this handle.
+ XMLHandle LastChildElement( const char* _value=0 ) {
+ return XMLHandle( _node ? _node->LastChildElement( _value ) : 0 );
+ }
+ /// Get the previous sibling of this handle.
+ XMLHandle PreviousSibling() {
+ return XMLHandle( _node ? _node->PreviousSibling() : 0 );
+ }
+ /// Get the previous sibling element of this handle.
+ XMLHandle PreviousSiblingElement( const char* _value=0 ) {
+ return XMLHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
+ }
+ /// Get the next sibling of this handle.
+ XMLHandle NextSibling() {
+ return XMLHandle( _node ? _node->NextSibling() : 0 );
+ }
+ /// Get the next sibling element of this handle.
+ XMLHandle NextSiblingElement( const char* _value=0 ) {
+ return XMLHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
+ }
+
+ /// Safe cast to XMLNode. This can return null.
+ XMLNode* ToNode() {
+ return _node;
+ }
+ /// Safe cast to XMLElement. This can return null.
+ XMLElement* ToElement() {
+ return ( ( _node == 0 ) ? 0 : _node->ToElement() );
+ }
+ /// Safe cast to XMLText. This can return null.
+ XMLText* ToText() {
+ return ( ( _node == 0 ) ? 0 : _node->ToText() );
+ }
+ /// Safe cast to XMLUnknown. This can return null.
+ XMLUnknown* ToUnknown() {
+ return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
+ }
+ /// Safe cast to XMLDeclaration. This can return null.
+ XMLDeclaration* ToDeclaration() {
+ return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
+ }
+
+private:
+ XMLNode* _node;
+};
+
+
+/**
+ A variant of the XMLHandle class for working with const XMLNodes and Documents. It is the
+ same in all regards, except for the 'const' qualifiers. See XMLHandle for API.
+*/
+class TINYXML2_LIB XMLConstHandle
+{
+public:
+ XMLConstHandle( const XMLNode* node ) {
+ _node = node;
+ }
+ XMLConstHandle( const XMLNode& node ) {
+ _node = &node;
+ }
+ XMLConstHandle( const XMLConstHandle& ref ) {
+ _node = ref._node;
+ }
+
+ XMLConstHandle& operator=( const XMLConstHandle& ref ) {
+ _node = ref._node;
+ return *this;
+ }
+
+ const XMLConstHandle FirstChild() const {
+ return XMLConstHandle( _node ? _node->FirstChild() : 0 );
+ }
+ const XMLConstHandle FirstChildElement( const char* value=0 ) const {
+ return XMLConstHandle( _node ? _node->FirstChildElement( value ) : 0 );
+ }
+ const XMLConstHandle LastChild() const {
+ return XMLConstHandle( _node ? _node->LastChild() : 0 );
+ }
+ const XMLConstHandle LastChildElement( const char* _value=0 ) const {
+ return XMLConstHandle( _node ? _node->LastChildElement( _value ) : 0 );
+ }
+ const XMLConstHandle PreviousSibling() const {
+ return XMLConstHandle( _node ? _node->PreviousSibling() : 0 );
+ }
+ const XMLConstHandle PreviousSiblingElement( const char* _value=0 ) const {
+ return XMLConstHandle( _node ? _node->PreviousSiblingElement( _value ) : 0 );
+ }
+ const XMLConstHandle NextSibling() const {
+ return XMLConstHandle( _node ? _node->NextSibling() : 0 );
+ }
+ const XMLConstHandle NextSiblingElement( const char* _value=0 ) const {
+ return XMLConstHandle( _node ? _node->NextSiblingElement( _value ) : 0 );
+ }
+
+
+ const XMLNode* ToNode() const {
+ return _node;
+ }
+ const XMLElement* ToElement() const {
+ return ( ( _node == 0 ) ? 0 : _node->ToElement() );
+ }
+ const XMLText* ToText() const {
+ return ( ( _node == 0 ) ? 0 : _node->ToText() );
+ }
+ const XMLUnknown* ToUnknown() const {
+ return ( ( _node == 0 ) ? 0 : _node->ToUnknown() );
+ }
+ const XMLDeclaration* ToDeclaration() const {
+ return ( ( _node == 0 ) ? 0 : _node->ToDeclaration() );
+ }
+
+private:
+ const XMLNode* _node;
+};
+
+
+/**
+ Printing functionality. The XMLPrinter gives you more
+ options than the XMLDocument::Print() method.
+
+ It can:
+ -# Print to memory.
+ -# Print to a file you provide.
+ -# Print XML without a XMLDocument.
+
+ Print to Memory
+
+ @verbatim
+ XMLPrinter printer;
+ doc.Print( &printer );
+ SomeFunction( printer.CStr() );
+ @endverbatim
+
+ Print to a File
+
+ You provide the file pointer.
+ @verbatim
+ XMLPrinter printer( fp );
+ doc.Print( &printer );
+ @endverbatim
+
+ Print without a XMLDocument
+
+ When loading, an XML parser is very useful. However, sometimes
+ when saving, it just gets in the way. The code is often set up
+ for streaming, and constructing the DOM is just overhead.
+
+ The Printer supports the streaming case. The following code
+ prints out a trivially simple XML file without ever creating
+ an XML document.
+
+ @verbatim
+ XMLPrinter printer( fp );
+ printer.OpenElement( "foo" );
+ printer.PushAttribute( "foo", "bar" );
+ printer.CloseElement();
+ @endverbatim
+*/
+class TINYXML2_LIB XMLPrinter : public XMLVisitor
+{
+public:
+ /** Construct the printer. If the FILE* is specified,
+ this will print to the FILE. Else it will print
+ to memory, and the result is available in CStr().
+ If 'compact' is set to true, then output is created
+ with only required whitespace and newlines.
+ */
+ XMLPrinter( FILE* file=0, bool compact = false, int depth = 0 );
+ virtual ~XMLPrinter() {}
+
+ /** If streaming, write the BOM and declaration. */
+ void PushHeader( bool writeBOM, bool writeDeclaration );
+ /** If streaming, start writing an element.
+ The element must be closed with CloseElement()
+ */
+ void OpenElement( const char* name, bool compactMode=false );
+ /// If streaming, add an attribute to an open element.
+ void PushAttribute( const char* name, const char* value );
+ void PushAttribute( const char* name, int value );
+ void PushAttribute( const char* name, unsigned value );
+ void PushAttribute( const char* name, bool value );
+ void PushAttribute( const char* name, double value );
+ /// If streaming, close the Element.
+ virtual void CloseElement( bool compactMode=false );
+
+ /// Add a text node.
+ void PushText( const char* text, bool cdata=false );
+ /// Add a text node from an integer.
+ void PushText( int value );
+ /// Add a text node from an unsigned.
+ void PushText( unsigned value );
+ /// Add a text node from a bool.
+ void PushText( bool value );
+ /// Add a text node from a float.
+ void PushText( float value );
+ /// Add a text node from a double.
+ void PushText( double value );
+
+ /// Add a comment
+ void PushComment( const char* comment );
+
+ void PushDeclaration( const char* value );
+ void PushUnknown( const char* value );
+
+ virtual bool VisitEnter( const XMLDocument& /*doc*/ );
+ virtual bool VisitExit( const XMLDocument& /*doc*/ ) {
+ return true;
+ }
+
+ virtual bool VisitEnter( const XMLElement& element, const XMLAttribute* attribute );
+ virtual bool VisitExit( const XMLElement& element );
+
+ virtual bool Visit( const XMLText& text );
+ virtual bool Visit( const XMLComment& comment );
+ virtual bool Visit( const XMLDeclaration& declaration );
+ virtual bool Visit( const XMLUnknown& unknown );
+
+ /**
+ If in print to memory mode, return a pointer to
+ the XML file in memory.
+ */
+ const char* CStr() const {
+ return _buffer.Mem();
+ }
+ /**
+ If in print to memory mode, return the size
+ of the XML file in memory. (Note the size returned
+ includes the terminating null.)
+ */
+ int CStrSize() const {
+ return _buffer.Size();
+ }
+ /**
+ If in print to memory mode, reset the buffer to the
+ beginning.
+ */
+ void ClearBuffer() {
+ _buffer.Clear();
+ _buffer.Push(0);
+ }
+
+protected:
+ virtual bool CompactMode( const XMLElement& ) { return _compactMode; }
+
+ /** Prints out the space before an element. You may override to change
+ the space and tabs used. A PrintSpace() override should call Print().
+ */
+ virtual void PrintSpace( int depth );
+ void Print( const char* format, ... );
+
+ void SealElement();
+ bool _elementJustOpened;
+ DynArray< const char*, 10 > _stack;
+
+private:
+ void PrintString( const char*, bool restrictedEntitySet ); // prints out, after detecting entities.
+
+ bool _firstElement;
+ FILE* _fp;
+ int _depth;
+ int _textDepth;
+ bool _processEntities;
+ bool _compactMode;
+
+ enum {
+ ENTITY_RANGE = 64,
+ BUF_SIZE = 200
+ };
+ bool _entityFlag[ENTITY_RANGE];
+ bool _restrictedEntityFlag[ENTITY_RANGE];
+
+ DynArray< char, 20 > _buffer;
+};
+
+
+} // tinyxml2
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#endif
+
+#endif // TINYXML2_INCLUDED
-----------------------------------------------------------------------
Summary of changes:
.drone.yml | 20 +
.editorconfig | 62 +
.gitignore | 11 +-
.gitlab-ci.yml | 16 +
.travis.yml | 122 +-
AUTHORS | 2 +-
CMakeLists.txt | 217 +-
ChangeLog | 29159 -------------------
HOWTO_RELEASE | 78 +-
Makefile.am | 44 +-
NEWS | 139 +-
README | 105 -
README.md | 121 +
TODO | 2 -
appveyor.yml | 85 +
authors.svn | 18 -
autogen.bat | 4 +-
autogen.sh | 1 -
capi/CMakeLists.txt | 12 +-
capi/geos_c.cpp | 149 +-
capi/geos_c.h.in | 397 +-
capi/geos_ts_c.cpp | 1599 +-
cmake/modules/GenerateSourceGroups.cmake | 17 +
configure.ac | 122 +-
doc/Doxyfile.in | 6 +
doc/example.cpp | 98 +-
include/CMakeLists.txt | 5 +
include/acconfig.h | 2 +-
include/geos.h | 2 +-
include/geos/algorithm/Angle.h | 12 +-
include/geos/algorithm/BoundaryNodeRule.h | 4 +-
include/geos/algorithm/CGAlgorithms.h | 10 +-
.../geos/algorithm/CentralEndpointIntersector.h | 14 +-
include/geos/algorithm/Centroid.h | 12 +-
include/geos/algorithm/CentroidArea.h | 10 +-
include/geos/algorithm/CentroidLine.h | 2 +-
include/geos/algorithm/CentroidPoint.h | 2 +-
include/geos/algorithm/ConvexHull.h | 10 +-
include/geos/algorithm/ConvexHull.inl | 6 +-
include/geos/algorithm/HCoordinate.h | 6 +-
include/geos/algorithm/InteriorPointArea.h | 4 +-
include/geos/algorithm/InteriorPointLine.h | 6 +-
include/geos/algorithm/InteriorPointPoint.h | 2 +-
include/geos/algorithm/LineIntersector.h | 18 +-
include/geos/algorithm/MCPointInRing.h | 8 +-
include/geos/algorithm/MinimumDiameter.h | 47 +-
include/geos/algorithm/NotRepresentableException.h | 4 +-
include/geos/algorithm/PointInRing.h | 2 +-
include/geos/algorithm/PointLocator.h | 5 +-
include/geos/algorithm/RayCrossingCounter.h | 80 +-
include/geos/algorithm/RobustDeterminant.h | 4 +-
include/geos/algorithm/SIRtreePointInRing.h | 5 +-
include/geos/algorithm/SimplePointInRing.h | 6 +-
.../algorithm/distance/DiscreteFrechetDistance.h | 184 +
.../algorithm/distance/DiscreteHausdorffDistance.h | 26 +-
include/geos/algorithm/distance/DistanceToPoint.h | 10 +-
include/geos/algorithm/distance/Makefile.am | 1 +
.../geos/algorithm/distance/PointPairDistance.h | 9 +-
.../algorithm/locate/IndexedPointInAreaLocator.h | 32 +-
.../geos/algorithm/locate/PointOnGeometryLocator.h | 12 +-
.../algorithm/locate/SimplePointInAreaLocator.h | 8 +-
include/geos/geom.h | 6 +-
include/geos/geom/BinaryOp.h | 168 +-
include/geos/geom/Coordinate.h | 10 +-
include/geos/geom/CoordinateArraySequence.h | 50 +-
include/geos/geom/CoordinateArraySequenceFactory.h | 17 +-
.../geos/geom/CoordinateArraySequenceFactory.inl | 7 +-
include/geos/geom/CoordinateFilter.h | 2 +-
include/geos/geom/CoordinateList.h | 24 +-
include/geos/geom/CoordinateSequence.h | 28 +-
include/geos/geom/CoordinateSequenceFactory.h | 12 +-
include/geos/geom/CoordinateSequenceFilter.h | 6 +-
include/geos/geom/Dimension.h | 2 +-
include/geos/geom/Envelope.h | 24 +-
include/geos/geom/Geometry.h | 108 +-
include/geos/geom/GeometryCollection.h | 79 +-
include/geos/geom/GeometryComponentFilter.h | 2 +-
include/geos/geom/GeometryFactory.h | 165 +-
include/geos/geom/GeometryFilter.h | 2 +-
include/geos/geom/GeometryList.h | 83 -
include/geos/geom/IntersectionMatrix.h | 78 +-
include/geos/geom/LineSegment.h | 30 +-
include/geos/geom/LineSegment.inl | 2 +-
include/geos/geom/LineString.h | 87 +-
include/geos/geom/Lineal.h | 15 +-
include/geos/geom/LinearRing.h | 24 +-
include/geos/geom/Location.h | 2 +-
include/geos/geom/Makefile.am | 5 +-
include/geos/geom/MultiLineString.h | 26 +-
include/geos/geom/MultiLineString.inl | 2 +-
include/geos/geom/MultiPoint.h | 22 +-
include/geos/geom/MultiPolygon.h | 24 +-
include/geos/geom/Point.h | 77 +-
include/geos/geom/Polygon.h | 76 +-
include/geos/geom/Polygonal.h | 15 +-
include/geos/geom/PrecisionModel.h | 12 +-
include/geos/geom/PrecisionModel.inl | 2 +-
include/geos/geom/Puntal.h | 15 +-
include/geos/geom/Triangle.h | 12 +-
.../geom/prep/AbstractPreparedPolygonContains.h | 38 +-
include/geos/geom/prep/BasicPreparedGeometry.h | 60 +-
include/geos/geom/prep/PreparedGeometry.h | 66 +-
include/geos/geom/prep/PreparedGeometryFactory.h | 18 +-
include/geos/geom/prep/PreparedLineString.h | 18 +-
.../geos/geom/prep/PreparedLineStringIntersects.h | 28 +-
include/geos/geom/prep/PreparedPoint.h | 14 +-
include/geos/geom/prep/PreparedPolygon.h | 22 +-
include/geos/geom/prep/PreparedPolygonContains.h | 26 +-
.../geom/prep/PreparedPolygonContainsProperly.h | 32 +-
include/geos/geom/prep/PreparedPolygonCovers.h | 30 +-
include/geos/geom/prep/PreparedPolygonIntersects.h | 22 +-
include/geos/geom/prep/PreparedPolygonPredicate.h | 32 +-
.../geos/geom/util/ComponentCoordinateExtracter.h | 14 +-
include/geos/geom/util/CoordinateOperation.h | 8 +-
include/geos/geom/util/GeometryCombiner.h | 22 +-
include/geos/geom/util/GeometryEditor.h | 6 +-
include/geos/geom/util/GeometryEditorOperation.h | 2 +-
include/geos/geom/util/GeometryExtracter.h | 12 +-
include/geos/geom/util/GeometryTransformer.h | 51 +-
include/geos/geom/util/LinearComponentExtracter.h | 10 +-
include/geos/geom/util/PointExtracter.h | 10 +-
include/geos/geom/util/PolygonExtracter.h | 10 +-
.../geos/geom/util/ShortCircuitedGeometryVisitor.h | 2 +-
include/geos/geom/util/SineStarFactory.h | 8 +-
include/geos/geomPrep.h | 4 +-
include/geos/geomUtil.h | 2 +-
include/geos/geomgraph.h | 10 +-
include/geos/geomgraph/Depth.h | 2 +-
include/geos/geomgraph/DirectedEdge.h | 26 +-
include/geos/geomgraph/DirectedEdge.inl | 2 +-
include/geos/geomgraph/DirectedEdgeStar.h | 22 +-
include/geos/geomgraph/Edge.h | 14 +-
include/geos/geomgraph/EdgeEnd.h | 20 +-
include/geos/geomgraph/EdgeEndStar.h | 17 +-
include/geos/geomgraph/EdgeIntersection.h | 6 +-
include/geos/geomgraph/EdgeIntersectionList.h | 4 +-
include/geos/geomgraph/EdgeList.h | 8 +-
include/geos/geomgraph/EdgeNodingValidator.h | 4 +-
include/geos/geomgraph/EdgeRing.h | 12 +-
include/geos/geomgraph/GeometryGraph.h | 45 +-
include/geos/geomgraph/GeometryGraph.inl | 10 +-
include/geos/geomgraph/GraphComponent.h | 10 +-
include/geos/geomgraph/Label.h | 10 +-
include/geos/geomgraph/Node.h | 16 +-
include/geos/geomgraph/NodeFactory.h | 2 +-
include/geos/geomgraph/NodeMap.h | 6 +-
include/geos/geomgraph/PlanarGraph.h | 10 +-
include/geos/geomgraph/Position.h | 6 +-
include/geos/geomgraph/Quadrant.h | 4 +-
include/geos/geomgraph/TopologyLocation.h | 10 +-
include/geos/geomgraph/index/EdgeSetIntersector.h | 4 +-
include/geos/geomgraph/index/MonotoneChain.h | 4 +-
include/geos/geomgraph/index/MonotoneChainEdge.h | 2 +-
.../geos/geomgraph/index/MonotoneChainIndexer.h | 2 +-
include/geos/geomgraph/index/SegmentIntersector.h | 12 +-
.../geomgraph/index/SimpleEdgeSetIntersector.h | 6 +-
.../geomgraph/index/SimpleMCSweepLineIntersector.h | 11 +-
.../geomgraph/index/SimpleSweepLineIntersector.h | 8 +-
include/geos/geomgraph/index/SweepLineEvent.h | 6 +-
include/geos/geomgraph/index/SweepLineEventObj.h | 4 +-
include/geos/geomgraph/index/SweepLineSegment.h | 4 +-
include/geos/geomgraphindex.h | 8 +-
include/geos/geosAlgorithm.h | 20 +-
include/geos/index/ItemVisitor.h | 2 +-
include/geos/index/SpatialIndex.h | 6 +-
include/geos/index/bintree/Bintree.h | 8 +-
include/geos/index/bintree/Interval.h | 2 +-
include/geos/index/bintree/Key.h | 6 +-
include/geos/index/bintree/Node.h | 10 +-
include/geos/index/bintree/NodeBase.h | 8 +-
include/geos/index/bintree/Root.h | 10 +-
include/geos/index/chain/MonotoneChain.h | 22 +-
include/geos/index/chain/MonotoneChainBuilder.h | 8 +-
.../geos/index/chain/MonotoneChainOverlapAction.h | 6 +-
.../geos/index/chain/MonotoneChainSelectAction.h | 6 +-
.../index/intervalrtree/IntervalRTreeBranchNode.h | 8 +-
.../index/intervalrtree/IntervalRTreeLeafNode.h | 8 +-
.../geos/index/intervalrtree/IntervalRTreeNode.h | 28 +-
.../intervalrtree/SortedPackedIntervalRTree.h | 24 +-
include/geos/index/quadtree/DoubleBits.h | 4 +-
include/geos/index/quadtree/IntervalSize.h | 2 +-
include/geos/index/quadtree/Key.h | 6 +-
include/geos/index/quadtree/Node.h | 24 +-
include/geos/index/quadtree/NodeBase.h | 10 +-
include/geos/index/quadtree/Quadtree.h | 20 +-
include/geos/index/quadtree/Root.h | 6 +-
include/geos/index/strtree/AbstractNode.h | 14 +-
include/geos/index/strtree/AbstractSTRtree.h | 46 +-
include/geos/index/strtree/Boundable.h | 2 +-
include/geos/index/strtree/BoundablePair.h | 111 +
include/geos/index/strtree/GeometryItemDistance.h | 45 +
include/geos/index/strtree/Interval.h | 2 +-
include/geos/index/strtree/ItemBoundable.h | 8 +-
include/geos/index/strtree/ItemDistance.h | 44 +
include/geos/index/strtree/Makefile.am | 3 +
include/geos/index/strtree/SIRtree.h | 18 +-
include/geos/index/strtree/STRtree.h | 51 +-
include/geos/index/sweepline/SweepLineEvent.h | 6 +-
include/geos/index/sweepline/SweepLineIndex.h | 4 +-
include/geos/index/sweepline/SweepLineInterval.h | 4 +-
.../geos/index/sweepline/SweepLineOverlapAction.h | 4 +-
include/geos/indexBintree.h | 2 +-
include/geos/indexChain.h | 2 +-
include/geos/indexIntervalRTree.h | 4 +-
include/geos/indexQuadtree.h | 2 +-
include/geos/indexStrtree.h | 2 +-
include/geos/indexSweepline.h | 2 +-
include/geos/inline.h | 2 +-
include/geos/io.h | 2 +-
include/geos/io/ByteOrderDataInStream.h | 6 +-
include/geos/io/ByteOrderValues.h | 6 +-
include/geos/io/CLocalizer.h | 2 +-
include/geos/io/ParseException.h | 4 +-
include/geos/io/StringTokenizer.h | 8 +-
include/geos/io/WKBConstants.h | 4 +-
include/geos/io/WKBReader.h | 12 +-
include/geos/io/WKBWriter.h | 18 +-
include/geos/io/WKTReader.h | 6 +-
include/geos/io/WKTWriter.h | 26 +-
include/geos/io/Writer.h | 2 +-
include/geos/linearref/LengthIndexOfPoint.h | 2 +-
include/geos/linearref/LengthIndexedLine.h | 2 +-
include/geos/linearref/LengthLocationMap.h | 8 +-
include/geos/linearref/LinearIterator.h | 4 +-
include/geos/linearref/LinearLocation.h | 6 +-
include/geos/linearref/LocationIndexOfLine.h | 2 +-
include/geos/linearref/LocationIndexOfPoint.h | 2 +-
include/geos/linearref/LocationIndexedLine.h | 2 +-
include/geos/noding.h | 2 +-
include/geos/noding/BasicSegmentString.h | 20 +-
include/geos/noding/FastNodingValidator.h | 32 +-
.../geos/noding/FastSegmentSetIntersectionFinder.h | 10 +-
include/geos/noding/GeometryNoder.h | 14 +-
include/geos/noding/IntersectionAdder.h | 18 +-
include/geos/noding/IntersectionFinderAdder.h | 14 +-
include/geos/noding/IteratedNoder.h | 14 +-
include/geos/noding/MCIndexNoder.h | 20 +-
.../noding/MCIndexSegmentSetMutualIntersector.h | 34 +-
include/geos/noding/NodableSegmentString.h | 10 +-
include/geos/noding/NodedSegmentString.h | 32 +-
include/geos/noding/Noder.h | 2 +-
include/geos/noding/NodingValidator.h | 6 +-
include/geos/noding/Octant.h | 10 +-
include/geos/noding/OrientedCoordinateArray.h | 230 +-
include/geos/noding/ScaledNoder.h | 12 +-
include/geos/noding/SegmentIntersectionDetector.h | 64 +-
include/geos/noding/SegmentIntersector.h | 8 +-
include/geos/noding/SegmentNode.h | 12 +-
include/geos/noding/SegmentNodeList.h | 12 +-
include/geos/noding/SegmentPointComparator.h | 8 +-
include/geos/noding/SegmentSetMutualIntersector.h | 10 +-
include/geos/noding/SegmentString.h | 8 +-
include/geos/noding/SegmentStringUtil.h | 8 +-
include/geos/noding/SimpleNoder.h | 8 +-
.../geos/noding/SingleInteriorIntersectionFinder.h | 32 +-
include/geos/noding/SinglePassNoder.h | 12 +-
include/geos/noding/snapround/HotPixel.h | 24 +-
.../geos/noding/snapround/MCIndexPointSnapper.h | 10 +-
include/geos/noding/snapround/MCIndexSnapRounder.h | 22 +-
include/geos/noding/snapround/SimpleSnapRounder.h | 10 +-
include/geos/nodingSnapround.h | 2 +-
include/geos/opBuffer.h | 4 +-
include/geos/opDistance.h | 2 +-
include/geos/opLinemerge.h | 2 +-
include/geos/opOverlay.h | 18 +-
include/geos/opPolygonize.h | 2 +-
include/geos/opPredicate.h | 2 +-
include/geos/opRelate.h | 14 +-
include/geos/opValid.h | 2 +-
include/geos/operation.h | 2 +-
include/geos/operation/GeometryGraphOperation.h | 4 +-
include/geos/operation/IsSimpleOp.h | 18 +-
include/geos/operation/Makefile.am | 1 +
include/geos/operation/buffer/BufferBuilder.h | 24 +-
.../operation/buffer/BufferInputLineSimplifier.h | 22 +-
include/geos/operation/buffer/BufferOp.h | 24 +-
include/geos/operation/buffer/BufferParameters.h | 14 +-
include/geos/operation/buffer/BufferSubgraph.h | 8 +-
include/geos/operation/buffer/OffsetCurveBuilder.h | 18 +-
.../geos/operation/buffer/OffsetCurveSetBuilder.h | 8 +-
.../geos/operation/buffer/OffsetSegmentGenerator.h | 28 +-
.../geos/operation/buffer/OffsetSegmentString.h | 32 +-
.../geos/operation/buffer/RightmostEdgeFinder.h | 2 +-
.../geos/operation/buffer/SubgraphDepthLocater.h | 2 +-
.../distance/ConnectedElementLocationFilter.h | 16 +-
.../distance/ConnectedElementPointFilter.h | 6 +-
include/geos/operation/distance/DistanceOp.h | 22 +-
include/geos/operation/distance/FacetSequence.h | 64 +
.../operation/distance/FacetSequenceTreeBuilder.h | 48 +
include/geos/operation/distance/GeometryLocation.h | 10 +-
.../geos/operation/distance/IndexedFacetDistance.h | 47 +
include/geos/operation/distance/Makefile.am | 3 +
include/geos/operation/intersection/Makefile.am | 13 +
include/geos/operation/intersection/Rectangle.h | 209 +
.../operation/intersection/RectangleIntersection.h | 179 +
.../intersection/RectangleIntersectionBuilder.h | 161 +
include/geos/operation/linemerge/EdgeString.h | 12 +-
.../operation/linemerge/LineMergeDirectedEdge.h | 14 +-
include/geos/operation/linemerge/LineMergeEdge.h | 6 +-
include/geos/operation/linemerge/LineMergeGraph.h | 18 +-
include/geos/operation/linemerge/LineMerger.h | 16 +-
include/geos/operation/linemerge/LineSequencer.h | 28 +-
include/geos/operation/overlay/EdgeSetNoder.h | 2 +-
include/geos/operation/overlay/ElevationMatrix.h | 14 +-
.../geos/operation/overlay/ElevationMatrixCell.h | 2 +-
include/geos/operation/overlay/LineBuilder.h | 12 +-
include/geos/operation/overlay/MaximalEdgeRing.h | 14 +-
include/geos/operation/overlay/MinimalEdgeRing.h | 10 +-
.../geos/operation/overlay/OverlayNodeFactory.h | 4 +-
include/geos/operation/overlay/OverlayOp.h | 31 +-
include/geos/operation/overlay/PointBuilder.h | 6 +-
include/geos/operation/overlay/PolygonBuilder.h | 8 +-
.../geos/operation/overlay/snap/GeometrySnapper.h | 20 +-
.../operation/overlay/snap/LineStringSnapper.h | 14 +-
.../operation/overlay/snap/SnapIfNeededOverlayOp.h | 28 +-
.../geos/operation/overlay/snap/SnapOverlayOp.h | 32 +-
.../operation/overlay/validate/FuzzyPointLocator.h | 16 +-
.../overlay/validate/OffsetPointGenerator.h | 16 +-
.../overlay/validate/OverlayResultValidator.h | 6 +-
include/geos/operation/polygonize/EdgeRing.h | 10 +-
.../operation/polygonize/PolygonizeDirectedEdge.h | 10 +-
include/geos/operation/polygonize/PolygonizeEdge.h | 4 +-
.../geos/operation/polygonize/PolygonizeGraph.h | 12 +-
include/geos/operation/polygonize/Polygonizer.h | 16 +-
.../geos/operation/predicate/RectangleContains.h | 8 +-
.../geos/operation/predicate/RectangleIntersects.h | 12 +-
.../predicate/SegmentIntersectionTester.h | 4 +-
include/geos/operation/relate/EdgeEndBuilder.h | 2 +-
include/geos/operation/relate/EdgeEndBundle.h | 14 +-
include/geos/operation/relate/EdgeEndBundleStar.h | 8 +-
include/geos/operation/relate/RelateComputer.h | 10 +-
include/geos/operation/relate/RelateNode.h | 6 +-
include/geos/operation/relate/RelateNodeFactory.h | 4 +-
include/geos/operation/relate/RelateNodeGraph.h | 4 +-
include/geos/operation/relate/RelateOp.h | 6 +-
include/geos/operation/sharedpaths/SharedPathsOp.h | 16 +-
.../geos/operation/union/CascadedPolygonUnion.h | 71 +-
include/geos/operation/union/CascadedUnion.h | 42 +-
include/geos/operation/union/GeometryListHolder.h | 12 +-
include/geos/operation/union/PointGeometryUnion.h | 12 +-
include/geos/operation/union/UnaryUnionOp.h | 28 +-
.../geos/operation/valid/ConnectedInteriorTester.h | 17 +-
.../geos/operation/valid/ConsistentAreaTester.h | 12 +-
include/geos/operation/valid/IsValidOp.h | 22 +-
.../operation/valid/QuadtreeNestedRingTester.h | 2 +-
include/geos/operation/valid/RepeatedPointTester.h | 2 +-
.../geos/operation/valid/SimpleNestedRingTester.h | 4 +-
.../operation/valid/SweeplineNestedRingTester.h | 8 +-
.../geos/operation/valid/TopologyValidationError.h | 2 +-
include/geos/planargraph.h | 2 +-
include/geos/planargraph/DirectedEdge.h | 14 +-
include/geos/planargraph/DirectedEdgeStar.h | 8 +-
include/geos/planargraph/Edge.h | 8 +-
include/geos/planargraph/GraphComponent.h | 4 +-
include/geos/planargraph/Node.h | 14 +-
include/geos/planargraph/NodeMap.h | 6 +-
include/geos/planargraph/PlanarGraph.h | 10 +-
include/geos/planargraph/Subgraph.h | 22 +-
.../algorithm/ConnectedSubgraphFinder.h | 10 +-
include/geos/platform.h.cmake | 159 +-
include/geos/platform.h.in | 6 +-
include/geos/precision.h | 2 +-
include/geos/precision/CommonBits.h | 2 +-
include/geos/precision/CommonBitsOp.h | 14 +-
include/geos/precision/CommonBitsRemover.h | 2 +-
include/geos/precision/EnhancedPrecisionOp.h | 2 +-
include/geos/precision/GeometryPrecisionReducer.h | 25 +-
include/geos/precision/Makefile.am | 1 +
include/geos/precision/MinimumClearance.h | 60 +
.../PrecisionReducerCoordinateOperation.h | 8 +-
.../precision/SimpleGeometryPrecisionReducer.h | 6 +-
include/geos/profiler.h | 23 +-
.../geos/simplify/DouglasPeuckerLineSimplifier.h | 16 +-
include/geos/simplify/DouglasPeuckerSimplifier.h | 10 +-
include/geos/simplify/LineSegmentIndex.h | 10 +-
include/geos/simplify/TaggedLineSegment.h | 6 +-
include/geos/simplify/TaggedLineString.h | 14 +-
include/geos/simplify/TaggedLineStringSimplifier.h | 8 +-
include/geos/simplify/TaggedLinesSimplifier.h | 10 +-
.../geos/simplify/TopologyPreservingSimplifier.h | 16 +-
include/geos/spatialIndex.h | 2 +-
include/geos/timeval.h | 20 +-
.../triangulate/DelaunayTriangulationBuilder.h | 58 +-
.../triangulate/IncrementalDelaunayTriangulator.h | 14 +-
include/geos/triangulate/VoronoiDiagramBuilder.h | 52 +-
.../quadedge/LastFoundQuadEdgeLocator.h | 8 +-
.../triangulate/quadedge/LocateFailureException.h | 2 +-
include/geos/triangulate/quadedge/QuadEdge.h | 90 +-
.../geos/triangulate/quadedge/QuadEdgeLocator.h | 8 +-
.../triangulate/quadedge/QuadEdgeSubdivision.h | 136 +-
.../geos/triangulate/quadedge/TrianglePredicate.h | 38 +-
.../geos/triangulate/quadedge/TriangleVisitor.h | 8 +-
include/geos/triangulate/quadedge/Vertex.h | 82 +-
include/geos/unload.h | 2 +-
include/geos/util.h | 6 +-
include/geos/util/Assert.h | 2 +-
include/geos/util/AssertionFailedException.h | 4 +-
include/geos/util/CoordinateArrayFilter.h | 4 +-
include/geos/util/GEOSException.h | 7 +-
include/geos/util/GeometricShapeFactory.h | 8 +-
include/geos/util/IllegalArgumentException.h | 6 +-
include/geos/util/IllegalStateException.h | 6 +-
include/geos/util/Interrupt.h | 6 +-
include/geos/util/Machine.h | 2 +-
include/geos/util/TopologyException.h | 4 +-
include/geos/util/UniqueCoordinateArrayFilter.h | 12 +-
include/geos/util/UnsupportedOperationException.h | 4 +-
include/geos/util/math.h | 2 +-
include/geos/version.h.in | 2 +-
include/geos/version.h.vc | 6 +-
macros/ax_check_compile_flag.m4 | 74 +
macros/ax_cxx_compile_stdcxx.m4 | 562 +
macros/ax_cxx_compile_stdcxx_11.m4 | 39 +
macros/python.m4 | 127 +-
macros/ruby.m4 | 26 +-
nmake.opt | 46 +-
php/Makefile.am | 62 -
php/README | 48 -
php/TODO | 11 -
php/geos.c | 2843 --
php/php_geos.h | 41 -
php/test/Makefile.am | 52 -
php/test/crashme.php | 25 -
php/test/test.php | 2355 --
src/CMakeLists.txt | 147 +-
src/Makefile.am | 5 +-
src/Makefile.vc | 37 +-
src/algorithm/Angle.cpp | 10 +-
src/algorithm/BoundaryNodeRule.cpp | 14 +-
src/algorithm/CGAlgorithms.cpp | 35 +-
src/algorithm/Centroid.cpp | 16 +-
src/algorithm/CentroidArea.cpp | 4 +-
src/algorithm/CentroidLine.cpp | 2 +-
src/algorithm/CentroidPoint.cpp | 2 +-
src/algorithm/ConvexHull.cpp | 35 +-
src/algorithm/HCoordinate.cpp | 4 +-
src/algorithm/InteriorPointArea.cpp | 24 +-
src/algorithm/InteriorPointLine.cpp | 2 +-
src/algorithm/InteriorPointPoint.cpp | 2 +-
src/algorithm/LineIntersector.cpp | 64 +-
src/algorithm/MCPointInRing.cpp | 10 +-
src/algorithm/MinimumDiameter.cpp | 167 +-
src/algorithm/NotRepresentableException.cpp | 4 +-
src/algorithm/PointLocator.cpp | 23 +-
src/algorithm/RayCrossingCounter.cpp | 88 +-
src/algorithm/RobustDeterminant.cpp | 9 +-
src/algorithm/SIRtreePointInRing.cpp | 9 +-
src/algorithm/SimplePointInRing.cpp | 2 +-
src/algorithm/distance/DiscreteFrechetDistance.cpp | 156 +
.../distance/DiscreteHausdorffDistance.cpp | 12 +-
src/algorithm/distance/DistanceToPoint.cpp | 4 +-
src/algorithm/distance/Makefile.am | 1 +
src/algorithm/locate/IndexedPointInAreaLocator.cpp | 36 +-
src/algorithm/locate/PointOnGeometryLocator.cpp | 2 +-
src/algorithm/locate/SimplePointInAreaLocator.cpp | 6 +-
src/dirlist.mk | 1 +
src/geom/Coordinate.cpp | 6 +-
src/geom/CoordinateArraySequence.cpp | 8 +-
src/geom/CoordinateArraySequenceFactory.cpp | 2 +-
src/geom/CoordinateSequence.cpp | 16 +-
src/geom/CoordinateSequenceFactory.cpp | 2 +-
src/geom/Dimension.cpp | 2 +-
src/geom/Envelope.cpp | 21 +-
src/geom/Geometry.cpp | 117 +-
src/geom/GeometryCollection.cpp | 36 +-
src/geom/GeometryComponentFilter.cpp | 2 +-
src/geom/GeometryFactory.cpp | 174 +-
src/geom/GeometryList.cpp | 80 -
src/geom/IntersectionMatrix.cpp | 20 +-
src/geom/LineSegment.cpp | 16 +-
src/geom/LineString.cpp | 34 +-
src/geom/LinearRing.cpp | 16 +-
src/geom/Location.cpp | 2 +-
src/geom/Makefile.am | 5 +-
src/geom/MultiLineString.cpp | 12 +-
src/geom/MultiPoint.cpp | 4 +-
src/geom/MultiPolygon.cpp | 24 +-
src/geom/Point.cpp | 33 +-
src/geom/Polygon.cpp | 48 +-
src/geom/PrecisionModel.cpp | 10 +-
src/geom/Triangle.cpp | 10 +-
src/geom/prep/AbstractPreparedPolygonContains.cpp | 56 +-
src/geom/prep/BasicPreparedGeometry.cpp | 40 +-
src/geom/prep/PreparedGeometry.cpp | 2 +-
src/geom/prep/PreparedGeometryFactory.cpp | 6 +-
src/geom/prep/PreparedLineString.cpp | 10 +-
src/geom/prep/PreparedLineStringIntersects.cpp | 20 +-
src/geom/prep/PreparedPoint.cpp | 6 +-
src/geom/prep/PreparedPolygon.cpp | 40 +-
src/geom/prep/PreparedPolygonContains.cpp | 4 +-
src/geom/prep/PreparedPolygonContainsProperly.cpp | 18 +-
src/geom/prep/PreparedPolygonCovers.cpp | 4 +-
src/geom/prep/PreparedPolygonIntersects.cpp | 22 +-
src/geom/prep/PreparedPolygonPredicate.cpp | 12 +-
src/geom/util/ComponentCoordinateExtracter.cpp | 10 +-
src/geom/util/CoordinateOperation.cpp | 2 +-
src/geom/util/GeometryCombiner.cpp | 22 +-
src/geom/util/GeometryEditor.cpp | 24 +-
src/geom/util/GeometryTransformer.cpp | 135 +-
src/geom/util/LinearComponentExtracter.cpp | 2 +-
src/geom/util/PointExtracter.cpp | 2 +-
src/geom/util/PolygonExtracter.cpp | 4 +-
src/geom/util/ShortCircuitedGeometryVisitor.cpp | 4 +-
src/geom/util/SineStarFactory.cpp | 16 +-
src/geomgraph/Depth.cpp | 2 +-
src/geomgraph/DirectedEdge.cpp | 18 +-
src/geomgraph/DirectedEdgeStar.cpp | 46 +-
src/geomgraph/Edge.cpp | 30 +-
src/geomgraph/EdgeEnd.cpp | 18 +-
src/geomgraph/EdgeEndStar.cpp | 42 +-
src/geomgraph/EdgeIntersectionList.cpp | 6 +-
src/geomgraph/EdgeList.cpp | 8 +-
src/geomgraph/EdgeNodingValidator.cpp | 2 +-
src/geomgraph/EdgeRing.cpp | 28 +-
src/geomgraph/GeometryGraph.cpp | 108 +-
src/geomgraph/GraphComponent.cpp | 4 +-
src/geomgraph/Label.cpp | 4 +-
src/geomgraph/Node.cpp | 6 +-
src/geomgraph/NodeFactory.cpp | 6 +-
src/geomgraph/NodeMap.cpp | 8 +-
src/geomgraph/PlanarGraph.cpp | 46 +-
src/geomgraph/Position.cpp | 2 +-
src/geomgraph/Quadrant.cpp | 2 +-
src/geomgraph/TopologyLocation.cpp | 2 +-
src/geomgraph/index/MonotoneChainEdge.cpp | 10 +-
src/geomgraph/index/MonotoneChainIndexer.cpp | 2 +-
src/geomgraph/index/SegmentIntersector.cpp | 20 +-
src/geomgraph/index/SimpleEdgeSetIntersector.cpp | 10 +-
.../index/SimpleMCSweepLineIntersector.cpp | 24 +-
src/geomgraph/index/SimpleSweepLineIntersector.cpp | 10 +-
src/geomgraph/index/SweepLineEvent.cpp | 6 +-
src/geomgraph/index/SweepLineSegment.cpp | 2 +-
src/index/bintree/Bintree.cpp | 8 +-
src/index/bintree/Interval.cpp | 12 +-
src/index/bintree/Key.cpp | 4 +-
src/index/bintree/Node.cpp | 12 +-
src/index/bintree/NodeBase.cpp | 20 +-
src/index/bintree/Root.cpp | 6 +-
src/index/chain/MonotoneChain.cpp | 20 +-
src/index/chain/MonotoneChainBuilder.cpp | 10 +-
src/index/chain/MonotoneChainOverlapAction.cpp | 2 +-
src/index/chain/MonotoneChainSelectAction.cpp | 2 +-
.../intervalrtree/IntervalRTreeBranchNode.cpp | 12 +-
src/index/intervalrtree/IntervalRTreeLeafNode.cpp | 8 +-
src/index/intervalrtree/IntervalRTreeNode.cpp | 2 +-
.../intervalrtree/SortedPackedIntervalRTree.cpp | 30 +-
src/index/quadtree/DoubleBits.cpp | 4 +-
src/index/quadtree/IntervalSize.cpp | 2 +-
src/index/quadtree/Key.cpp | 6 +-
src/index/quadtree/Node.cpp | 45 +-
src/index/quadtree/NodeBase.cpp | 40 +-
src/index/quadtree/Quadtree.cpp | 2 +-
src/index/quadtree/Root.cpp | 12 +-
src/index/strtree/AbstractNode.cpp | 8 +-
src/index/strtree/AbstractSTRtree.cpp | 57 +-
src/index/strtree/BoundablePair.cpp | 117 +
src/index/strtree/GeometryItemDistance.cpp | 30 +
src/index/strtree/Interval.cpp | 2 +-
src/index/strtree/ItemBoundable.cpp | 2 +-
src/index/strtree/Makefile.am | 4 +-
src/index/strtree/SIRtree.cpp | 20 +-
src/index/strtree/STRtree.cpp | 141 +-
src/index/sweepline/SweepLineEvent.cpp | 8 +-
src/index/sweepline/SweepLineIndex.cpp | 6 +-
src/index/sweepline/SweepLineInterval.cpp | 2 +-
src/inlines.cpp | 11 +-
src/io/ByteOrderDataInStream.cpp | 2 +-
src/io/ByteOrderValues.cpp | 2 +-
src/io/CLocalizer.cpp | 10 +-
src/io/ParseException.cpp | 2 +-
src/io/StringTokenizer.cpp | 48 +-
src/io/Unload.cpp | 2 +-
src/io/WKBReader.cpp | 17 +-
src/io/WKBWriter.cpp | 82 +-
src/io/WKTReader.cpp | 102 +-
src/io/WKTWriter.cpp | 53 +-
src/io/Writer.cpp | 2 +-
src/linearref/ExtractLineByLocation.cpp | 10 +-
src/linearref/LengthIndexOfPoint.cpp | 2 +-
src/linearref/LengthIndexedLine.cpp | 2 +-
src/linearref/LengthLocationMap.cpp | 4 +-
src/linearref/LinearGeometryBuilder.cpp | 8 +-
src/linearref/LinearIterator.cpp | 8 +-
src/linearref/LinearLocation.cpp | 37 +-
src/linearref/LocationIndexOfLine.cpp | 2 +-
src/linearref/LocationIndexOfPoint.cpp | 4 +-
src/noding/BasicSegmentString.cpp | 4 +-
src/noding/FastNodingValidator.cpp | 4 +-
src/noding/FastSegmentSetIntersectionFinder.cpp | 8 +-
src/noding/GeometryNoder.cpp | 42 +-
src/noding/IntersectionAdder.cpp | 8 +-
src/noding/IntersectionFinderAdder.cpp | 2 +-
src/noding/IteratedNoder.cpp | 10 +-
src/noding/MCIndexNoder.cpp | 10 +-
src/noding/MCIndexSegmentSetMutualIntersector.cpp | 27 +-
src/noding/NodedSegmentString.cpp | 6 +-
src/noding/NodingValidator.cpp | 26 +-
src/noding/Octant.cpp | 4 +-
src/noding/OrientedCoordinateArray.cpp | 197 +-
src/noding/ScaledNoder.cpp | 14 +-
src/noding/SegmentIntersectionDetector.cpp | 18 +-
src/noding/SegmentNode.cpp | 2 +-
src/noding/SegmentNodeList.cpp | 18 +-
src/noding/SegmentString.cpp | 4 +-
src/noding/SegmentStringUtil.cpp | 2 +-
src/noding/SimpleNoder.cpp | 8 +-
src/noding/SingleInteriorIntersectionFinder.cpp | 8 +-
src/noding/snapround/HotPixel.cpp | 22 +-
src/noding/snapround/MCIndexPointSnapper.cpp | 20 +-
src/noding/snapround/MCIndexSnapRounder.cpp | 12 +-
src/noding/snapround/SimpleSnapRounder.cpp | 10 +-
src/operation/GeometryGraphOperation.cpp | 2 +-
src/operation/IsSimpleOp.cpp | 18 +-
src/operation/Makefile.am | 2 +
src/operation/buffer/BufferBuilder.cpp | 95 +-
src/operation/buffer/BufferInputLineSimplifier.cpp | 10 +-
src/operation/buffer/BufferOp.cpp | 25 +-
src/operation/buffer/BufferParameters.cpp | 4 +-
src/operation/buffer/BufferSubgraph.cpp | 18 +-
src/operation/buffer/OffsetCurveBuilder.cpp | 44 +-
src/operation/buffer/OffsetCurveSetBuilder.cpp | 9 +-
src/operation/buffer/OffsetSegmentGenerator.cpp | 2 +-
src/operation/buffer/RightmostEdgeFinder.cpp | 14 +-
src/operation/buffer/SubgraphDepthLocater.cpp | 10 +-
.../distance/ConnectedElementLocationFilter.cpp | 2 +-
.../distance/ConnectedElementPointFilter.cpp | 2 +-
src/operation/distance/DistanceOp.cpp | 46 +-
src/operation/distance/FacetSequence.cpp | 118 +
.../distance/FacetSequenceTreeBuilder.cpp | 88 +
src/operation/distance/GeometryLocation.cpp | 14 +-
src/operation/distance/IndexedFacetDistance.cpp | 63 +
src/operation/distance/Makefile.am | 3 +
src/operation/intersection/Makefile.am | 15 +
src/operation/intersection/Rectangle.cpp | 65 +
.../intersection/RectangleIntersection.cpp | 709 +
.../intersection/RectangleIntersectionBuilder.cpp | 517 +
src/operation/linemerge/EdgeString.cpp | 10 +-
src/operation/linemerge/LineMergeDirectedEdge.cpp | 6 +-
src/operation/linemerge/LineMergeEdge.cpp | 2 +-
src/operation/linemerge/LineMergeGraph.cpp | 8 +-
src/operation/linemerge/LineMerger.cpp | 32 +-
src/operation/linemerge/LineSequencer.cpp | 60 +-
src/operation/overlay/EdgeSetNoder.cpp | 2 +-
src/operation/overlay/ElevationMatrix.cpp | 4 +-
src/operation/overlay/ElevationMatrixCell.cpp | 9 +-
src/operation/overlay/LineBuilder.cpp | 27 +-
src/operation/overlay/Makefile.am | 3 +
src/operation/overlay/MaximalEdgeRing.cpp | 6 +-
src/operation/overlay/MinimalEdgeRing.cpp | 2 +-
src/operation/overlay/OverlayNodeFactory.cpp | 4 +-
src/operation/overlay/OverlayOp.cpp | 133 +-
src/operation/overlay/PointBuilder.cpp | 6 +-
src/operation/overlay/PolygonBuilder.cpp | 26 +-
src/operation/overlay/snap/GeometrySnapper.cpp | 48 +-
src/operation/overlay/snap/LineStringSnapper.cpp | 31 +-
.../overlay/snap/SnapIfNeededOverlayOp.cpp | 12 +-
src/operation/overlay/snap/SnapOverlayOp.cpp | 10 +-
.../overlay/validate/FuzzyPointLocator.cpp | 20 +-
.../overlay/validate/OffsetPointGenerator.cpp | 19 +-
.../overlay/validate/OverlayResultValidator.cpp | 39 +-
src/operation/polygonize/EdgeRing.cpp | 32 +-
.../polygonize/PolygonizeDirectedEdge.cpp | 14 +-
src/operation/polygonize/PolygonizeEdge.cpp | 2 +-
src/operation/polygonize/PolygonizeGraph.cpp | 54 +-
src/operation/polygonize/Polygonizer.cpp | 57 +-
src/operation/predicate/RectangleContains.cpp | 8 +-
src/operation/predicate/RectangleIntersects.cpp | 22 +-
.../predicate/SegmentIntersectionTester.cpp | 12 +-
src/operation/relate/EdgeEndBuilder.cpp | 26 +-
src/operation/relate/EdgeEndBundle.cpp | 6 +-
src/operation/relate/EdgeEndBundleStar.cpp | 2 +-
src/operation/relate/RelateComputer.cpp | 111 +-
src/operation/relate/RelateNode.cpp | 2 +-
src/operation/relate/RelateNodeFactory.cpp | 4 +-
src/operation/relate/RelateNodeGraph.cpp | 4 +-
src/operation/relate/RelateOp.cpp | 2 +-
src/operation/sharedpaths/SharedPathsOp.cpp | 14 +-
src/operation/union/CascadedPolygonUnion.cpp | 238 +-
src/operation/union/CascadedUnion.cpp | 61 +-
src/operation/union/PointGeometryUnion.cpp | 22 +-
src/operation/union/UnaryUnionOp.cpp | 50 +-
src/operation/valid/ConnectedInteriorTester.cpp | 31 +-
src/operation/valid/ConsistentAreaTester.cpp | 31 +-
src/operation/valid/IndexedNestedRingTester.cpp | 8 +-
src/operation/valid/IndexedNestedRingTester.h | 16 +-
src/operation/valid/IsValidOp.cpp | 116 +-
src/operation/valid/QuadtreeNestedRingTester.cpp | 10 +-
src/operation/valid/RepeatedPointTester.cpp | 22 +-
src/operation/valid/SimpleNestedRingTester.cpp | 4 +-
src/operation/valid/SweeplineNestedRingTester.cpp | 4 +-
src/operation/valid/TopologyValidationError.cpp | 2 +-
src/planargraph/DirectedEdge.cpp | 18 +-
src/planargraph/DirectedEdgeStar.cpp | 10 +-
src/planargraph/Edge.cpp | 6 +-
src/planargraph/Makefile.am | 3 +
src/planargraph/Node.cpp | 6 +-
src/planargraph/NodeMap.cpp | 12 +-
src/planargraph/PlanarGraph.cpp | 8 +-
src/planargraph/Subgraph.cpp | 2 +-
.../algorithm/ConnectedSubgraphFinder.cpp | 10 +-
src/precision/CommonBits.cpp | 4 +-
src/precision/CommonBitsOp.cpp | 28 +-
src/precision/CommonBitsRemover.cpp | 12 +-
src/precision/EnhancedPrecisionOp.cpp | 6 +-
src/precision/GeometryPrecisionReducer.cpp | 28 +-
src/precision/Makefile.am | 1 +
src/precision/MinimumClearance.cpp | 190 +
.../PrecisionReducerCoordinateOperation.cpp | 14 +-
src/precision/SimpleGeometryPrecisionReducer.cpp | 14 +-
src/simplify/DouglasPeuckerLineSimplifier.cpp | 6 +-
src/simplify/DouglasPeuckerSimplifier.cpp | 51 +-
src/simplify/LineSegmentIndex.cpp | 23 +-
src/simplify/TaggedLineSegment.cpp | 6 +-
src/simplify/TaggedLineString.cpp | 22 +-
src/simplify/TaggedLineStringSimplifier.cpp | 39 +-
src/simplify/TaggedLinesSimplifier.cpp | 2 +-
src/simplify/TopologyPreservingSimplifier.cpp | 49 +-
src/triangulate/DelaunayTriangulationBuilder.cpp | 16 +-
.../IncrementalDelaunayTriangulator.cpp | 14 +-
src/triangulate/VoronoiDiagramBuilder.cpp | 45 +-
.../quadedge/LastFoundQuadEdgeLocator.cpp | 6 +-
.../quadedge/LocateFailureException.cpp | 2 +-
src/triangulate/quadedge/QuadEdge.cpp | 26 +-
src/triangulate/quadedge/QuadEdgeLocator.cpp | 2 +-
src/triangulate/quadedge/QuadEdgeSubdivision.cpp | 117 +-
src/triangulate/quadedge/TrianglePredicate.cpp | 20 +-
src/triangulate/quadedge/TriangleVisitor.cpp | 2 +-
src/triangulate/quadedge/Vertex.cpp | 51 +-
src/util/Assert.cpp | 2 +-
src/util/GeometricShapeFactory.cpp | 34 +-
src/util/Interrupt.cpp | 6 +-
src/util/Profiler.cpp | 28 +-
src/util/math.cpp | 6 +-
swig/ruby/Makefile.am | 6 +-
tests/CMakeLists.txt | 5 +-
tests/bigtest/CMakeLists.txt | 24 +-
tests/bigtest/GeometryTestFactory.cpp | 12 +-
tests/bigtest/TestSweepLineSpeed.cpp | 11 +-
tests/bigtest/bigtest.h | 2 +-
tests/bigtest/bug234.cpp | 14 +-
tests/geostest/geostest.c | 8 +-
tests/geostest/test.expected | 2 +
tests/perf/CMakeLists.txt | 34 +
tests/perf/ClassSizes.cpp | 4 +-
tests/perf/Makefile.am | 4 +-
tests/perf/capi/CMakeLists.txt | 18 +
tests/perf/operation/CMakeLists.txt | 15 +
tests/perf/operation/buffer/CMakeLists.txt | 21 +
.../operation/buffer/IteratedBufferStressTest.cpp | 12 +-
tests/perf/operation/predicate/CMakeLists.txt | 21 +
.../predicate/RectangleIntersectsPerfTest.cpp | 24 +-
tests/thread/badthreadtest.c | 2 +-
tests/thread/threadtest.c | 2 +-
tests/unit/CMakeLists.txt | 23 +-
tests/unit/Makefile.am | 34 +-
tests/unit/algorithm/AngleTest.cpp | 6 +-
.../CGAlgorithms/computeOrientationTest.cpp | 10 +-
tests/unit/algorithm/CGAlgorithms/isCCWTest.cpp | 14 +-
.../algorithm/CGAlgorithms/isPointInRingTest.cpp | 16 +-
.../unit/algorithm/CGAlgorithms/signedAreaTest.cpp | 14 +-
tests/unit/algorithm/ConvexHullTest.cpp | 108 +-
tests/unit/algorithm/InteriorPointAreaTest.cpp | 12 +-
tests/unit/algorithm/MinimumDiameterTest.cpp | 236 +
tests/unit/algorithm/PointLocatorTest.cpp | 31 +-
.../unit/algorithm/RobustLineIntersectionTest.cpp | 60 +-
tests/unit/algorithm/RobustLineIntersectorTest.cpp | 109 +-
...nceTest.cpp => DiscreteFrechetDistanceTest.cpp} | 62 +-
.../distance/DiscreteHausdorffDistanceTest.cpp | 26 +-
tests/unit/capi/GEOSBufferTest.cpp | 100 +-
tests/unit/capi/GEOSCAPIDefinesTest.cpp | 56 +
tests/unit/capi/GEOSClipByRectTest.cpp | 191 +
tests/unit/capi/GEOSContainsTest.cpp | 146 +-
tests/unit/capi/GEOSConvexHullTest.cpp | 162 +-
tests/unit/capi/GEOSCoordSeqTest.cpp | 105 +-
tests/unit/capi/GEOSDelaunayTriangulationTest.cpp | 28 +-
tests/unit/capi/GEOSDistanceTest.cpp | 69 +-
.../{GEOSIntersectsTest.cpp => GEOSEqualsTest.cpp} | 116 +-
...istanceTest.cpp => GEOSFrechetDistanceTest.cpp} | 54 +-
tests/unit/capi/GEOSGeomFromWKBTest.cpp | 20 +-
tests/unit/capi/GEOSGeomToWKTTest.cpp | 44 +-
tests/unit/capi/GEOSGeom_create.cpp | 28 +-
tests/unit/capi/GEOSGeom_createCollection.cpp | 114 +
tests/unit/capi/GEOSGeom_extentTest.cpp | 82 +
.../unit/capi/GEOSGeom_extractUniquePointsTest.cpp | 18 +-
tests/unit/capi/GEOSGeom_setPrecisionTest.cpp | 186 +
tests/unit/capi/GEOSGetCentroidTest.cpp | 36 +-
tests/unit/capi/GEOSHausdorffDistanceTest.cpp | 99 +
tests/unit/capi/GEOSInterruptTest.cpp | 81 +-
tests/unit/capi/GEOSIntersectionTest.cpp | 142 +
tests/unit/capi/GEOSIntersectsTest.cpp | 48 +-
tests/unit/capi/GEOSLineString_PointTest.cpp | 37 +-
tests/unit/capi/GEOSMinimumClearanceTest.cpp | 132 +
tests/unit/capi/GEOSMinimumRectangleTest.cpp | 84 +
tests/unit/capi/GEOSMinimumWidthTest.cpp | 99 +
tests/unit/capi/GEOSNearestPointsTest.cpp | 30 +-
tests/unit/capi/GEOSNodeTest.cpp | 28 +-
tests/unit/capi/GEOSOffsetCurveTest.cpp | 66 +-
tests/unit/capi/GEOSOrientationIndex.cpp | 8 +-
tests/unit/capi/GEOSPointOnSurfaceTest.cpp | 100 +-
.../unit/capi/GEOSPolygonizer_getCutEdgesTest.cpp | 20 +-
tests/unit/capi/GEOSPreparedGeometryTest.cpp | 243 +-
tests/unit/capi/GEOSRelateBoundaryNodeRuleTest.cpp | 12 +-
tests/unit/capi/GEOSRelatePatternMatchTest.cpp | 10 +-
tests/unit/capi/GEOSReverseTest.cpp | 138 +
tests/unit/capi/GEOSSTRtreeTest.cpp | 236 +
tests/unit/capi/GEOSSegmentIntersectionTest.cpp | 83 +
tests/unit/capi/GEOSSharedPathsTest.cpp | 26 +-
tests/unit/capi/GEOSSimplifyTest.cpp | 16 +-
tests/unit/capi/GEOSSnapTest.cpp | 38 +-
tests/unit/capi/GEOSUnaryUnionTest.cpp | 50 +-
tests/unit/capi/GEOSUserDataTest.cpp | 105 +
tests/unit/capi/GEOSVoronoiDiagramTest.cpp | 36 +-
tests/unit/capi/GEOSWithinTest.cpp | 36 +-
tests/unit/capi/GEOSisClosedTest.cpp | 95 +
tests/unit/capi/GEOSisValidDetailTest.cpp | 24 +-
.../geom/CoordinateArraySequenceFactoryTest.cpp | 55 +-
tests/unit/geom/CoordinateArraySequenceTest.cpp | 76 +-
tests/unit/geom/CoordinateListTest.cpp | 26 +-
tests/unit/geom/CoordinateTest.cpp | 12 +-
tests/unit/geom/DimensionTest.cpp | 44 +-
tests/unit/geom/EnvelopeTest.cpp | 6 +-
tests/unit/geom/Geometry/clone.cpp | 42 +-
tests/unit/geom/Geometry/coversTest.cpp | 29 +-
tests/unit/geom/Geometry/equalsTest.cpp | 17 +-
tests/unit/geom/Geometry/isRectangleTest.cpp | 35 +-
tests/unit/geom/Geometry/normalize.cpp | 14 +-
tests/unit/geom/Geometry/touchesTest.cpp | 166 +
tests/unit/geom/GeometryComponentFilterTest.cpp | 95 +
tests/unit/geom/GeometryFactoryTest.cpp | 540 +-
tests/unit/geom/GeometryFilterTest.cpp | 96 +
tests/unit/geom/IntersectionMatrixTest.cpp | 112 +-
tests/unit/geom/LineSegmentTest.cpp | 6 +-
tests/unit/geom/LineStringTest.cpp | 184 +-
tests/unit/geom/LinearRingTest.cpp | 107 +-
tests/unit/geom/LocationTest.cpp | 20 +-
tests/unit/geom/MultiLineStringTest.cpp | 4 +-
tests/unit/geom/MultiPointTest.cpp | 106 +-
tests/unit/geom/MultiPolygonTest.cpp | 4 +-
tests/unit/geom/PointTest.cpp | 142 +-
tests/unit/geom/PolygonTest.cpp | 163 +-
tests/unit/geom/PrecisionModelTest.cpp | 8 +-
tests/unit/geom/TriangleTest.cpp | 10 +-
.../geom/prep/PreparedGeometry/touchesTest.cpp | 134 +
.../unit/geom/prep/PreparedGeometryFactoryTest.cpp | 288 +-
tests/unit/geom/util/GeometryExtracterTest.cpp | 14 +-
tests/unit/geos_unit.cpp | 12 +-
tests/unit/index/quadtree/DoubleBitsTest.cpp | 4 +-
tests/unit/io/ByteOrderValuesTest.cpp | 14 +-
tests/unit/io/WKBReaderTest.cpp | 50 +-
tests/unit/io/WKBWriterTest.cpp | 57 +-
tests/unit/io/WKTReaderTest.cpp | 59 +-
tests/unit/io/WKTWriterTest.cpp | 36 +-
tests/unit/io/WriterTest.cpp | 12 +-
tests/unit/linearref/LengthIndexedLineTest.cpp | 46 +-
tests/unit/noding/BasicSegmentStringTest.cpp | 32 +-
tests/unit/noding/NodedSegmentStringTest.cpp | 32 +-
tests/unit/noding/OrientedCoordinateArray.cpp | 16 +-
tests/unit/noding/SegmentNodeTest.cpp | 46 +-
tests/unit/noding/SegmentPointComparatorTest.cpp | 12 +-
tests/unit/noding/snapround/HotPixelTest.cpp | 4 +-
.../noding/snapround/MCIndexSnapRounderTest.cpp | 30 +-
tests/unit/operation/IsSimpleOpTest.cpp | 18 +-
tests/unit/operation/buffer/BufferBuilderTest.cpp | 258 +-
tests/unit/operation/buffer/BufferOpTest.cpp | 22 +-
.../unit/operation/buffer/BufferParametersTest.cpp | 8 +-
tests/unit/operation/distance/DistanceOpTest.cpp | 20 +-
.../intersection/RectangleIntersectionTest.cpp | 1517 +
tests/unit/operation/linemerge/LineMergerTest.cpp | 82 +-
.../unit/operation/linemerge/LineSequencerTest.cpp | 51 +-
.../unit/operation/overlay/OverlayOpUnionTest.cpp | 66 +
.../operation/overlay/snap/GeometrySnapperTest.cpp | 27 +-
.../overlay/snap/LineStringSnapperTest.cpp | 69 +-
.../overlay/validate/FuzzyPointLocatorTest.cpp | 36 +-
.../overlay/validate/OffsetPointGeneratorTest.cpp | 34 +-
.../validate/OverlayResultValidatorTest.cpp | 14 +-
tests/unit/operation/polygonize/PolygonizeTest.cpp | 28 +-
.../operation/sharedpaths/SharedPathsOpTest.cpp | 27 +-
.../operation/union/CascadedPolygonUnionTest.cpp | 56 +-
tests/unit/operation/union/UnaryUnionOpTest.cpp | 33 +-
tests/unit/operation/valid/IsValidTest.cpp | 15 +-
tests/unit/operation/valid/ValidClosedRingTest.cpp | 23 +-
.../valid/ValidSelfTouchingRingFormingHoleTest.cpp | 13 +-
tests/unit/precision/CommonBitsTest.cpp | 56 +
.../precision/GeometryPrecisionReducerTest.cpp | 23 +-
.../SimpleGeometryPrecisionReducerTest.cpp | 13 +-
.../unit/simplify/DouglasPeuckerSimplifierTest.cpp | 75 +-
.../simplify/TopologyPreservingSimplifierTest.cpp | 24 +-
tests/unit/triangulate/DelaunayTest.cpp | 24 +-
tests/unit/triangulate/VoronoiTest.cpp | 24 +-
.../quadedge/QuadEdgeSubdivisionTest.cpp | 34 +-
tests/unit/triangulate/quadedge/QuadEdgeTest.cpp | 32 +-
tests/unit/triangulate/quadedge/VertexTest.cpp | 6 +-
tests/unit/tut/README | 4 +
tests/unit/tut/tut.hpp | 151 +-
tests/unit/tut/tut_assert.hpp | 155 +-
tests/unit/tut/tut_config.hpp | 6 +
tests/unit/tut/tut_console_reporter.hpp | 109 +-
tests/unit/tut/tut_cppunit_reporter.hpp | 218 +
tests/unit/tut/tut_exception.hpp | 120 +-
tests/unit/tut/tut_fpt.hpp | 181 +
tests/unit/tut/tut_macros.hpp | 71 +
tests/unit/tut/tut_main.hpp | 111 +
tests/unit/tut/tut_posix.hpp | 69 +-
tests/unit/tut/tut_reporter.hpp | 2 +-
tests/unit/tut/tut_restartable.hpp | 9 +-
tests/unit/tut/tut_result.hpp | 84 +-
tests/unit/tut/tut_runner.hpp | 59 +-
tests/unit/tut/tut_xml_reporter.hpp | 310 +
.../unit/util/UniqueCoordinateArrayFilterTest.cpp | 39 +-
tests/unit/utility.h | 51 +-
tests/xmltester/BufferResultMatcher.cpp | 14 +-
tests/xmltester/BufferResultMatcher.h | 4 +-
tests/xmltester/CMakeLists.txt | 28 +-
tests/xmltester/CTS.cpp | 4 +-
tests/xmltester/JTSXMLTester.sh | 49 +
tests/xmltester/Makefile.am | 20 +-
tests/xmltester/SimpleWKTTester.cpp | 8 +-
tests/xmltester/SingleSidedBufferResultMatcher.cpp | 6 +-
tests/xmltester/SingleSidedBufferResultMatcher.h | 4 +-
tests/xmltester/Stackwalker.cpp | 52 +-
tests/xmltester/Stackwalker.h | 2 +-
tests/xmltester/XMLTester.cpp | 338 +-
tests/xmltester/XMLTester.h | 18 +-
tests/xmltester/safe_to_xml.sh | 2 +-
tests/xmltester/tests/general/MISSING | 8 -
.../tests/general/TestPreparedPointPredicate.xml | 34 +
.../tests/general/TestPreparedPolygonPredicate.xml | 191 +
...estPreparedPredicatesWithGeometryCollection.xml | 81 +
tests/xmltester/tests/ticket/bug569.xml | 22 +
tests/xmltester/tests/ticket/bug716.xml | 75 +
tests/xmltester/tests/ticket/bug837.xml | 16 +
tests/xmltester/tinyxml/tinystr.h | 6 +-
tests/xmltester/tinyxml/tinyxml.cpp | 144 +-
tests/xmltester/tinyxml/tinyxml.h | 162 +-
tests/xmltester/tinyxml/tinyxmlparser.cpp | 111 +-
tools/CMakeLists.txt | 2 +-
tools/Makefile.am | 2 +-
tools/build-cmake.bat | 46 +
tools/ci/before_install.sh | 19 -
tools/ci/before_install_autotools.sh | 14 -
tools/ci/before_install_cmake.sh | 14 -
tools/ci/bessie.sh | 15 +
tools/ci/bessie32.sh | 15 +
tools/geos-config.in | 10 +-
tools/geos_svn_revision_cmake.h.in | 1 -
tools/{svn_repo_revision.sh => repo_revision.sh} | 30 +-
web/index.html | 113 -
web/style.css | 8 -
948 files changed, 23811 insertions(+), 44563 deletions(-)
create mode 100644 .drone.yml
create mode 100644 .editorconfig
create mode 100644 .gitlab-ci.yml
delete mode 100644 ChangeLog
delete mode 100644 README
create mode 100644 README.md
create mode 100644 appveyor.yml
delete mode 100644 authors.svn
create mode 100644 cmake/modules/GenerateSourceGroups.cmake
create mode 100644 include/geos/algorithm/distance/DiscreteFrechetDistance.h
delete mode 100644 include/geos/geom/GeometryList.h
create mode 100644 include/geos/index/strtree/BoundablePair.h
create mode 100644 include/geos/index/strtree/GeometryItemDistance.h
create mode 100644 include/geos/index/strtree/ItemDistance.h
create mode 100644 include/geos/operation/distance/FacetSequence.h
create mode 100644 include/geos/operation/distance/FacetSequenceTreeBuilder.h
create mode 100644 include/geos/operation/distance/IndexedFacetDistance.h
create mode 100644 include/geos/operation/intersection/Makefile.am
create mode 100644 include/geos/operation/intersection/Rectangle.h
create mode 100644 include/geos/operation/intersection/RectangleIntersection.h
create mode 100644 include/geos/operation/intersection/RectangleIntersectionBuilder.h
create mode 100644 include/geos/precision/MinimumClearance.h
create mode 100755 macros/ax_check_compile_flag.m4
create mode 100755 macros/ax_cxx_compile_stdcxx.m4
create mode 100755 macros/ax_cxx_compile_stdcxx_11.m4
delete mode 100644 php/Makefile.am
delete mode 100644 php/README
delete mode 100644 php/TODO
delete mode 100644 php/geos.c
delete mode 100644 php/php_geos.h
delete mode 100644 php/test/Makefile.am
delete mode 100644 php/test/crashme.php
delete mode 100644 php/test/test.php
create mode 100644 src/algorithm/distance/DiscreteFrechetDistance.cpp
delete mode 100644 src/geom/GeometryList.cpp
create mode 100644 src/index/strtree/BoundablePair.cpp
create mode 100644 src/index/strtree/GeometryItemDistance.cpp
create mode 100644 src/operation/distance/FacetSequence.cpp
create mode 100644 src/operation/distance/FacetSequenceTreeBuilder.cpp
create mode 100644 src/operation/distance/IndexedFacetDistance.cpp
create mode 100644 src/operation/intersection/Makefile.am
create mode 100644 src/operation/intersection/Rectangle.cpp
create mode 100644 src/operation/intersection/RectangleIntersection.cpp
create mode 100644 src/operation/intersection/RectangleIntersectionBuilder.cpp
create mode 100644 src/precision/MinimumClearance.cpp
create mode 100644 tests/perf/CMakeLists.txt
create mode 100644 tests/perf/capi/CMakeLists.txt
create mode 100644 tests/perf/operation/CMakeLists.txt
create mode 100644 tests/perf/operation/buffer/CMakeLists.txt
create mode 100644 tests/perf/operation/predicate/CMakeLists.txt
create mode 100644 tests/unit/algorithm/MinimumDiameterTest.cpp
copy tests/unit/algorithm/distance/{DiscreteHausdorffDistanceTest.cpp => DiscreteFrechetDistanceTest.cpp} (57%)
create mode 100644 tests/unit/capi/GEOSCAPIDefinesTest.cpp
create mode 100644 tests/unit/capi/GEOSClipByRectTest.cpp
copy tests/unit/capi/{GEOSIntersectsTest.cpp => GEOSEqualsTest.cpp} (53%)
copy tests/unit/capi/{GEOSDistanceTest.cpp => GEOSFrechetDistanceTest.cpp} (50%)
create mode 100644 tests/unit/capi/GEOSGeom_createCollection.cpp
create mode 100644 tests/unit/capi/GEOSGeom_extentTest.cpp
create mode 100644 tests/unit/capi/GEOSGeom_setPrecisionTest.cpp
create mode 100644 tests/unit/capi/GEOSHausdorffDistanceTest.cpp
create mode 100644 tests/unit/capi/GEOSIntersectionTest.cpp
create mode 100644 tests/unit/capi/GEOSMinimumClearanceTest.cpp
create mode 100644 tests/unit/capi/GEOSMinimumRectangleTest.cpp
create mode 100644 tests/unit/capi/GEOSMinimumWidthTest.cpp
create mode 100644 tests/unit/capi/GEOSReverseTest.cpp
create mode 100644 tests/unit/capi/GEOSSTRtreeTest.cpp
create mode 100644 tests/unit/capi/GEOSSegmentIntersectionTest.cpp
create mode 100644 tests/unit/capi/GEOSUserDataTest.cpp
create mode 100644 tests/unit/capi/GEOSisClosedTest.cpp
create mode 100644 tests/unit/geom/Geometry/touchesTest.cpp
create mode 100644 tests/unit/geom/GeometryComponentFilterTest.cpp
create mode 100644 tests/unit/geom/GeometryFilterTest.cpp
create mode 100644 tests/unit/geom/prep/PreparedGeometry/touchesTest.cpp
create mode 100644 tests/unit/operation/intersection/RectangleIntersectionTest.cpp
create mode 100644 tests/unit/operation/overlay/OverlayOpUnionTest.cpp
create mode 100644 tests/unit/precision/CommonBitsTest.cpp
create mode 100644 tests/unit/tut/README
create mode 100644 tests/unit/tut/tut_config.hpp
create mode 100644 tests/unit/tut/tut_cppunit_reporter.hpp
create mode 100644 tests/unit/tut/tut_fpt.hpp
create mode 100644 tests/unit/tut/tut_macros.hpp
create mode 100644 tests/unit/tut/tut_main.hpp
create mode 100644 tests/unit/tut/tut_xml_reporter.hpp
create mode 100755 tests/xmltester/JTSXMLTester.sh
create mode 100644 tests/xmltester/tests/general/TestPreparedPointPredicate.xml
create mode 100644 tests/xmltester/tests/general/TestPreparedPolygonPredicate.xml
create mode 100644 tests/xmltester/tests/general/TestPreparedPredicatesWithGeometryCollection.xml
create mode 100644 tests/xmltester/tests/ticket/bug569.xml
create mode 100644 tests/xmltester/tests/ticket/bug716.xml
create mode 100644 tests/xmltester/tests/ticket/bug837.xml
create mode 100644 tools/build-cmake.bat
delete mode 100755 tools/ci/before_install.sh
delete mode 100755 tools/ci/before_install_autotools.sh
delete mode 100755 tools/ci/before_install_cmake.sh
create mode 100644 tools/ci/bessie.sh
create mode 100644 tools/ci/bessie32.sh
delete mode 100644 tools/geos_svn_revision_cmake.h.in
rename tools/{svn_repo_revision.sh => repo_revision.sh} (71%)
delete mode 100644 web/index.html
delete mode 100644 web/style.css
hooks/post-receive
--
GEOS
More information about the geos-commits
mailing list