├── .travis.yml
├── .gitignore
├── package.json
├── .gitmodules
├── CMakeLists.txt
├── README.md
├── include
    ├── murmur3.h
    └── hyperloglog.hpp
├── t
    ├── HyperLogLogTest.cpp
    └── HyperLogLogHIPTest.cpp
└── Doxyfile


/.travis.yml:
--------------------------------------------------------------------------------
1 | language: cpp
2 | compiler:
3 |   - gcc
4 | os:
5 |   - linux
6 |   - osx
7 | script: cmake ./CMakeLists.txt && make && ctest -VV
8 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | cmake_install.cmake
 2 | CMakeCache.txt
 3 | CTestTestfile.cmake
 4 | Makefile
 5 | Testing
 6 | CMakeFiles
 7 | .cproject
 8 | test_hyperloglog
 9 | test_hyperloglog_hip
10 | tags
11 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "hyperloglog",
 3 |   "version": "1.0.0",
 4 |   "repo": "hideo55/cpp-HyperLogLog",
 5 |   "description": "C++ implementation of HyperLogLog ",
 6 |   "keywords": ["hyperloglog"], 
 7 |   "license": "MIT",
 8 |   "src": ["include/hyperloglog.hpp", "include/murmur3.h"]
 9 | }
10 | 


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
 1 | [submodule "docs"]
 2 | 	path = docs
 3 | 	url = https://github.com/hideo55/cpp-HyperLogLog.git
 4 | [submodule "extlib/igloo"]
 5 | 	path = extlib/igloo
 6 | 	url = https://github.com/joakimkarlsson/igloo.git
 7 | [submodule "extlib/igloo-TapTestListener"]
 8 | 	path = extlib/igloo-TapTestListener
 9 | 	url = https://github.com/hideo55/igloo-TapTestListener.git
10 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | SET (CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
 2 | CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
 3 | 
 4 | SET(CMAKE_CXX_FLAGS_RELEASE "-Wall -O3")
 5 | 
 6 | SET(CMAKE_CXX_FLAGS_DEBUG "-g -Wall -D_DEBUG")
 7 | 
 8 | SET(CMAKE_BUILD_TYPE Release)
 9 | 
10 | SET(CMAKE_CONFIGURATION_TYPES ${CMAKE_BUILD_TYPE} CACHE STRING "" FORCE)
11 | 
12 | PROJECT(HyperLogLog CXX)
13 | 
14 | SET(serial "1.0.0")
15 | 
16 | SET(soserial "1")
17 | 
18 | INCLUDE_DIRECTORIES(include extlib/igloo extlib/igloo-TapTestListener)
19 | 
20 | # Testing
21 | ENABLE_TESTING()
22 | 
23 | ADD_EXECUTABLE(test_hyperloglog t/HyperLogLogTest.cpp)
24 | ADD_EXECUTABLE(test_hyperloglog_hip t/HyperLogLogHIPTest.cpp)
25 | 
26 | ADD_TEST(NAME test_hyperloglog COMMAND test_hyperloglog)
27 | ADD_TEST(NAME test_hyperloglog_hip COMMAND test_hyperloglog_hip)
28 | 
29 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Build Status](https://travis-ci.org/hideo55/cpp-HyperLogLog.svg?branch=master)](https://travis-ci.org/hideo55/cpp-HyperLogLog)
 2 | 
 3 | # HyperLoglog
 4 | 
 5 | C++ implementation of [HyperLogLog](http://algo.inria.fr/flajolet/Publications/FlFuGaMe07.pdf) algorithm and [HIP(Historic Inverse Probability) Estimator](http://arxiv.org/pdf/1306.3284v5.pdf).
 6 | 
 7 | ## Usage
 8 | 
 9 | HyperLoglog is a headers-only library so you just need to include "hyperloglog.hpp" and "murmur3.h" to use this project.
10 | You can use normal HyperLogLog counter class(hll::HyperLogLog) and HyperLogLog counter with HIP Estimator class(hll::HyperLogLogHIP).
11 | 
12 | ```C++
13 | 
14 | #include <vector>
15 | #include <string>
16 | #include <iostream>
17 | #include <fstream>
18 | #include "hyperloglog.hpp"
19 | 
20 | using namespace hll;
21 | 
22 | int main(){
23 |     HyperLogLog hll(10);
24 |     std::vector<string> somedata;
25 | 
26 |     //Load data to somedata
27 | 
28 |     std::vector<std::string>::iterator iter = somedata.begin();
29 |     std::vector<std::string>::iterator iter_end = somedata.end();
30 |     for(;iter != iter_end; ++iter){
31 |         hll.add(iter->c_str(), iter->size());
32 |     }
33 | 
34 |     double cardinality = hll.estimate();
35 | 
36 |     std::cout << "Cardinality:" << cardinality << std::endl;
37 | 
38 |     std::ofstream ofs("path/to/dumpfile");
39 |     hll.dump(ofs); // It can restore by restore().
40 | 
41 |     return 0;
42 | }
43 | ```
44 | 
45 | If you are using [Clib](https://github.com/clibs/clib), you can get source files by `clib install hideo55/cpp-HyperLogLog`.
46 | 
47 | ## Document
48 | 
49 | http://hideo55.github.com/cpp-HyperLogLog/
50 | 
51 | ## Author
52 | 
53 | Hideaki Ohno <hide.o.j55{at}gmail.com>
54 | 
55 | ## Thanks to
56 | 
57 | MurmurHash3([https://github.com/PeterScott/murmur3](https://github.com/PeterScott/murmur3))
58 | 
59 | - Austin Appleby
60 | - Peter Scott
61 | 
62 | ## License 
63 | 
64 | (The MIT License)
65 | 
66 | Copyright (c) 2013 Hideaki Ohno &lt;hide.o.j55{at}gmail.com&gt;
67 | 
68 | Permission is hereby granted, free of charge, to any person obtaining
69 | a copy of this software and associated documentation files (the
70 | 'Software'), to deal in the Software without restriction, including
71 | without limitation the rights to use, copy, modify, merge, publish,
72 | distribute, sublicense, and/or sell copies of the Software, and to
73 | permit persons to whom the Software is furnished to do so, subject to
74 | the following conditions:
75 | 
76 | The above copyright notice and this permission notice shall be
77 | included in all copies or substantial portions of the Software.
78 | 
79 | THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
80 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
81 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
82 | IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
83 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
84 | TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
85 | SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
86 | 


--------------------------------------------------------------------------------
/include/murmur3.h:
--------------------------------------------------------------------------------
  1 | #ifndef MURMUR3_H
  2 | #define MURMUR3_H
  3 | 
  4 | //-----------------------------------------------------------------------------
  5 | // MurmurHash3 was written by Austin Appleby, and is placed in the public
  6 | // domain. The author hereby disclaims copyright to this source code.
  7 | 
  8 | // Note - The x86 and x64 versions do _not_ produce the same results, as the
  9 | // algorithms are optimized for their respective platforms. You can still
 10 | // compile and run any of them on any platform, but your performance with the
 11 | // non-native version will be less than optimal.
 12 | 
 13 | //-----------------------------------------------------------------------------
 14 | // Platform-specific functions and macros
 15 | 
 16 | // Microsoft Visual Studio
 17 | 
 18 | #if defined(_MSC_VER)
 19 | 
 20 | typedef unsigned char uint8_t;
 21 | typedef unsigned long uint32_t;
 22 | typedef unsigned __int64 uint64_t;
 23 | 
 24 | // Other compilers
 25 | 
 26 | #else   // defined(_MSC_VER)
 27 | 
 28 | #include <stdint.h>
 29 | 
 30 | #endif // !defined(_MSC_VER)
 31 | 
 32 | #define FORCE_INLINE __attribute__((always_inline))
 33 | 
 34 | inline uint32_t rotl32 ( uint32_t x, uint8_t r )
 35 | {
 36 |   return (x << r) | (x >> (32 - r));
 37 | }
 38 | 
 39 | #define ROTL32(x,y) rotl32(x,y)
 40 | 
 41 | #define BIG_CONSTANT(x) (x##LLU)
 42 | 
 43 | /* NO-OP for little-endian platforms */
 44 | #if defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__)
 45 | # if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 46 | #   define BYTESWAP(x) (x)
 47 | # endif
 48 | /* if __BYTE_ORDER__ is not predefined (like FreeBSD), use arch */
 49 | #elif defined(__i386)  || defined(__x86_64) \
 50 |   ||  defined(__alpha) || defined(__vax)
 51 | 
 52 | # define BYTESWAP(x) (x)
 53 | /* use __builtin_bswap32 if available */
 54 | #elif defined(__GNUC__) || defined(__clang__)
 55 | #ifdef __has_builtin
 56 | #if __has_builtin(__builtin_bswap32)
 57 | #define BYTESWAP(x) __builtin_bswap32(x)
 58 | #endif // __has_builtin(__builtin_bswap32)
 59 | #endif // __has_builtin
 60 | #endif // defined(__GNUC__) || defined(__clang__)
 61 | /* last resort (big-endian w/o __builtin_bswap) */
 62 | #ifndef BYTESWAP
 63 | # define BYTESWAP(x)   ((((x)&0xFF)<<24) \
 64 |          |(((x)>>24)&0xFF) \
 65 |          |(((x)&0x0000FF00)<<8)    \
 66 |          |(((x)&0x00FF0000)>>8)    )
 67 | #endif
 68 | 
 69 | //-----------------------------------------------------------------------------
 70 | // Block read - if your platform needs to do endian-swapping or can only
 71 | // handle aligned reads, do the conversion here
 72 | 
 73 | #define getblock(p, i) BYTESWAP(p[i])
 74 | 
 75 | //-----------------------------------------------------------------------------
 76 | // Finalization mix - force all bits of a hash block to avalanche
 77 | 
 78 | uint32_t fmix32( uint32_t h )
 79 | {
 80 |   h ^= h >> 16;
 81 |   h *= 0x85ebca6b;
 82 |   h ^= h >> 13;
 83 |   h *= 0xc2b2ae35;
 84 |   h ^= h >> 16;
 85 | 
 86 |   return h;
 87 | }
 88 | 
 89 | //-----------------------------------------------------------------------------
 90 | 
 91 | #ifdef __cplusplus
 92 | extern "C"
 93 | #else
 94 | extern
 95 | #endif
 96 | void MurmurHash3_x86_32( const void * key, int len, uint32_t seed, void * out )
 97 | {
 98 |   const uint8_t * data = (const uint8_t*)key;
 99 |   const int nblocks = len / 4;
100 |   int i;
101 | 
102 |   uint32_t h1 = seed;
103 | 
104 |   uint32_t c1 = 0xcc9e2d51;
105 |   uint32_t c2 = 0x1b873593;
106 | 
107 |   //----------
108 |   // body
109 | 
110 |   const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
111 | 
112 |   for(i = -nblocks; i; i++)
113 |   {
114 |     uint32_t k1 = getblock(blocks,i);
115 | 
116 |     k1 *= c1;
117 |     k1 = ROTL32(k1,15);
118 |     k1 *= c2;
119 | 
120 |     h1 ^= k1;
121 |     h1 = ROTL32(h1,13);
122 |     h1 = h1*5+0xe6546b64;
123 |   }
124 | 
125 |   //----------
126 |   // tail
127 |   {
128 |     const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
129 |     
130 |     uint32_t k1 = 0;
131 |     
132 |     switch(len & 3)
133 |     {
134 |     case 3: k1 ^= tail[2] << 16;
135 |     case 2: k1 ^= tail[1] << 8;
136 |     case 1: k1 ^= tail[0];
137 |             k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
138 |     };
139 |   }
140 | 
141 |   //----------
142 |   // finalization
143 | 
144 |   h1 ^= len;
145 | 
146 |   h1 = fmix32(h1);
147 | 
148 |   *(uint32_t*)out = h1;
149 | }
150 | 
151 | #endif
152 | 


--------------------------------------------------------------------------------
/t/HyperLogLogTest.cpp:
--------------------------------------------------------------------------------
  1 | #include <igloo/igloo_alt.h>
  2 | #include <igloo/TapTestListener.h>
  3 | #include "hyperloglog.hpp"
  4 | #include <map>
  5 | #include <string>
  6 | #include <cstdlib>
  7 | #include <ctime>
  8 | #include <iostream>
  9 | #include <fstream>
 10 | #include <iomanip>
 11 | using namespace igloo;
 12 | using namespace hll;
 13 | 
 14 | namespace {
 15 | // Test utilities
 16 | 
 17 | static const char alphanum[] = "0123456789"
 18 |         "!@#$%^&*"
 19 |         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 20 |         "abcdefghijklmnopqrstuvwxyz";
 21 | 
 22 | static const int alphanumSize = sizeof(alphanum) - 1;
 23 | 
 24 | static void genRandomString(size_t len, std::string& str) {
 25 |     srand(time(0));
 26 |     for (size_t i = 0; i < len; ++i) {
 27 |         char c = alphanum[rand() % alphanumSize];
 28 |         str.append(&c, 1);
 29 |     }
 30 | }
 31 | 
 32 | static std::map<std::string, bool> GEN_STRINGS;
 33 | static void getUniqueString(size_t len, std::string& str) {
 34 |     do {
 35 |         genRandomString(len, str);
 36 |     } while (GEN_STRINGS.find(str) != GEN_STRINGS.end());
 37 |     GEN_STRINGS.insert(std::make_pair(str, true));
 38 | }
 39 | 
 40 | }
 41 | 
 42 | class ScopedFile {
 43 | public:
 44 |     ScopedFile(std::string& filename) : filename_(filename) {
 45 |     }
 46 | 
 47 |     ~ScopedFile() {
 48 |         remove(filename_.c_str());   
 49 |     }
 50 | 
 51 |     const std::string& getFileName() const {
 52 |         return filename_;
 53 |     }
 54 | private:
 55 |     std::string filename_;
 56 | };
 57 | 
 58 | Describe(hll_HyperLogLog) {
 59 |     Describe(create_instance) {
 60 |         It(pass_minimum_arugment_in_range) {
 61 |             HyperLogLog *hll = new HyperLogLog(4);
 62 |             Assert::That(hll != NULL);
 63 |             delete hll;
 64 |         }
 65 | 
 66 |         It(pass_maximum_argument_in_range) {
 67 |             HyperLogLog *hll = new HyperLogLog(16);
 68 |             Assert::That(hll != NULL);
 69 |             delete hll;
 70 |         }
 71 | 
 72 |         It(pass_out_of_range_argument_min) {
 73 |             AssertThrows(std::invalid_argument, HyperLogLog(3));
 74 |             Assert::That(LastException<std::invalid_argument>().what(),
 75 |                     Is().Containing("bit width must be in the range [4,30]"));
 76 |         }
 77 | 
 78 |         It(pass_out_of_range_argument_max) {
 79 |             AssertThrows(std::invalid_argument, HyperLogLog(31));
 80 |             Assert::That(LastException<std::invalid_argument>().what(),
 81 |                     Is().Containing("bit width must be in the range [4,30]"));
 82 |         }
 83 |     };
 84 | 
 85 |     It(get_register_size) {
 86 |         HyperLogLog *hll = new HyperLogLog(10);
 87 |         Assert::That(hll->registerSize(), Equals(1UL << 10));
 88 |         delete hll;
 89 | 
 90 |         hll = new HyperLogLog(30);
 91 |         Assert::That(hll->registerSize(), Equals(1UL << 30));
 92 |         delete hll;
 93 |     }
 94 | 
 95 |     It(estimate_cardinality) {
 96 |         uint32_t k = 14;
 97 |         uint32_t registerSize = 1UL << k;
 98 |         double expectRatio = 1.04 / sqrt((double)registerSize);
 99 |         double error = 0.0;
100 |         size_t dataNum = (size_t(1) << 24) + size_t(1);
101 |         size_t execNum = 10;
102 | #if defined(HLL_HEAVYTEST)
103 |         k = 30;
104 | #endif
105 |         for (size_t n = 0; n < execNum; ++n) {
106 |             HyperLogLog hll(k);
107 |             for (size_t i = 0; i < dataNum; ++i) {
108 |                 std::string str((const char*)&i, sizeof(i));
109 |                 hll.add(str.c_str(), str.size());
110 |             }
111 |             double cardinality = hll.estimate();
112 |             error += std::abs(cardinality - (double)dataNum) / dataNum;
113 |         }
114 |         double errorRatio = error / execNum;
115 |         Assert::That(errorRatio, IsLessThan(expectRatio));
116 |     }
117 | 
118 |     It(dump_and_restore) {
119 |         uint32_t k = 16;
120 |         size_t dataNum = 500;
121 |         HyperLogLog hll(k);
122 |         for (size_t i = 1; i < dataNum; ++i) {
123 |             std::string str;
124 |             getUniqueString((i%100) + 10, str);
125 |             hll.add(str.c_str(), str.size());
126 |         }
127 |         double cardinality = hll.estimate();
128 |         {
129 |             std::string dumpFile = "./t/hll_test.dump";
130 |             ScopedFile sf(dumpFile);
131 |             std::ofstream ofs(dumpFile.c_str());
132 |             hll.dump(ofs);
133 |             ofs.close();
134 | 
135 |             std::ifstream ifs(dumpFile.c_str());
136 |             HyperLogLog hll2;
137 |             hll2.restore(ifs);
138 |             ifs.close();
139 |             Assert::That(hll2.estimate(), Equals(cardinality));
140 |         }
141 |     }
142 | 
143 |     It(clear_register) {
144 |         HyperLogLog hll(16);
145 |         size_t dataNum = 100;
146 |         for (size_t i = 1; i < dataNum; ++i) {
147 |             std::string str;
148 |             getUniqueString(i + 10,str);
149 |             hll.add(str.c_str(), str.size());
150 |         }
151 |         Assert::That(hll.estimate(), !Equals(0.0f));
152 |         hll.clear();
153 |         Assert::That(hll.estimate(), Equals(0.0f));
154 |     }
155 |     
156 |     Describe(merge) {
157 |         It(merge_registers) {
158 |             uint32_t k = 16;
159 |             uint32_t registerSize = 1UL << k;
160 |             double expectRatio = 1.04 / sqrt((double)registerSize);
161 |             size_t dataNum = 1 << 10;
162 |             size_t dataNum2 = 1 << 10;
163 |             size_t execNum = 10;
164 |             double error = 0.0;
165 |             for (size_t i = 0; i < execNum; ++i) {
166 |                 HyperLogLog hll(k);
167 |                 std::map<std::string, bool>().swap(GEN_STRINGS);
168 |                 for (size_t i = 1; i < dataNum; ++i) {
169 |                     std::string str;
170 |                     getUniqueString((i%100) + 10, str);
171 |                     hll.add(str.c_str(), str.size());
172 |                 }
173 | 
174 |                 HyperLogLog hll2(k);
175 | 
176 |                 for (size_t i = 1; i < dataNum2; ++i) {
177 |                     std::string str;
178 |                     getUniqueString((i % 100) + 10, str);
179 |                     hll2.add(str.c_str(), str.size());
180 |                 }
181 | 
182 |                 hll.merge(hll2);
183 |                 double cardinality = hll.estimate();
184 |                 error += std::abs(cardinality - (double)(dataNum + dataNum2))/(dataNum + dataNum2);
185 |             }
186 |             double errorRatio = error / execNum;
187 |             Assert::That(errorRatio, IsLessThan(expectRatio));
188 |         }
189 | 
190 |         It(merge_size_unmatched_registers) {
191 |             HyperLogLog hll(16);
192 |             HyperLogLog hll2(10);
193 |             AssertThrows(std::invalid_argument, hll.merge(hll2));
194 |             Assert::That(LastException<std::invalid_argument>().what(),
195 |                     Is().Containing("number of registers doesn't match:"));
196 |         }
197 |     };
198 | };
199 | 
200 | int main() {
201 |     DefaultTestResultsOutput output;
202 |     TestRunner runner(output);
203 | 
204 |     TapTestListener listener;
205 |     runner.AddListener(&listener);
206 | 
207 |     return runner.Run();
208 | }
209 | 
210 | 


--------------------------------------------------------------------------------
/t/HyperLogLogHIPTest.cpp:
--------------------------------------------------------------------------------
  1 | #include <igloo/igloo_alt.h>
  2 | #include <igloo/TapTestListener.h>
  3 | #include "hyperloglog.hpp"
  4 | #include <map>
  5 | #include <string>
  6 | #include <cstdlib>
  7 | #include <ctime>
  8 | #include <cmath>
  9 | #include <iostream>
 10 | #include <fstream>
 11 | #include <iomanip>
 12 | using namespace igloo;
 13 | using namespace hll;
 14 | 
 15 | namespace {
 16 | // Test utilities
 17 | 
 18 | static const char alphanum[] = "0123456789"
 19 |         "!@#$%^&*"
 20 |         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 21 |         "abcdefghijklmnopqrstuvwxyz";
 22 | 
 23 | static const int alphanumSize = sizeof(alphanum) - 1;
 24 | 
 25 | static void genRandomString(size_t len, std::string& str) {
 26 |     srand(time(0));
 27 |     for (size_t i = 0; i < len; ++i) {
 28 |         char c = alphanum[rand() % alphanumSize];
 29 |         str.append(&c, 1);
 30 |     }
 31 | }
 32 | 
 33 | static std::map<std::string, bool> GEN_STRINGS;
 34 | static void getUniqueString(size_t len, std::string& str) {
 35 |     do {
 36 |         genRandomString(len, str);
 37 |     } while (GEN_STRINGS.find(str) != GEN_STRINGS.end());
 38 |     GEN_STRINGS.insert(std::make_pair(str, true));
 39 | }
 40 | 
 41 | }
 42 | 
 43 | class ScopedFile {
 44 | public:
 45 |     ScopedFile(std::string& filename) : filename_(filename) {
 46 |     }
 47 | 
 48 |     ~ScopedFile() {
 49 |         remove(filename_.c_str());   
 50 |     }
 51 | 
 52 |     const std::string& getFileName() const {
 53 |         return filename_;
 54 |     }
 55 | private:
 56 |     std::string filename_;
 57 | };
 58 | 
 59 | Describe(hll_HyperLogLogHIP) {
 60 |     Describe(create_instance) {
 61 |         It(pass_minimum_arugment_in_range) {
 62 |             HyperLogLogHIP *hll = new HyperLogLogHIP(4);
 63 |             Assert::That(hll != NULL);
 64 |             delete hll;
 65 |         }
 66 | 
 67 |         It(pass_maximum_argument_in_range) {
 68 |             HyperLogLogHIP *hll = new HyperLogLogHIP(16);
 69 |             Assert::That(hll != NULL);
 70 |             delete hll;
 71 |         }
 72 | 
 73 |         It(pass_out_of_range_argument_min) {
 74 |             AssertThrows(std::invalid_argument, HyperLogLogHIP(3));
 75 |             Assert::That(LastException<std::invalid_argument>().what(),
 76 |                     Is().Containing("bit width must be in the range [4,30]"));
 77 |         }
 78 | 
 79 |         It(pass_out_of_range_argument_max) {
 80 |             AssertThrows(std::invalid_argument, HyperLogLogHIP(31));
 81 |             Assert::That(LastException<std::invalid_argument>().what(),
 82 |                     Is().Containing("bit width must be in the range [4,30]"));
 83 |         }
 84 |     };
 85 | 
 86 |     It(get_register_size) {
 87 |         HyperLogLogHIP *hll = new HyperLogLogHIP(10);
 88 |         Assert::That(hll->registerSize(), Equals(1UL << 10));
 89 |         delete hll;
 90 | 
 91 |         hll = new HyperLogLogHIP(16);
 92 |         Assert::That(hll->registerSize(), Equals(1UL << 16));
 93 |         delete hll;
 94 |     }
 95 | 
 96 |     It(estimate_cardinality) {
 97 |         uint32_t k = 14;
 98 |         uint32_t registerSize = 1UL << k;
 99 |         double expectRatio = sqrt(2.0 / M_PI * ((double)registerSize - 2.0));
100 |         double error = 0.0;
101 |         size_t dataNum = (size_t(1) << 24) + size_t(1);
102 |         size_t execNum = 10;
103 |         for (size_t n = 0; n < execNum; ++n) {
104 |             HyperLogLogHIP hll(k);
105 |             std::map<std::string, bool>().swap(GEN_STRINGS);
106 |             for (size_t i = 1; i < dataNum; ++i) {
107 |                 std::string str((const char*)&i, sizeof(i));
108 |                 hll.add(str.c_str(), str.size());
109 |             }
110 |             double cardinality = hll.estimate();
111 |             error += std::abs(cardinality - dataNum) / dataNum;
112 |         }
113 |         double errorRatio = error / execNum;
114 |         Assert::That(errorRatio, IsLessThan(expectRatio));
115 |     }
116 | 
117 |     It(dump_and_restore) {
118 |         uint32_t k = 16;
119 |         size_t dataNum = 500;
120 |         HyperLogLogHIP hll(k);
121 |         for (size_t i = 1; i < dataNum; ++i) {
122 |             std::string str;
123 |             getUniqueString((i % 100) + 10, str);
124 |             hll.add(str.c_str(), str.size());
125 |         }
126 |         double cardinality = hll.estimate();
127 |         {
128 |             std::string dumpFile = "./t/hll_test.dump";
129 |             ScopedFile sf(dumpFile);
130 |             std::ofstream ofs(dumpFile.c_str());
131 |             hll.dump(ofs);
132 |             ofs.close();
133 | 
134 |             std::ifstream ifs(dumpFile.c_str());
135 |             HyperLogLogHIP hll2;
136 |             hll2.restore(ifs);
137 |             ifs.close();
138 |             Assert::That(hll2.estimate(), Equals(cardinality));
139 |         }
140 |     }
141 | 
142 |     It(clear_register) {
143 |         HyperLogLogHIP hll(16);
144 |         size_t dataNum = 100;
145 |         for (size_t i = 1; i < dataNum; ++i) {
146 |             std::string str;
147 |             getUniqueString(i + 10, str);
148 |             hll.add(str.c_str(), str.size());
149 |         }
150 |         Assert::That(hll.estimate(), !Equals(0.0f));
151 |         hll.clear();
152 |         Assert::That(hll.estimate(), Equals(0.0f));
153 |     }
154 |     
155 |     Describe(merge) {
156 |         It(merge_registers) {
157 |             uint32_t k = 16;
158 |             uint32_t registerSize = 1UL << k;
159 |             double expectRatio = sqrt(2.0 / M_PI * ((double)registerSize - 2.0));
160 |             size_t dataNum = 1 << 10;
161 |             size_t dataNum2 = 1 << 10;
162 |             size_t execNum = 10;
163 |             double error = 0.0;
164 |             for (size_t i = 0; i < execNum; ++i) {
165 |                 HyperLogLogHIP hll(k);
166 |                 std::map<std::string, bool>().swap(GEN_STRINGS);
167 |                 for (size_t i = 1; i < dataNum; ++i) {
168 |                     std::string str;
169 |                     getUniqueString((i % 100) + 10, str);
170 |                     hll.add(str.c_str(), str.size());
171 |                 }
172 | 
173 |                 HyperLogLogHIP hll2(k);
174 | 
175 |                 for (size_t i = 1; i < dataNum2; ++i) {
176 |                     std::string str;
177 |                     getUniqueString((i % 100) + 10, str);
178 |                     hll2.add(str.c_str(), str.size());
179 |                 }
180 | 
181 |                 hll.merge(hll2);
182 |                 double cardinality = hll.estimate();
183 |                 error += std::abs(cardinality - (double)(dataNum + dataNum2))/(dataNum + dataNum2);
184 |             }
185 |             double errorRatio = error / execNum;
186 |             Assert::That(errorRatio, IsLessThan(expectRatio));
187 |         }
188 | 
189 |         It(merge_size_unmatched_registers) {
190 |             HyperLogLogHIP hll(16);
191 |             HyperLogLogHIP hll2(10);
192 |             AssertThrows(std::invalid_argument, hll.merge(hll2));
193 |             Assert::That(LastException<std::invalid_argument>().what(),
194 |                     Is().Containing("number of registers doesn't match:"));
195 |         }
196 |     };
197 | };
198 | 
199 | int main() {
200 |     DefaultTestResultsOutput output;
201 |     TestRunner runner(output);
202 | 
203 |     TapTestListener listener;
204 |     runner.AddListener(&listener);
205 | 
206 |     return runner.Run();
207 | }
208 | 
209 | 


--------------------------------------------------------------------------------
/include/hyperloglog.hpp:
--------------------------------------------------------------------------------
  1 | #if !defined(HYPERLOGLOG_HPP)
  2 | #define HYPERLOGLOG_HPP
  3 | 
  4 | /**
  5 |  * @file hyperloglog.hpp
  6 |  * @brief HyperLogLog cardinality estimator
  7 |  * @date Created 2013/3/20
  8 |  * @author Hideaki Ohno
  9 |  */
 10 | 
 11 | #include <vector>
 12 | #include <cmath>
 13 | #include <sstream>
 14 | #include <stdexcept>
 15 | #include <algorithm>
 16 | #include "murmur3.h"
 17 | 
 18 | #define HLL_HASH_SEED 313
 19 | 
 20 | #if defined(__has_builtin) && (defined(__GNUC__) || defined(__clang__))
 21 | 
 22 | #define _GET_CLZ(x, b) (uint8_t)std::min(b, ::__builtin_clz(x)) + 1
 23 | 
 24 | #else
 25 | 
 26 | inline uint8_t _get_leading_zero_count(uint32_t x, uint8_t b) {
 27 | 
 28 | #if defined (_MSC_VER)
 29 |     uint32_t leading_zero_len = 32;
 30 |     ::_BitScanReverse(&leading_zero_len, x);
 31 |     --leading_zero_len;
 32 |     return std::min(b, (uint8_t)leading_zero_len);
 33 | #else
 34 |     uint8_t v = 1;
 35 |     while (v <= b && !(x & 0x80000000)) {
 36 |         v++;
 37 |         x <<= 1;
 38 |     }
 39 |     return v;
 40 | #endif
 41 | 
 42 | }
 43 | #define _GET_CLZ(x, b) _get_leading_zero_count(x, b)
 44 | #endif /* defined(__GNUC__) */
 45 | 
 46 | namespace hll {
 47 | 
 48 | static const double pow_2_32 = 4294967296.0; ///< 2^32
 49 | static const double neg_pow_2_32 = -4294967296.0; ///< -(2^32)
 50 | 
 51 | /** @class HyperLogLog
 52 |  *  @brief Implement of 'HyperLogLog' estimate cardinality algorithm
 53 |  */
 54 | class HyperLogLog {
 55 | public:
 56 | 
 57 |     /**
 58 |      * Constructor
 59 |      *
 60 |      * @param[in] b bit width (register size will be 2 to the b power).
 61 |      *            This value must be in the range[4,30].Default value is 4.
 62 |      *
 63 |      * @exception std::invalid_argument the argument is out of range.
 64 |      */
 65 |     HyperLogLog(uint8_t b = 4) throw (std::invalid_argument) :
 66 |             b_(b), m_(1 << b), M_(m_, 0) {
 67 | 
 68 |         if (b < 4 || 30 < b) {
 69 |             throw std::invalid_argument("bit width must be in the range [4,30]");
 70 |         }
 71 | 
 72 |         double alpha;
 73 |         switch (m_) {
 74 |             case 16:
 75 |                 alpha = 0.673;
 76 |                 break;
 77 |             case 32:
 78 |                 alpha = 0.697;
 79 |                 break;
 80 |             case 64:
 81 |                 alpha = 0.709;
 82 |                 break;
 83 |             default:
 84 |                 alpha = 0.7213 / (1.0 + 1.079 / m_);
 85 |                 break;
 86 |         }
 87 |         alphaMM_ = alpha * m_ * m_;
 88 |     }
 89 | 
 90 |     /**
 91 |      * Adds element to the estimator
 92 |      *
 93 |      * @param[in] str string to add
 94 |      * @param[in] len length of string
 95 |      */
 96 |     void add(const char* str, uint32_t len) {
 97 |         uint32_t hash;
 98 |         MurmurHash3_x86_32(str, len, HLL_HASH_SEED, (void*) &hash);
 99 |         uint32_t index = hash >> (32 - b_);
100 |         uint8_t rank = _GET_CLZ((hash << b_), 32 - b_);
101 |         if (rank > M_[index]) {
102 |             M_[index] = rank;
103 |         }
104 |     }
105 | 
106 |     /**
107 |      * Estimates cardinality value.
108 |      *
109 |      * @return Estimated cardinality value.
110 |      */
111 |     double estimate() const {
112 |         double estimate;
113 |         double sum = 0.0;
114 |         for (uint32_t i = 0; i < m_; i++) {
115 |             sum += 1.0 / (1 << M_[i]);
116 |         }
117 |         estimate = alphaMM_ / sum; // E in the original paper
118 |         if (estimate <= 2.5 * m_) {
119 |             uint32_t zeros = 0;
120 |             for (uint32_t i = 0; i < m_; i++) {
121 |                 if (M_[i] == 0) {
122 |                     zeros++;
123 |                 }
124 |             }
125 |             if (zeros != 0) {
126 |                 estimate = m_ * std::log(static_cast<double>(m_)/ zeros);
127 |             }
128 |         } else if (estimate > (1.0 / 30.0) * pow_2_32) {
129 |             estimate = neg_pow_2_32 * log(1.0 - (estimate / pow_2_32));
130 |         }
131 |         return estimate;
132 |     }
133 | 
134 |     /**
135 |      * Merges the estimate from 'other' into this object, returning the estimate of their union.
136 |      * The number of registers in each must be the same.
137 |      *
138 |      * @param[in] other HyperLogLog instance to be merged
139 |      * 
140 |      * @exception std::invalid_argument number of registers doesn't match.
141 |      */
142 |     void merge(const HyperLogLog& other) throw (std::invalid_argument) {
143 |         if (m_ != other.m_) {
144 |             std::stringstream ss;
145 |             ss << "number of registers doesn't match: " << m_ << " != " << other.m_;
146 |             throw std::invalid_argument(ss.str().c_str());
147 |         }
148 |         for (uint32_t r = 0; r < m_; ++r) {
149 |             if (M_[r] < other.M_[r]) {
150 |                 M_[r] |= other.M_[r];
151 |             }
152 |         }
153 |     }
154 | 
155 |     /**
156 |      * Clears all internal registers.
157 |      */
158 |     void clear() {
159 |         std::fill(M_.begin(), M_.end(), 0);
160 |     }
161 | 
162 |     /**
163 |      * Returns size of register.
164 |      *
165 |      * @return Register size
166 |      */
167 |     uint32_t registerSize() const {
168 |         return m_;
169 |     }
170 | 
171 |     /**
172 |      * Exchanges the content of the instance
173 |      *
174 |      * @param[in,out] rhs Another HyperLogLog instance
175 |      */
176 |     void swap(HyperLogLog& rhs) {
177 |         std::swap(b_, rhs.b_);
178 |         std::swap(m_, rhs.m_);
179 |         std::swap(alphaMM_, rhs.alphaMM_);
180 |         M_.swap(rhs.M_);       
181 |     }
182 | 
183 |     /**
184 |      * Dump the current status to a stream
185 |      *
186 |      * @param[out] os The output stream where the data is saved
187 |      *
188 |      * @exception std::runtime_error When failed to dump.
189 |      */
190 |     void dump(std::ostream& os) const throw(std::runtime_error){
191 |         os.write((char*)&b_, sizeof(b_));
192 |         os.write((char*)&M_[0], sizeof(M_[0]) * M_.size());
193 |         if(os.fail()){
194 |             throw std::runtime_error("Failed to dump");
195 |         }
196 |     }
197 | 
198 |     /**
199 |      * Restore the status from a stream
200 |      * 
201 |      * @param[in] is The input stream where the status is saved
202 |      *
203 |      * @exception std::runtime_error When failed to restore.
204 |      */
205 |     void restore(std::istream& is) throw(std::runtime_error){
206 |         uint8_t b = 0;
207 |         is.read((char*)&b, sizeof(b));
208 |         HyperLogLog tempHLL(b);
209 |         is.read((char*)&(tempHLL.M_[0]), sizeof(M_[0]) * tempHLL.m_);
210 |         if(is.fail()){
211 |            throw std::runtime_error("Failed to restore");
212 |         }       
213 |         swap(tempHLL);
214 |     }
215 | 
216 | protected:
217 |     uint8_t b_; ///< register bit width
218 |     uint32_t m_; ///< register size
219 |     double alphaMM_; ///< alpha * m^2
220 |     std::vector<uint8_t> M_; ///< registers
221 | };
222 | 
223 | /**
224 |  * @brief HIP estimator on HyperLogLog counter.
225 |  */
226 | class HyperLogLogHIP : public HyperLogLog {
227 | public:
228 | 
229 |     /**
230 |      * Constructor
231 |      *
232 |      * @param[in] b bit width (register size will be 2 to the b power).
233 |      *            This value must be in the range[4,30].Default value is 4.
234 |      *
235 |      * @exception std::invalid_argument the argument is out of range.
236 |      */
237 |     HyperLogLogHIP(uint8_t b = 4) throw (std::invalid_argument) : HyperLogLog(b), register_limit_((1 << 5) - 1), c_(0.0), p_(1 << b) {
238 |     }
239 | 
240 |     /**
241 |      * Adds element to the estimator
242 |      *
243 |      * @param[in] str string to add
244 |      * @param[in] len length of string
245 |      */
246 |     void add(const char* str, uint32_t len) {
247 |         uint32_t hash;
248 |         MurmurHash3_x86_32(str, len, HLL_HASH_SEED, (void*) &hash);
249 |         uint32_t index = hash >> (32 - b_);
250 |         uint8_t rank = _GET_CLZ((hash << b_), 32 - b_);
251 |         rank = rank == 0 ? register_limit_ : std::min(register_limit_, rank);
252 |         const uint8_t old = M_[index];
253 |         if (rank > old) {
254 |             c_ += 1.0 / (p_/m_);
255 |             p_ -= 1.0/(1 << old);
256 |             M_[index] = rank;
257 |             if(rank < 31){
258 |                 p_ += 1.0/(uint32_t(1) << rank);
259 |             }
260 |         }
261 |     }
262 | 
263 |     /**
264 |      * Estimates cardinality value.
265 |      *
266 |      * @return Estimated cardinality value.
267 |      */
268 |     double estimate() const {
269 |         return c_;
270 |     }
271 | 
272 |     /**
273 |      * Merges the estimate from 'other' into this object, returning the estimate of their union.
274 |      * The number of registers in each must be the same.
275 |      *
276 |      * @param[in] other HyperLogLog instance to be merged
277 |      * 
278 |      * @exception std::invalid_argument number of registers doesn't match.
279 |      */
280 |     void merge(const HyperLogLogHIP& other) throw (std::invalid_argument) {
281 |         if (m_ != other.m_) {
282 |             std::stringstream ss;
283 |             ss << "number of registers doesn't match: " << m_ << " != " << other.m_;
284 |             throw std::invalid_argument(ss.str().c_str());
285 |         }
286 |         for (uint32_t r = 0; r < m_; ++r) {
287 |             const uint8_t b = M_[r];
288 |             const uint8_t b_other = other.M_[r];
289 |             if (b < b_other) {
290 |                 c_ += 1.0 / (p_/m_);
291 |                 p_ -= 1.0/(1 << b);
292 |                 M_[r] |= b_other;
293 |                 if(b_other < register_limit_){
294 |                     p_ += 1.0/(1 << b_other);
295 |                 }
296 |             }
297 |         }
298 |     }
299 | 
300 |     /**
301 |      * Clears all internal registers.
302 |      */
303 |     void clear() {
304 |         std::fill(M_.begin(), M_.end(), 0);
305 |         c_ = 0.0;
306 |         p_ = 1 << b_;
307 |     }
308 | 
309 |     /**
310 |      * Returns size of register.
311 |      *
312 |      * @return Register size
313 |      */
314 |     uint32_t registerSize() const {
315 |         return m_;
316 |     }
317 | 
318 |     /**
319 |      * Exchanges the content of the instance
320 |      *
321 |      * @param[in,out] rhs Another HyperLogLog instance
322 |      */
323 |     void swap(HyperLogLogHIP& rhs) {
324 |         std::swap(b_, rhs.b_);
325 |         std::swap(m_, rhs.m_);
326 |         std::swap(c_, rhs.c_);
327 |         M_.swap(rhs.M_);       
328 |     }
329 | 
330 |     /**
331 |      * Dump the current status to a stream
332 |      *
333 |      * @param[out] os The output stream where the data is saved
334 |      *
335 |      * @exception std::runtime_error When failed to dump.
336 |      */
337 |     void dump(std::ostream& os) const throw(std::runtime_error){
338 |         os.write((char*)&b_, sizeof(b_));
339 |         os.write((char*)&M_[0], sizeof(M_[0]) * M_.size());
340 |         os.write((char*)&c_, sizeof(c_));
341 |         os.write((char*)&p_, sizeof(p_));
342 |         if(os.fail()){
343 |             throw std::runtime_error("Failed to dump");
344 |         }
345 |     }
346 | 
347 |     /**
348 |      * Restore the status from a stream
349 |      * 
350 |      * @param[in] is The input stream where the status is saved
351 |      *
352 |      * @exception std::runtime_error When failed to restore.
353 |      */
354 |     void restore(std::istream& is) throw(std::runtime_error){
355 |         uint8_t b = 0;
356 |         is.read((char*)&b, sizeof(b));
357 |         HyperLogLogHIP tempHLL(b);
358 |         is.read((char*)&(tempHLL.M_[0]), sizeof(M_[0]) * tempHLL.m_);
359 |         is.read((char*)&(tempHLL.c_), sizeof(double));
360 |         is.read((char*)&(tempHLL.p_), sizeof(double));
361 |         if(is.fail()){
362 |            throw std::runtime_error("Failed to restore");
363 |         }       
364 |         swap(tempHLL);
365 |     }
366 | private: 
367 |     const uint8_t register_limit_;
368 |     double c_;
369 |     double p_;
370 | };
371 | 
372 | } // namespace hll
373 | 
374 | #endif // !defined(HYPERLOGLOG_HPP)
375 | 


--------------------------------------------------------------------------------
/Doxyfile:
--------------------------------------------------------------------------------
   1 | # Doxyfile 1.8.3.1
   2 | 
   3 | # This file describes the settings to be used by the documentation system
   4 | # doxygen (www.doxygen.org) for a project.
   5 | #
   6 | # All text after a hash (#) is considered a comment and will be ignored.
   7 | # The format is:
   8 | #       TAG = value [value, ...]
   9 | # For lists items can also be appended using:
  10 | #       TAG += value [value, ...]
  11 | # Values that contain spaces should be placed between quotes (" ").
  12 | 
  13 | #---------------------------------------------------------------------------
  14 | # Project related configuration options
  15 | #---------------------------------------------------------------------------
  16 | 
  17 | # This tag specifies the encoding used for all characters in the config file
  18 | # that follow. The default is UTF-8 which is also the encoding used for all
  19 | # text before the first occurrence of this tag. Doxygen uses libiconv (or the
  20 | # iconv built into libc) for the transcoding. See
  21 | # http://www.gnu.org/software/libiconv for the list of possible encodings.
  22 | 
  23 | DOXYFILE_ENCODING      = UTF-8
  24 | 
  25 | # The PROJECT_NAME tag is a single word (or sequence of words) that should
  26 | # identify the project. Note that if you do not use Doxywizard you need
  27 | # to put quotes around the project name if it contains spaces.
  28 | 
  29 | PROJECT_NAME           = "HyperLogLog"
  30 | 
  31 | # The PROJECT_NUMBER tag can be used to enter a project or revision number.
  32 | # This could be handy for archiving the generated documentation or
  33 | # if some version control system is used.
  34 | 
  35 | PROJECT_NUMBER         =
  36 | 
  37 | # Using the PROJECT_BRIEF tag one can provide an optional one line description
  38 | # for a project that appears at the top of each page and should give viewer
  39 | # a quick idea about the purpose of the project. Keep the description short.
  40 | 
  41 | PROJECT_BRIEF          =
  42 | 
  43 | # With the PROJECT_LOGO tag one can specify an logo or icon that is
  44 | # included in the documentation. The maximum height of the logo should not
  45 | # exceed 55 pixels and the maximum width should not exceed 200 pixels.
  46 | # Doxygen will copy the logo to the output directory.
  47 | 
  48 | PROJECT_LOGO           =
  49 | 
  50 | # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute)
  51 | # base path where the generated documentation will be put.
  52 | # If a relative path is entered, it will be relative to the location
  53 | # where doxygen was started. If left blank the current directory will be used.
  54 | 
  55 | OUTPUT_DIRECTORY       =
  56 | 
  57 | # If the CREATE_SUBDIRS tag is set to YES, then doxygen will create
  58 | # 4096 sub-directories (in 2 levels) under the output directory of each output
  59 | # format and will distribute the generated files over these directories.
  60 | # Enabling this option can be useful when feeding doxygen a huge amount of
  61 | # source files, where putting all generated files in the same directory would
  62 | # otherwise cause performance problems for the file system.
  63 | 
  64 | CREATE_SUBDIRS         = NO
  65 | 
  66 | # The OUTPUT_LANGUAGE tag is used to specify the language in which all
  67 | # documentation generated by doxygen is written. Doxygen will use this
  68 | # information to generate all constant output in the proper language.
  69 | # The default language is English, other supported languages are:
  70 | # Afrikaans, Arabic, Brazilian, Catalan, Chinese, Chinese-Traditional,
  71 | # Croatian, Czech, Danish, Dutch, Esperanto, Farsi, Finnish, French, German,
  72 | # Greek, Hungarian, Italian, Japanese, Japanese-en (Japanese with English
  73 | # messages), Korean, Korean-en, Lithuanian, Norwegian, Macedonian, Persian,
  74 | # Polish, Portuguese, Romanian, Russian, Serbian, Serbian-Cyrillic, Slovak,
  75 | # Slovene, Spanish, Swedish, Ukrainian, and Vietnamese.
  76 | 
  77 | OUTPUT_LANGUAGE        = English
  78 | 
  79 | # If the BRIEF_MEMBER_DESC tag is set to YES (the default) Doxygen will
  80 | # include brief member descriptions after the members that are listed in
  81 | # the file and class documentation (similar to JavaDoc).
  82 | # Set to NO to disable this.
  83 | 
  84 | BRIEF_MEMBER_DESC      = YES
  85 | 
  86 | # If the REPEAT_BRIEF tag is set to YES (the default) Doxygen will prepend
  87 | # the brief description of a member or function before the detailed description.
  88 | # Note: if both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the
  89 | # brief descriptions will be completely suppressed.
  90 | 
  91 | REPEAT_BRIEF           = YES
  92 | 
  93 | # This tag implements a quasi-intelligent brief description abbreviator
  94 | # that is used to form the text in various listings. Each string
  95 | # in this list, if found as the leading text of the brief description, will be
  96 | # stripped from the text and the result after processing the whole list, is
  97 | # used as the annotated text. Otherwise, the brief description is used as-is.
  98 | # If left blank, the following values are used ("$name" is automatically
  99 | # replaced with the name of the entity): "The $name class" "The $name widget"
 100 | # "The $name file" "is" "provides" "specifies" "contains"
 101 | # "represents" "a" "an" "the"
 102 | 
 103 | ABBREVIATE_BRIEF       =
 104 | 
 105 | # If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then
 106 | # Doxygen will generate a detailed section even if there is only a brief
 107 | # description.
 108 | 
 109 | ALWAYS_DETAILED_SEC    = NO
 110 | 
 111 | # If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all
 112 | # inherited members of a class in the documentation of that class as if those
 113 | # members were ordinary class members. Constructors, destructors and assignment
 114 | # operators of the base classes will not be shown.
 115 | 
 116 | INLINE_INHERITED_MEMB  = NO
 117 | 
 118 | # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
 119 | # path before files name in the file list and in the header files. If set
 120 | # to NO the shortest path that makes the file name unique will be used.
 121 | 
 122 | FULL_PATH_NAMES        = YES
 123 | 
 124 | # If the FULL_PATH_NAMES tag is set to YES then the STRIP_FROM_PATH tag
 125 | # can be used to strip a user-defined part of the path. Stripping is
 126 | # only done if one of the specified strings matches the left-hand part of
 127 | # the path. The tag can be used to show relative paths in the file list.
 128 | # If left blank the directory from which doxygen is run is used as the
 129 | # path to strip. Note that you specify absolute paths here, but also
 130 | # relative paths, which will be relative from the directory where doxygen is
 131 | # started.
 132 | 
 133 | STRIP_FROM_PATH        =
 134 | 
 135 | # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of
 136 | # the path mentioned in the documentation of a class, which tells
 137 | # the reader which header file to include in order to use a class.
 138 | # If left blank only the name of the header file containing the class
 139 | # definition is used. Otherwise one should specify the include paths that
 140 | # are normally passed to the compiler using the -I flag.
 141 | 
 142 | STRIP_FROM_INC_PATH    =
 143 | 
 144 | # If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter
 145 | # (but less readable) file names. This can be useful if your file system
 146 | # doesn't support long names like on DOS, Mac, or CD-ROM.
 147 | 
 148 | SHORT_NAMES            = NO
 149 | 
 150 | # If the JAVADOC_AUTOBRIEF tag is set to YES then Doxygen
 151 | # will interpret the first line (until the first dot) of a JavaDoc-style
 152 | # comment as the brief description. If set to NO, the JavaDoc
 153 | # comments will behave just like regular Qt-style comments
 154 | # (thus requiring an explicit @brief command for a brief description.)
 155 | 
 156 | JAVADOC_AUTOBRIEF      = YES
 157 | 
 158 | # If the QT_AUTOBRIEF tag is set to YES then Doxygen will
 159 | # interpret the first line (until the first dot) of a Qt-style
 160 | # comment as the brief description. If set to NO, the comments
 161 | # will behave just like regular Qt-style comments (thus requiring
 162 | # an explicit \brief command for a brief description.)
 163 | 
 164 | QT_AUTOBRIEF           = NO
 165 | 
 166 | # The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make Doxygen
 167 | # treat a multi-line C++ special comment block (i.e. a block of //! or ///
 168 | # comments) as a brief description. This used to be the default behaviour.
 169 | # The new default is to treat a multi-line C++ comment block as a detailed
 170 | # description. Set this tag to YES if you prefer the old behaviour instead.
 171 | 
 172 | MULTILINE_CPP_IS_BRIEF = NO
 173 | 
 174 | # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented
 175 | # member inherits the documentation from any documented member that it
 176 | # re-implements.
 177 | 
 178 | INHERIT_DOCS           = YES
 179 | 
 180 | # If the SEPARATE_MEMBER_PAGES tag is set to YES, then doxygen will produce
 181 | # a new page for each member. If set to NO, the documentation of a member will
 182 | # be part of the file/class/namespace that contains it.
 183 | 
 184 | SEPARATE_MEMBER_PAGES  = NO
 185 | 
 186 | # The TAB_SIZE tag can be used to set the number of spaces in a tab.
 187 | # Doxygen uses this value to replace tabs by spaces in code fragments.
 188 | 
 189 | TAB_SIZE               = 4
 190 | 
 191 | # This tag can be used to specify a number of aliases that acts
 192 | # as commands in the documentation. An alias has the form "name=value".
 193 | # For example adding "sideeffect=\par Side Effects:\n" will allow you to
 194 | # put the command \sideeffect (or @sideeffect) in the documentation, which
 195 | # will result in a user-defined paragraph with heading "Side Effects:".
 196 | # You can put \n's in the value part of an alias to insert newlines.
 197 | 
 198 | ALIASES                =
 199 | 
 200 | # This tag can be used to specify a number of word-keyword mappings (TCL only).
 201 | # A mapping has the form "name=value". For example adding
 202 | # "class=itcl::class" will allow you to use the command class in the
 203 | # itcl::class meaning.
 204 | 
 205 | TCL_SUBST              =
 206 | 
 207 | # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C
 208 | # sources only. Doxygen will then generate output that is more tailored for C.
 209 | # For instance, some of the names that are used will be different. The list
 210 | # of all members will be omitted, etc.
 211 | 
 212 | OPTIMIZE_OUTPUT_FOR_C  = YES
 213 | 
 214 | # Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java
 215 | # sources only. Doxygen will then generate output that is more tailored for
 216 | # Java. For instance, namespaces will be presented as packages, qualified
 217 | # scopes will look different, etc.
 218 | 
 219 | OPTIMIZE_OUTPUT_JAVA   = NO
 220 | 
 221 | # Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran
 222 | # sources only. Doxygen will then generate output that is more tailored for
 223 | # Fortran.
 224 | 
 225 | OPTIMIZE_FOR_FORTRAN   = NO
 226 | 
 227 | # Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL
 228 | # sources. Doxygen will then generate output that is tailored for
 229 | # VHDL.
 230 | 
 231 | OPTIMIZE_OUTPUT_VHDL   = NO
 232 | 
 233 | # Doxygen selects the parser to use depending on the extension of the files it
 234 | # parses. With this tag you can assign which parser to use for a given
 235 | # extension. Doxygen has a built-in mapping, but you can override or extend it
 236 | # using this tag. The format is ext=language, where ext is a file extension,
 237 | # and language is one of the parsers supported by doxygen: IDL, Java,
 238 | # Javascript, CSharp, C, C++, D, PHP, Objective-C, Python, Fortran, VHDL, C,
 239 | # C++. For instance to make doxygen treat .inc files as Fortran files (default
 240 | # is PHP), and .f files as C (default is Fortran), use: inc=Fortran f=C. Note
 241 | # that for custom extensions you also need to set FILE_PATTERNS otherwise the
 242 | # files are not read by doxygen.
 243 | 
 244 | EXTENSION_MAPPING      =
 245 | 
 246 | # If MARKDOWN_SUPPORT is enabled (the default) then doxygen pre-processes all
 247 | # comments according to the Markdown format, which allows for more readable
 248 | # documentation. See http://daringfireball.net/projects/markdown/ for details.
 249 | # The output of markdown processing is further processed by doxygen, so you
 250 | # can mix doxygen, HTML, and XML commands with Markdown formatting.
 251 | # Disable only in case of backward compatibilities issues.
 252 | 
 253 | MARKDOWN_SUPPORT       = YES
 254 | 
 255 | # When enabled doxygen tries to link words that correspond to documented classes,
 256 | # or namespaces to their corresponding documentation. Such a link can be
 257 | # prevented in individual cases by by putting a % sign in front of the word or
 258 | # globally by setting AUTOLINK_SUPPORT to NO.
 259 | 
 260 | AUTOLINK_SUPPORT       = YES
 261 | 
 262 | # If you use STL classes (i.e. std::string, std::vector, etc.) but do not want
 263 | # to include (a tag file for) the STL sources as input, then you should
 264 | # set this tag to YES in order to let doxygen match functions declarations and
 265 | # definitions whose arguments contain STL classes (e.g. func(std::string); v.s.
 266 | # func(std::string) {}). This also makes the inheritance and collaboration
 267 | # diagrams that involve STL classes more complete and accurate.
 268 | 
 269 | BUILTIN_STL_SUPPORT    = NO
 270 | 
 271 | # If you use Microsoft's C++/CLI language, you should set this option to YES to
 272 | # enable parsing support.
 273 | 
 274 | CPP_CLI_SUPPORT        = NO
 275 | 
 276 | # Set the SIP_SUPPORT tag to YES if your project consists of sip sources only.
 277 | # Doxygen will parse them like normal C++ but will assume all classes use public
 278 | # instead of private inheritance when no explicit protection keyword is present.
 279 | 
 280 | SIP_SUPPORT            = NO
 281 | 
 282 | # For Microsoft's IDL there are propget and propput attributes to indicate
 283 | # getter and setter methods for a property. Setting this option to YES (the
 284 | # default) will make doxygen replace the get and set methods by a property in
 285 | # the documentation. This will only work if the methods are indeed getting or
 286 | # setting a simple type. If this is not the case, or you want to show the
 287 | # methods anyway, you should set this option to NO.
 288 | 
 289 | IDL_PROPERTY_SUPPORT   = YES
 290 | 
 291 | # If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC
 292 | # tag is set to YES, then doxygen will reuse the documentation of the first
 293 | # member in the group (if any) for the other members of the group. By default
 294 | # all members of a group must be documented explicitly.
 295 | 
 296 | DISTRIBUTE_GROUP_DOC   = NO
 297 | 
 298 | # Set the SUBGROUPING tag to YES (the default) to allow class member groups of
 299 | # the same type (for instance a group of public functions) to be put as a
 300 | # subgroup of that type (e.g. under the Public Functions section). Set it to
 301 | # NO to prevent subgrouping. Alternatively, this can be done per class using
 302 | # the \nosubgrouping command.
 303 | 
 304 | SUBGROUPING            = YES
 305 | 
 306 | # When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and
 307 | # unions are shown inside the group in which they are included (e.g. using
 308 | # @ingroup) instead of on a separate page (for HTML and Man pages) or
 309 | # section (for LaTeX and RTF).
 310 | 
 311 | INLINE_GROUPED_CLASSES = NO
 312 | 
 313 | # When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and
 314 | # unions with only public data fields will be shown inline in the documentation
 315 | # of the scope in which they are defined (i.e. file, namespace, or group
 316 | # documentation), provided this scope is documented. If set to NO (the default),
 317 | # structs, classes, and unions are shown on a separate page (for HTML and Man
 318 | # pages) or section (for LaTeX and RTF).
 319 | 
 320 | INLINE_SIMPLE_STRUCTS  = NO
 321 | 
 322 | # When TYPEDEF_HIDES_STRUCT is enabled, a typedef of a struct, union, or enum
 323 | # is documented as struct, union, or enum with the name of the typedef. So
 324 | # typedef struct TypeS {} TypeT, will appear in the documentation as a struct
 325 | # with name TypeT. When disabled the typedef will appear as a member of a file,
 326 | # namespace, or class. And the struct will be named TypeS. This can typically
 327 | # be useful for C code in case the coding convention dictates that all compound
 328 | # types are typedef'ed and only the typedef is referenced, never the tag name.
 329 | 
 330 | TYPEDEF_HIDES_STRUCT   = NO
 331 | 
 332 | # The SYMBOL_CACHE_SIZE determines the size of the internal cache use to
 333 | # determine which symbols to keep in memory and which to flush to disk.
 334 | # When the cache is full, less often used symbols will be written to disk.
 335 | # For small to medium size projects (<1000 input files) the default value is
 336 | # probably good enough. For larger projects a too small cache size can cause
 337 | # doxygen to be busy swapping symbols to and from disk most of the time
 338 | # causing a significant performance penalty.
 339 | # If the system has enough physical memory increasing the cache will improve the
 340 | # performance by keeping more symbols in memory. Note that the value works on
 341 | # a logarithmic scale so increasing the size by one will roughly double the
 342 | # memory usage. The cache size is given by this formula:
 343 | # 2^(16+SYMBOL_CACHE_SIZE). The valid range is 0..9, the default is 0,
 344 | # corresponding to a cache size of 2^16 = 65536 symbols.
 345 | 
 346 | SYMBOL_CACHE_SIZE      = 0
 347 | 
 348 | # Similar to the SYMBOL_CACHE_SIZE the size of the symbol lookup cache can be
 349 | # set using LOOKUP_CACHE_SIZE. This cache is used to resolve symbols given
 350 | # their name and scope. Since this can be an expensive process and often the
 351 | # same symbol appear multiple times in the code, doxygen keeps a cache of
 352 | # pre-resolved symbols. If the cache is too small doxygen will become slower.
 353 | # If the cache is too large, memory is wasted. The cache size is given by this
 354 | # formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range is 0..9, the default is 0,
 355 | # corresponding to a cache size of 2^16 = 65536 symbols.
 356 | 
 357 | LOOKUP_CACHE_SIZE      = 0
 358 | 
 359 | #---------------------------------------------------------------------------
 360 | # Build related configuration options
 361 | #---------------------------------------------------------------------------
 362 | 
 363 | # If the EXTRACT_ALL tag is set to YES doxygen will assume all entities in
 364 | # documentation are documented, even if no documentation was available.
 365 | # Private class members and static file members will be hidden unless
 366 | # the EXTRACT_PRIVATE and EXTRACT_STATIC tags are set to YES
 367 | 
 368 | EXTRACT_ALL            = YES
 369 | 
 370 | # If the EXTRACT_PRIVATE tag is set to YES all private members of a class
 371 | # will be included in the documentation.
 372 | 
 373 | EXTRACT_PRIVATE        = NO
 374 | 
 375 | # If the EXTRACT_PACKAGE tag is set to YES all members with package or internal
 376 | # scope will be included in the documentation.
 377 | 
 378 | EXTRACT_PACKAGE        = NO
 379 | 
 380 | # If the EXTRACT_STATIC tag is set to YES all static members of a file
 381 | # will be included in the documentation.
 382 | 
 383 | EXTRACT_STATIC         = NO
 384 | 
 385 | # If the EXTRACT_LOCAL_CLASSES tag is set to YES classes (and structs)
 386 | # defined locally in source files will be included in the documentation.
 387 | # If set to NO only classes defined in header files are included.
 388 | 
 389 | EXTRACT_LOCAL_CLASSES  = YES
 390 | 
 391 | # This flag is only useful for Objective-C code. When set to YES local
 392 | # methods, which are defined in the implementation section but not in
 393 | # the interface are included in the documentation.
 394 | # If set to NO (the default) only methods in the interface are included.
 395 | 
 396 | EXTRACT_LOCAL_METHODS  = NO
 397 | 
 398 | # If this flag is set to YES, the members of anonymous namespaces will be
 399 | # extracted and appear in the documentation as a namespace called
 400 | # 'anonymous_namespace{file}', where file will be replaced with the base
 401 | # name of the file that contains the anonymous namespace. By default
 402 | # anonymous namespaces are hidden.
 403 | 
 404 | EXTRACT_ANON_NSPACES   = NO
 405 | 
 406 | # If the HIDE_UNDOC_MEMBERS tag is set to YES, Doxygen will hide all
 407 | # undocumented members of documented classes, files or namespaces.
 408 | # If set to NO (the default) these members will be included in the
 409 | # various overviews, but no documentation section is generated.
 410 | # This option has no effect if EXTRACT_ALL is enabled.
 411 | 
 412 | HIDE_UNDOC_MEMBERS     = NO
 413 | 
 414 | # If the HIDE_UNDOC_CLASSES tag is set to YES, Doxygen will hide all
 415 | # undocumented classes that are normally visible in the class hierarchy.
 416 | # If set to NO (the default) these classes will be included in the various
 417 | # overviews. This option has no effect if EXTRACT_ALL is enabled.
 418 | 
 419 | HIDE_UNDOC_CLASSES     = NO
 420 | 
 421 | # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, Doxygen will hide all
 422 | # friend (class|struct|union) declarations.
 423 | # If set to NO (the default) these declarations will be included in the
 424 | # documentation.
 425 | 
 426 | HIDE_FRIEND_COMPOUNDS  = NO
 427 | 
 428 | # If the HIDE_IN_BODY_DOCS tag is set to YES, Doxygen will hide any
 429 | # documentation blocks found inside the body of a function.
 430 | # If set to NO (the default) these blocks will be appended to the
 431 | # function's detailed documentation block.
 432 | 
 433 | HIDE_IN_BODY_DOCS      = NO
 434 | 
 435 | # The INTERNAL_DOCS tag determines if documentation
 436 | # that is typed after a \internal command is included. If the tag is set
 437 | # to NO (the default) then the documentation will be excluded.
 438 | # Set it to YES to include the internal documentation.
 439 | 
 440 | INTERNAL_DOCS          = NO
 441 | 
 442 | # If the CASE_SENSE_NAMES tag is set to NO then Doxygen will only generate
 443 | # file names in lower-case letters. If set to YES upper-case letters are also
 444 | # allowed. This is useful if you have classes or files whose names only differ
 445 | # in case and if your file system supports case sensitive file names. Windows
 446 | # and Mac users are advised to set this option to NO.
 447 | 
 448 | CASE_SENSE_NAMES       = NO
 449 | 
 450 | # If the HIDE_SCOPE_NAMES tag is set to NO (the default) then Doxygen
 451 | # will show members with their full class and namespace scopes in the
 452 | # documentation. If set to YES the scope will be hidden.
 453 | 
 454 | HIDE_SCOPE_NAMES       = NO
 455 | 
 456 | # If the SHOW_INCLUDE_FILES tag is set to YES (the default) then Doxygen
 457 | # will put a list of the files that are included by a file in the documentation
 458 | # of that file.
 459 | 
 460 | SHOW_INCLUDE_FILES     = YES
 461 | 
 462 | # If the FORCE_LOCAL_INCLUDES tag is set to YES then Doxygen
 463 | # will list include files with double quotes in the documentation
 464 | # rather than with sharp brackets.
 465 | 
 466 | FORCE_LOCAL_INCLUDES   = NO
 467 | 
 468 | # If the INLINE_INFO tag is set to YES (the default) then a tag [inline]
 469 | # is inserted in the documentation for inline members.
 470 | 
 471 | INLINE_INFO            = YES
 472 | 
 473 | # If the SORT_MEMBER_DOCS tag is set to YES (the default) then doxygen
 474 | # will sort the (detailed) documentation of file and class members
 475 | # alphabetically by member name. If set to NO the members will appear in
 476 | # declaration order.
 477 | 
 478 | SORT_MEMBER_DOCS       = YES
 479 | 
 480 | # If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the
 481 | # brief documentation of file, namespace and class members alphabetically
 482 | # by member name. If set to NO (the default) the members will appear in
 483 | # declaration order.
 484 | 
 485 | SORT_BRIEF_DOCS        = NO
 486 | 
 487 | # If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen
 488 | # will sort the (brief and detailed) documentation of class members so that
 489 | # constructors and destructors are listed first. If set to NO (the default)
 490 | # the constructors will appear in the respective orders defined by
 491 | # SORT_MEMBER_DOCS and SORT_BRIEF_DOCS.
 492 | # This tag will be ignored for brief docs if SORT_BRIEF_DOCS is set to NO
 493 | # and ignored for detailed docs if SORT_MEMBER_DOCS is set to NO.
 494 | 
 495 | SORT_MEMBERS_CTORS_1ST = NO
 496 | 
 497 | # If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the
 498 | # hierarchy of group names into alphabetical order. If set to NO (the default)
 499 | # the group names will appear in their defined order.
 500 | 
 501 | SORT_GROUP_NAMES       = NO
 502 | 
 503 | # If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be
 504 | # sorted by fully-qualified names, including namespaces. If set to
 505 | # NO (the default), the class list will be sorted only by class name,
 506 | # not including the namespace part.
 507 | # Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES.
 508 | # Note: This option applies only to the class list, not to the
 509 | # alphabetical list.
 510 | 
 511 | SORT_BY_SCOPE_NAME     = NO
 512 | 
 513 | # If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to
 514 | # do proper type resolution of all parameters of a function it will reject a
 515 | # match between the prototype and the implementation of a member function even
 516 | # if there is only one candidate or it is obvious which candidate to choose
 517 | # by doing a simple string match. By disabling STRICT_PROTO_MATCHING doxygen
 518 | # will still accept a match between prototype and implementation in such cases.
 519 | 
 520 | STRICT_PROTO_MATCHING  = NO
 521 | 
 522 | # The GENERATE_TODOLIST tag can be used to enable (YES) or
 523 | # disable (NO) the todo list. This list is created by putting \todo
 524 | # commands in the documentation.
 525 | 
 526 | GENERATE_TODOLIST      = YES
 527 | 
 528 | # The GENERATE_TESTLIST tag can be used to enable (YES) or
 529 | # disable (NO) the test list. This list is created by putting \test
 530 | # commands in the documentation.
 531 | 
 532 | GENERATE_TESTLIST      = YES
 533 | 
 534 | # The GENERATE_BUGLIST tag can be used to enable (YES) or
 535 | # disable (NO) the bug list. This list is created by putting \bug
 536 | # commands in the documentation.
 537 | 
 538 | GENERATE_BUGLIST       = YES
 539 | 
 540 | # The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or
 541 | # disable (NO) the deprecated list. This list is created by putting
 542 | # \deprecated commands in the documentation.
 543 | 
 544 | GENERATE_DEPRECATEDLIST= YES
 545 | 
 546 | # The ENABLED_SECTIONS tag can be used to enable conditional
 547 | # documentation sections, marked by \if section-label ... \endif
 548 | # and \cond section-label ... \endcond blocks.
 549 | 
 550 | ENABLED_SECTIONS       =
 551 | 
 552 | # The MAX_INITIALIZER_LINES tag determines the maximum number of lines
 553 | # the initial value of a variable or macro consists of for it to appear in
 554 | # the documentation. If the initializer consists of more lines than specified
 555 | # here it will be hidden. Use a value of 0 to hide initializers completely.
 556 | # The appearance of the initializer of individual variables and macros in the
 557 | # documentation can be controlled using \showinitializer or \hideinitializer
 558 | # command in the documentation regardless of this setting.
 559 | 
 560 | MAX_INITIALIZER_LINES  = 30
 561 | 
 562 | # Set the SHOW_USED_FILES tag to NO to disable the list of files generated
 563 | # at the bottom of the documentation of classes and structs. If set to YES the
 564 | # list will mention the files that were used to generate the documentation.
 565 | 
 566 | SHOW_USED_FILES        = YES
 567 | 
 568 | # Set the SHOW_FILES tag to NO to disable the generation of the Files page.
 569 | # This will remove the Files entry from the Quick Index and from the
 570 | # Folder Tree View (if specified). The default is YES.
 571 | 
 572 | SHOW_FILES             = YES
 573 | 
 574 | # Set the SHOW_NAMESPACES tag to NO to disable the generation of the
 575 | # Namespaces page.
 576 | # This will remove the Namespaces entry from the Quick Index
 577 | # and from the Folder Tree View (if specified). The default is YES.
 578 | 
 579 | SHOW_NAMESPACES        = YES
 580 | 
 581 | # The FILE_VERSION_FILTER tag can be used to specify a program or script that
 582 | # doxygen should invoke to get the current version for each file (typically from
 583 | # the version control system). Doxygen will invoke the program by executing (via
 584 | # popen()) the command <command> <input-file>, where <command> is the value of
 585 | # the FILE_VERSION_FILTER tag, and <input-file> is the name of an input file
 586 | # provided by doxygen. Whatever the program writes to standard output
 587 | # is used as the file version. See the manual for examples.
 588 | 
 589 | FILE_VERSION_FILTER    =
 590 | 
 591 | # The LAYOUT_FILE tag can be used to specify a layout file which will be parsed
 592 | # by doxygen. The layout file controls the global structure of the generated
 593 | # output files in an output format independent way. To create the layout file
 594 | # that represents doxygen's defaults, run doxygen with the -l option.
 595 | # You can optionally specify a file name after the option, if omitted
 596 | # DoxygenLayout.xml will be used as the name of the layout file.
 597 | 
 598 | LAYOUT_FILE            =
 599 | 
 600 | # The CITE_BIB_FILES tag can be used to specify one or more bib files
 601 | # containing the references data. This must be a list of .bib files. The
 602 | # .bib extension is automatically appended if omitted. Using this command
 603 | # requires the bibtex tool to be installed. See also
 604 | # http://en.wikipedia.org/wiki/BibTeX for more info. For LaTeX the style
 605 | # of the bibliography can be controlled using LATEX_BIB_STYLE. To use this
 606 | # feature you need bibtex and perl available in the search path. Do not use
 607 | # file names with spaces, bibtex cannot handle them.
 608 | 
 609 | CITE_BIB_FILES         =
 610 | 
 611 | #---------------------------------------------------------------------------
 612 | # configuration options related to warning and progress messages
 613 | #---------------------------------------------------------------------------
 614 | 
 615 | # The QUIET tag can be used to turn on/off the messages that are generated
 616 | # by doxygen. Possible values are YES and NO. If left blank NO is used.
 617 | 
 618 | QUIET                  = NO
 619 | 
 620 | # The WARNINGS tag can be used to turn on/off the warning messages that are
 621 | # generated by doxygen. Possible values are YES and NO. If left blank
 622 | # NO is used.
 623 | 
 624 | WARNINGS               = YES
 625 | 
 626 | # If WARN_IF_UNDOCUMENTED is set to YES, then doxygen will generate warnings
 627 | # for undocumented members. If EXTRACT_ALL is set to YES then this flag will
 628 | # automatically be disabled.
 629 | 
 630 | WARN_IF_UNDOCUMENTED   = YES
 631 | 
 632 | # If WARN_IF_DOC_ERROR is set to YES, doxygen will generate warnings for
 633 | # potential errors in the documentation, such as not documenting some
 634 | # parameters in a documented function, or documenting parameters that
 635 | # don't exist or using markup commands wrongly.
 636 | 
 637 | WARN_IF_DOC_ERROR      = YES
 638 | 
 639 | # The WARN_NO_PARAMDOC option can be enabled to get warnings for
 640 | # functions that are documented, but have no documentation for their parameters
 641 | # or return value. If set to NO (the default) doxygen will only warn about
 642 | # wrong or incomplete parameter documentation, but not about the absence of
 643 | # documentation.
 644 | 
 645 | WARN_NO_PARAMDOC       = NO
 646 | 
 647 | # The WARN_FORMAT tag determines the format of the warning messages that
 648 | # doxygen can produce. The string should contain the $file, $line, and $text
 649 | # tags, which will be replaced by the file and line number from which the
 650 | # warning originated and the warning text. Optionally the format may contain
 651 | # $version, which will be replaced by the version of the file (if it could
 652 | # be obtained via FILE_VERSION_FILTER)
 653 | 
 654 | WARN_FORMAT            = "$file:$line: $text"
 655 | 
 656 | # The WARN_LOGFILE tag can be used to specify a file to which warning
 657 | # and error messages should be written. If left blank the output is written
 658 | # to stderr.
 659 | 
 660 | WARN_LOGFILE           =
 661 | 
 662 | #---------------------------------------------------------------------------
 663 | # configuration options related to the input files
 664 | #---------------------------------------------------------------------------
 665 | 
 666 | # The INPUT tag can be used to specify the files and/or directories that contain
 667 | # documented source files. You may enter file names like "myfile.cpp" or
 668 | # directories like "/usr/src/myproject". Separate the files or directories
 669 | # with spaces.
 670 | 
 671 | INPUT                  = include/
 672 | 
 673 | # This tag can be used to specify the character encoding of the source files
 674 | # that doxygen parses. Internally doxygen uses the UTF-8 encoding, which is
 675 | # also the default input encoding. Doxygen uses libiconv (or the iconv built
 676 | # into libc) for the transcoding. See http://www.gnu.org/software/libiconv for
 677 | # the list of possible encodings.
 678 | 
 679 | INPUT_ENCODING         = UTF-8
 680 | 
 681 | # If the value of the INPUT tag contains directories, you can use the
 682 | # FILE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
 683 | # and *.h) to filter out the source-files in the directories. If left
 684 | # blank the following patterns are tested:
 685 | # *.c *.cc *.cxx *.cpp *.c++ *.d *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh
 686 | # *.hxx *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.dox *.py
 687 | # *.f90 *.f *.for *.vhd *.vhdl
 688 | 
 689 | FILE_PATTERNS          =
 690 | 
 691 | # The RECURSIVE tag can be used to turn specify whether or not subdirectories
 692 | # should be searched for input files as well. Possible values are YES and NO.
 693 | # If left blank NO is used.
 694 | 
 695 | RECURSIVE              = NO
 696 | 
 697 | # The EXCLUDE tag can be used to specify files and/or directories that should be
 698 | # excluded from the INPUT source files. This way you can easily exclude a
 699 | # subdirectory from a directory tree whose root is specified with the INPUT tag.
 700 | # Note that relative paths are relative to the directory from which doxygen is
 701 | # run.
 702 | 
 703 | EXCLUDE                =
 704 | 
 705 | # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 706 | # directories that are symbolic links (a Unix file system feature) are excluded
 707 | # from the input.
 708 | 
 709 | EXCLUDE_SYMLINKS       = NO
 710 | 
 711 | # If the value of the INPUT tag contains directories, you can use the
 712 | # EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude
 713 | # certain files from those directories. Note that the wildcards are matched
 714 | # against the file with absolute path, so to exclude all test directories
 715 | # for example use the pattern */test/*
 716 | 
 717 | EXCLUDE_PATTERNS       =
 718 | 
 719 | # The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names
 720 | # (namespaces, classes, functions, etc.) that should be excluded from the
 721 | # output. The symbol name can be a fully qualified name, a word, or if the
 722 | # wildcard * is used, a substring. Examples: ANamespace, AClass,
 723 | # AClass::ANamespace, ANamespace::*Test
 724 | 
 725 | EXCLUDE_SYMBOLS        =
 726 | 
 727 | # The EXAMPLE_PATH tag can be used to specify one or more files or
 728 | # directories that contain example code fragments that are included (see
 729 | # the \include command).
 730 | 
 731 | EXAMPLE_PATH           =
 732 | 
 733 | # If the value of the EXAMPLE_PATH tag contains directories, you can use the
 734 | # EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp
 735 | # and *.h) to filter out the source-files in the directories. If left
 736 | # blank all files are included.
 737 | 
 738 | EXAMPLE_PATTERNS       =
 739 | 
 740 | # If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be
 741 | # searched for input files to be used with the \include or \dontinclude
 742 | # commands irrespective of the value of the RECURSIVE tag.
 743 | # Possible values are YES and NO. If left blank NO is used.
 744 | 
 745 | EXAMPLE_RECURSIVE      = NO
 746 | 
 747 | # The IMAGE_PATH tag can be used to specify one or more files or
 748 | # directories that contain image that are included in the documentation (see
 749 | # the \image command).
 750 | 
 751 | IMAGE_PATH             =
 752 | 
 753 | # The INPUT_FILTER tag can be used to specify a program that doxygen should
 754 | # invoke to filter for each input file. Doxygen will invoke the filter program
 755 | # by executing (via popen()) the command <filter> <input-file>, where <filter>
 756 | # is the value of the INPUT_FILTER tag, and <input-file> is the name of an
 757 | # input file. Doxygen will then use the output that the filter program writes
 758 | # to standard output.
 759 | # If FILTER_PATTERNS is specified, this tag will be
 760 | # ignored.
 761 | 
 762 | INPUT_FILTER           =
 763 | 
 764 | # The FILTER_PATTERNS tag can be used to specify filters on a per file pattern
 765 | # basis.
 766 | # Doxygen will compare the file name with each pattern and apply the
 767 | # filter if there is a match.
 768 | # The filters are a list of the form:
 769 | # pattern=filter (like *.cpp=my_cpp_filter). See INPUT_FILTER for further
 770 | # info on how filters are used. If FILTER_PATTERNS is empty or if
 771 | # non of the patterns match the file name, INPUT_FILTER is applied.
 772 | 
 773 | FILTER_PATTERNS        =
 774 | 
 775 | # If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using
 776 | # INPUT_FILTER) will be used to filter the input files when producing source
 777 | # files to browse (i.e. when SOURCE_BROWSER is set to YES).
 778 | 
 779 | FILTER_SOURCE_FILES    = NO
 780 | 
 781 | # The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file
 782 | # pattern. A pattern will override the setting for FILTER_PATTERN (if any)
 783 | # and it is also possible to disable source filtering for a specific pattern
 784 | # using *.ext= (so without naming a filter). This option only has effect when
 785 | # FILTER_SOURCE_FILES is enabled.
 786 | 
 787 | FILTER_SOURCE_PATTERNS =
 788 | 
 789 | # If the USE_MD_FILE_AS_MAINPAGE tag refers to the name of a markdown file that
 790 | # is part of the input, its contents will be placed on the main page (index.html).
 791 | # This can be useful if you have a project on for instance GitHub and want reuse
 792 | # the introduction page also for the doxygen output.
 793 | 
 794 | USE_MDFILE_AS_MAINPAGE =
 795 | 
 796 | #---------------------------------------------------------------------------
 797 | # configuration options related to source browsing
 798 | #---------------------------------------------------------------------------
 799 | 
 800 | # If the SOURCE_BROWSER tag is set to YES then a list of source files will
 801 | # be generated. Documented entities will be cross-referenced with these sources.
 802 | # Note: To get rid of all source code in the generated output, make sure also
 803 | # VERBATIM_HEADERS is set to NO.
 804 | 
 805 | SOURCE_BROWSER         = YES
 806 | 
 807 | # Setting the INLINE_SOURCES tag to YES will include the body
 808 | # of functions and classes directly in the documentation.
 809 | 
 810 | INLINE_SOURCES         = NO
 811 | 
 812 | # Setting the STRIP_CODE_COMMENTS tag to YES (the default) will instruct
 813 | # doxygen to hide any special comment blocks from generated source code
 814 | # fragments. Normal C, C++ and Fortran comments will always remain visible.
 815 | 
 816 | STRIP_CODE_COMMENTS    = YES
 817 | 
 818 | # If the REFERENCED_BY_RELATION tag is set to YES
 819 | # then for each documented function all documented
 820 | # functions referencing it will be listed.
 821 | 
 822 | REFERENCED_BY_RELATION = NO
 823 | 
 824 | # If the REFERENCES_RELATION tag is set to YES
 825 | # then for each documented function all documented entities
 826 | # called/used by that function will be listed.
 827 | 
 828 | REFERENCES_RELATION    = NO
 829 | 
 830 | # If the REFERENCES_LINK_SOURCE tag is set to YES (the default)
 831 | # and SOURCE_BROWSER tag is set to YES, then the hyperlinks from
 832 | # functions in REFERENCES_RELATION and REFERENCED_BY_RELATION lists will
 833 | # link to the source code.
 834 | # Otherwise they will link to the documentation.
 835 | 
 836 | REFERENCES_LINK_SOURCE = YES
 837 | 
 838 | # If the USE_HTAGS tag is set to YES then the references to source code
 839 | # will point to the HTML generated by the htags(1) tool instead of doxygen
 840 | # built-in source browser. The htags tool is part of GNU's global source
 841 | # tagging system (see http://www.gnu.org/software/global/global.html). You
 842 | # will need version 4.8.6 or higher.
 843 | 
 844 | USE_HTAGS              = NO
 845 | 
 846 | # If the VERBATIM_HEADERS tag is set to YES (the default) then Doxygen
 847 | # will generate a verbatim copy of the header file for each class for
 848 | # which an include is specified. Set to NO to disable this.
 849 | 
 850 | VERBATIM_HEADERS       = YES
 851 | 
 852 | #---------------------------------------------------------------------------
 853 | # configuration options related to the alphabetical class index
 854 | #---------------------------------------------------------------------------
 855 | 
 856 | # If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index
 857 | # of all compounds will be generated. Enable this if the project
 858 | # contains a lot of classes, structs, unions or interfaces.
 859 | 
 860 | ALPHABETICAL_INDEX     = YES
 861 | 
 862 | # If the alphabetical index is enabled (see ALPHABETICAL_INDEX) then
 863 | # the COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns
 864 | # in which this list will be split (can be a number in the range [1..20])
 865 | 
 866 | COLS_IN_ALPHA_INDEX    = 5
 867 | 
 868 | # In case all classes in a project start with a common prefix, all
 869 | # classes will be put under the same header in the alphabetical index.
 870 | # The IGNORE_PREFIX tag can be used to specify one or more prefixes that
 871 | # should be ignored while generating the index headers.
 872 | 
 873 | IGNORE_PREFIX          =
 874 | 
 875 | #---------------------------------------------------------------------------
 876 | # configuration options related to the HTML output
 877 | #---------------------------------------------------------------------------
 878 | 
 879 | # If the GENERATE_HTML tag is set to YES (the default) Doxygen will
 880 | # generate HTML output.
 881 | 
 882 | GENERATE_HTML          = YES
 883 | 
 884 | # The HTML_OUTPUT tag is used to specify where the HTML docs will be put.
 885 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
 886 | # put in front of it. If left blank `html' will be used as the default path.
 887 | 
 888 | HTML_OUTPUT            = docs/
 889 | 
 890 | # The HTML_FILE_EXTENSION tag can be used to specify the file extension for
 891 | # each generated HTML page (for example: .htm,.php,.asp). If it is left blank
 892 | # doxygen will generate files with .html extension.
 893 | 
 894 | HTML_FILE_EXTENSION    = .html
 895 | 
 896 | # The HTML_HEADER tag can be used to specify a personal HTML header for
 897 | # each generated HTML page. If it is left blank doxygen will generate a
 898 | # standard header. Note that when using a custom header you are responsible
 899 | #  for the proper inclusion of any scripts and style sheets that doxygen
 900 | # needs, which is dependent on the configuration options used.
 901 | # It is advised to generate a default header using "doxygen -w html
 902 | # header.html footer.html stylesheet.css YourConfigFile" and then modify
 903 | # that header. Note that the header is subject to change so you typically
 904 | # have to redo this when upgrading to a newer version of doxygen or when
 905 | # changing the value of configuration settings such as GENERATE_TREEVIEW!
 906 | 
 907 | HTML_HEADER            =
 908 | 
 909 | # The HTML_FOOTER tag can be used to specify a personal HTML footer for
 910 | # each generated HTML page. If it is left blank doxygen will generate a
 911 | # standard footer.
 912 | 
 913 | HTML_FOOTER            =
 914 | 
 915 | # The HTML_STYLESHEET tag can be used to specify a user-defined cascading
 916 | # style sheet that is used by each HTML page. It can be used to
 917 | # fine-tune the look of the HTML output. If left blank doxygen will
 918 | # generate a default style sheet. Note that it is recommended to use
 919 | # HTML_EXTRA_STYLESHEET instead of this one, as it is more robust and this
 920 | # tag will in the future become obsolete.
 921 | 
 922 | HTML_STYLESHEET        =
 923 | 
 924 | # The HTML_EXTRA_STYLESHEET tag can be used to specify an additional
 925 | # user-defined cascading style sheet that is included after the standard
 926 | # style sheets created by doxygen. Using this option one can overrule
 927 | # certain style aspects. This is preferred over using HTML_STYLESHEET
 928 | # since it does not replace the standard style sheet and is therefor more
 929 | # robust against future updates. Doxygen will copy the style sheet file to
 930 | # the output directory.
 931 | 
 932 | HTML_EXTRA_STYLESHEET  =
 933 | 
 934 | # The HTML_EXTRA_FILES tag can be used to specify one or more extra images or
 935 | # other source files which should be copied to the HTML output directory. Note
 936 | # that these files will be copied to the base HTML output directory. Use the
 937 | # $relpath$ marker in the HTML_HEADER and/or HTML_FOOTER files to load these
 938 | # files. In the HTML_STYLESHEET file, use the file name only. Also note that
 939 | # the files will be copied as-is; there are no commands or markers available.
 940 | 
 941 | HTML_EXTRA_FILES       =
 942 | 
 943 | # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output.
 944 | # Doxygen will adjust the colors in the style sheet and background images
 945 | # according to this color. Hue is specified as an angle on a colorwheel,
 946 | # see http://en.wikipedia.org/wiki/Hue for more information.
 947 | # For instance the value 0 represents red, 60 is yellow, 120 is green,
 948 | # 180 is cyan, 240 is blue, 300 purple, and 360 is red again.
 949 | # The allowed range is 0 to 359.
 950 | 
 951 | HTML_COLORSTYLE_HUE    = 220
 952 | 
 953 | # The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of
 954 | # the colors in the HTML output. For a value of 0 the output will use
 955 | # grayscales only. A value of 255 will produce the most vivid colors.
 956 | 
 957 | HTML_COLORSTYLE_SAT    = 100
 958 | 
 959 | # The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to
 960 | # the luminance component of the colors in the HTML output. Values below
 961 | # 100 gradually make the output lighter, whereas values above 100 make
 962 | # the output darker. The value divided by 100 is the actual gamma applied,
 963 | # so 80 represents a gamma of 0.8, The value 220 represents a gamma of 2.2,
 964 | # and 100 does not change the gamma.
 965 | 
 966 | HTML_COLORSTYLE_GAMMA  = 80
 967 | 
 968 | # If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML
 969 | # page will contain the date and time when the page was generated. Setting
 970 | # this to NO can help when comparing the output of multiple runs.
 971 | 
 972 | HTML_TIMESTAMP         = YES
 973 | 
 974 | # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 975 | # documentation will contain sections that can be hidden and shown after the
 976 | # page has loaded.
 977 | 
 978 | HTML_DYNAMIC_SECTIONS  = NO
 979 | 
 980 | # With HTML_INDEX_NUM_ENTRIES one can control the preferred number of
 981 | # entries shown in the various tree structured indices initially; the user
 982 | # can expand and collapse entries dynamically later on. Doxygen will expand
 983 | # the tree to such a level that at most the specified number of entries are
 984 | # visible (unless a fully collapsed tree already exceeds this amount).
 985 | # So setting the number of entries 1 will produce a full collapsed tree by
 986 | # default. 0 is a special value representing an infinite number of entries
 987 | # and will result in a full expanded tree by default.
 988 | 
 989 | HTML_INDEX_NUM_ENTRIES = 100
 990 | 
 991 | # If the GENERATE_DOCSET tag is set to YES, additional index files
 992 | # will be generated that can be used as input for Apple's Xcode 3
 993 | # integrated development environment, introduced with OSX 10.5 (Leopard).
 994 | # To create a documentation set, doxygen will generate a Makefile in the
 995 | # HTML output directory. Running make will produce the docset in that
 996 | # directory and running "make install" will install the docset in
 997 | # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find
 998 | # it at startup.
 999 | # See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
1000 | # for more information.
1001 | 
1002 | GENERATE_DOCSET        = NO
1003 | 
1004 | # When GENERATE_DOCSET tag is set to YES, this tag determines the name of the
1005 | # feed. A documentation feed provides an umbrella under which multiple
1006 | # documentation sets from a single provider (such as a company or product suite)
1007 | # can be grouped.
1008 | 
1009 | DOCSET_FEEDNAME        = "Doxygen generated docs"
1010 | 
1011 | # When GENERATE_DOCSET tag is set to YES, this tag specifies a string that
1012 | # should uniquely identify the documentation set bundle. This should be a
1013 | # reverse domain-name style string, e.g. com.mycompany.MyDocSet. Doxygen
1014 | # will append .docset to the name.
1015 | 
1016 | DOCSET_BUNDLE_ID       = org.doxygen.Project
1017 | 
1018 | # When GENERATE_PUBLISHER_ID tag specifies a string that should uniquely
1019 | # identify the documentation publisher. This should be a reverse domain-name
1020 | # style string, e.g. com.mycompany.MyDocSet.documentation.
1021 | 
1022 | DOCSET_PUBLISHER_ID    = org.doxygen.Publisher
1023 | 
1024 | # The GENERATE_PUBLISHER_NAME tag identifies the documentation publisher.
1025 | 
1026 | DOCSET_PUBLISHER_NAME  = Publisher
1027 | 
1028 | # If the GENERATE_HTMLHELP tag is set to YES, additional index files
1029 | # will be generated that can be used as input for tools like the
1030 | # Microsoft HTML help workshop to generate a compiled HTML help file (.chm)
1031 | # of the generated HTML documentation.
1032 | 
1033 | GENERATE_HTMLHELP      = NO
1034 | 
1035 | # If the GENERATE_HTMLHELP tag is set to YES, the CHM_FILE tag can
1036 | # be used to specify the file name of the resulting .chm file. You
1037 | # can add a path in front of the file if the result should not be
1038 | # written to the html output directory.
1039 | 
1040 | CHM_FILE               =
1041 | 
1042 | # If the GENERATE_HTMLHELP tag is set to YES, the HHC_LOCATION tag can
1043 | # be used to specify the location (absolute path including file name) of
1044 | # the HTML help compiler (hhc.exe). If non-empty doxygen will try to run
1045 | # the HTML help compiler on the generated index.hhp.
1046 | 
1047 | HHC_LOCATION           =
1048 | 
1049 | # If the GENERATE_HTMLHELP tag is set to YES, the GENERATE_CHI flag
1050 | # controls if a separate .chi index file is generated (YES) or that
1051 | # it should be included in the master .chm file (NO).
1052 | 
1053 | GENERATE_CHI           = NO
1054 | 
1055 | # If the GENERATE_HTMLHELP tag is set to YES, the CHM_INDEX_ENCODING
1056 | # is used to encode HtmlHelp index (hhk), content (hhc) and project file
1057 | # content.
1058 | 
1059 | CHM_INDEX_ENCODING     =
1060 | 
1061 | # If the GENERATE_HTMLHELP tag is set to YES, the BINARY_TOC flag
1062 | # controls whether a binary table of contents is generated (YES) or a
1063 | # normal table of contents (NO) in the .chm file.
1064 | 
1065 | BINARY_TOC             = NO
1066 | 
1067 | # The TOC_EXPAND flag can be set to YES to add extra items for group members
1068 | # to the contents of the HTML help documentation and to the tree view.
1069 | 
1070 | TOC_EXPAND             = NO
1071 | 
1072 | # If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and
1073 | # QHP_VIRTUAL_FOLDER are set, an additional index file will be generated
1074 | # that can be used as input for Qt's qhelpgenerator to generate a
1075 | # Qt Compressed Help (.qch) of the generated HTML documentation.
1076 | 
1077 | GENERATE_QHP           = NO
1078 | 
1079 | # If the QHG_LOCATION tag is specified, the QCH_FILE tag can
1080 | # be used to specify the file name of the resulting .qch file.
1081 | # The path specified is relative to the HTML output folder.
1082 | 
1083 | QCH_FILE               =
1084 | 
1085 | # The QHP_NAMESPACE tag specifies the namespace to use when generating
1086 | # Qt Help Project output. For more information please see
1087 | # http://doc.trolltech.com/qthelpproject.html#namespace
1088 | 
1089 | QHP_NAMESPACE          = org.doxygen.Project
1090 | 
1091 | # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating
1092 | # Qt Help Project output. For more information please see
1093 | # http://doc.trolltech.com/qthelpproject.html#virtual-folders
1094 | 
1095 | QHP_VIRTUAL_FOLDER     = doc
1096 | 
1097 | # If QHP_CUST_FILTER_NAME is set, it specifies the name of a custom filter to
1098 | # add. For more information please see
1099 | # http://doc.trolltech.com/qthelpproject.html#custom-filters
1100 | 
1101 | QHP_CUST_FILTER_NAME   =
1102 | 
1103 | # The QHP_CUST_FILT_ATTRS tag specifies the list of the attributes of the
1104 | # custom filter to add. For more information please see
1105 | # <a href="http://doc.trolltech.com/qthelpproject.html#custom-filters">
1106 | # Qt Help Project / Custom Filters</a>.
1107 | 
1108 | QHP_CUST_FILTER_ATTRS  =
1109 | 
1110 | # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
1111 | # project's
1112 | # filter section matches.
1113 | # <a href="http://doc.trolltech.com/qthelpproject.html#filter-attributes">
1114 | # Qt Help Project / Filter Attributes</a>.
1115 | 
1116 | QHP_SECT_FILTER_ATTRS  =
1117 | 
1118 | # If the GENERATE_QHP tag is set to YES, the QHG_LOCATION tag can
1119 | # be used to specify the location of Qt's qhelpgenerator.
1120 | # If non-empty doxygen will try to run qhelpgenerator on the generated
1121 | # .qhp file.
1122 | 
1123 | QHG_LOCATION           =
1124 | 
1125 | # If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files
1126 | #  will be generated, which together with the HTML files, form an Eclipse help
1127 | # plugin. To install this plugin and make it available under the help contents
1128 | # menu in Eclipse, the contents of the directory containing the HTML and XML
1129 | # files needs to be copied into the plugins directory of eclipse. The name of
1130 | # the directory within the plugins directory should be the same as
1131 | # the ECLIPSE_DOC_ID value. After copying Eclipse needs to be restarted before
1132 | # the help appears.
1133 | 
1134 | GENERATE_ECLIPSEHELP   = NO
1135 | 
1136 | # A unique identifier for the eclipse help plugin. When installing the plugin
1137 | # the directory name containing the HTML and XML files should also have
1138 | # this name.
1139 | 
1140 | ECLIPSE_DOC_ID         = org.doxygen.Project
1141 | 
1142 | # The DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs)
1143 | # at top of each HTML page. The value NO (the default) enables the index and
1144 | # the value YES disables it. Since the tabs have the same information as the
1145 | # navigation tree you can set this option to NO if you already set
1146 | # GENERATE_TREEVIEW to YES.
1147 | 
1148 | DISABLE_INDEX          = NO
1149 | 
1150 | # The GENERATE_TREEVIEW tag is used to specify whether a tree-like index
1151 | # structure should be generated to display hierarchical information.
1152 | # If the tag value is set to YES, a side panel will be generated
1153 | # containing a tree-like index structure (just like the one that
1154 | # is generated for HTML Help). For this to work a browser that supports
1155 | # JavaScript, DHTML, CSS and frames is required (i.e. any modern browser).
1156 | # Windows users are probably better off using the HTML help feature.
1157 | # Since the tree basically has the same information as the tab index you
1158 | # could consider to set DISABLE_INDEX to NO when enabling this option.
1159 | 
1160 | GENERATE_TREEVIEW      = NO
1161 | 
1162 | # The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values
1163 | # (range [0,1..20]) that doxygen will group on one line in the generated HTML
1164 | # documentation. Note that a value of 0 will completely suppress the enum
1165 | # values from appearing in the overview section.
1166 | 
1167 | ENUM_VALUES_PER_LINE   = 4
1168 | 
1169 | # If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be
1170 | # used to set the initial width (in pixels) of the frame in which the tree
1171 | # is shown.
1172 | 
1173 | TREEVIEW_WIDTH         = 250
1174 | 
1175 | # When the EXT_LINKS_IN_WINDOW option is set to YES doxygen will open
1176 | # links to external symbols imported via tag files in a separate window.
1177 | 
1178 | EXT_LINKS_IN_WINDOW    = NO
1179 | 
1180 | # Use this tag to change the font size of Latex formulas included
1181 | # as images in the HTML documentation. The default is 10. Note that
1182 | # when you change the font size after a successful doxygen run you need
1183 | # to manually remove any form_*.png images from the HTML output directory
1184 | # to force them to be regenerated.
1185 | 
1186 | FORMULA_FONTSIZE       = 10
1187 | 
1188 | # Use the FORMULA_TRANPARENT tag to determine whether or not the images
1189 | # generated for formulas are transparent PNGs. Transparent PNGs are
1190 | # not supported properly for IE 6.0, but are supported on all modern browsers.
1191 | # Note that when changing this option you need to delete any form_*.png files
1192 | # in the HTML output before the changes have effect.
1193 | 
1194 | FORMULA_TRANSPARENT    = YES
1195 | 
1196 | # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax
1197 | # (see http://www.mathjax.org) which uses client side Javascript for the
1198 | # rendering instead of using prerendered bitmaps. Use this if you do not
1199 | # have LaTeX installed or if you want to formulas look prettier in the HTML
1200 | # output. When enabled you may also need to install MathJax separately and
1201 | # configure the path to it using the MATHJAX_RELPATH option.
1202 | 
1203 | USE_MATHJAX            = NO
1204 | 
1205 | # When MathJax is enabled you can set the default output format to be used for
1206 | # thA MathJax output. Supported types are HTML-CSS, NativeMML (i.e. MathML) and
1207 | # SVG. The default value is HTML-CSS, which is slower, but has the best
1208 | # compatibility.
1209 | 
1210 | MATHJAX_FORMAT         = HTML-CSS
1211 | 
1212 | # When MathJax is enabled you need to specify the location relative to the
1213 | # HTML output directory using the MATHJAX_RELPATH option. The destination
1214 | # directory should contain the MathJax.js script. For instance, if the mathjax
1215 | # directory is located at the same level as the HTML output directory, then
1216 | # MATHJAX_RELPATH should be ../mathjax. The default value points to
1217 | # the MathJax Content Delivery Network so you can quickly see the result without
1218 | # installing MathJax.
1219 | # However, it is strongly recommended to install a local
1220 | # copy of MathJax from http://www.mathjax.org before deployment.
1221 | 
1222 | MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
1223 | 
1224 | # The MATHJAX_EXTENSIONS tag can be used to specify one or MathJax extension
1225 | # names that should be enabled during MathJax rendering.
1226 | 
1227 | MATHJAX_EXTENSIONS     =
1228 | 
1229 | # When the SEARCHENGINE tag is enabled doxygen will generate a search box
1230 | # for the HTML output. The underlying search engine uses javascript
1231 | # and DHTML and should work on any modern browser. Note that when using
1232 | # HTML help (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets
1233 | # (GENERATE_DOCSET) there is already a search function so this one should
1234 | # typically be disabled. For large projects the javascript based search engine
1235 | # can be slow, then enabling SERVER_BASED_SEARCH may provide a better solution.
1236 | 
1237 | SEARCHENGINE           = YES
1238 | 
1239 | # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
1240 | # implemented using a web server instead of a web client using Javascript.
1241 | # There are two flavours of web server based search depending on the
1242 | # EXTERNAL_SEARCH setting. When disabled, doxygen will generate a PHP script for
1243 | # searching and an index file used by the script. When EXTERNAL_SEARCH is
1244 | # enabled the indexing and searching needs to be provided by external tools.
1245 | # See the manual for details.
1246 | 
1247 | SERVER_BASED_SEARCH    = NO
1248 | 
1249 | # When EXTERNAL_SEARCH is enabled doxygen will no longer generate the PHP
1250 | # script for searching. Instead the search results are written to an XML file
1251 | # which needs to be processed by an external indexer. Doxygen will invoke an
1252 | # external search engine pointed to by the SEARCHENGINE_URL option to obtain
1253 | # the search results. Doxygen ships with an example indexer (doxyindexer) and
1254 | # search engine (doxysearch.cgi) which are based on the open source search engine
1255 | # library Xapian. See the manual for configuration details.
1256 | 
1257 | EXTERNAL_SEARCH        = NO
1258 | 
1259 | # The SEARCHENGINE_URL should point to a search engine hosted by a web server
1260 | # which will returned the search results when EXTERNAL_SEARCH is enabled.
1261 | # Doxygen ships with an example search engine (doxysearch) which is based on
1262 | # the open source search engine library Xapian. See the manual for configuration
1263 | # details.
1264 | 
1265 | SEARCHENGINE_URL       =
1266 | 
1267 | # When SERVER_BASED_SEARCH and EXTERNAL_SEARCH are both enabled the unindexed
1268 | # search data is written to a file for indexing by an external tool. With the
1269 | # SEARCHDATA_FILE tag the name of this file can be specified.
1270 | 
1271 | SEARCHDATA_FILE        = searchdata.xml
1272 | 
1273 | # When SERVER_BASED_SEARCH AND EXTERNAL_SEARCH are both enabled the
1274 | # EXTERNAL_SEARCH_ID tag can be used as an identifier for the project. This is
1275 | # useful in combination with EXTRA_SEARCH_MAPPINGS to search through multiple
1276 | # projects and redirect the results back to the right project.
1277 | 
1278 | EXTERNAL_SEARCH_ID     =
1279 | 
1280 | # The EXTRA_SEARCH_MAPPINGS tag can be used to enable searching through doxygen
1281 | # projects other than the one defined by this configuration file, but that are
1282 | # all added to the same external search index. Each project needs to have a
1283 | # unique id set via EXTERNAL_SEARCH_ID. The search mapping then maps the id
1284 | # of to a relative location where the documentation can be found.
1285 | # The format is: EXTRA_SEARCH_MAPPINGS = id1=loc1 id2=loc2 ...
1286 | 
1287 | EXTRA_SEARCH_MAPPINGS  =
1288 | 
1289 | #---------------------------------------------------------------------------
1290 | # configuration options related to the LaTeX output
1291 | #---------------------------------------------------------------------------
1292 | 
1293 | # If the GENERATE_LATEX tag is set to YES (the default) Doxygen will
1294 | # generate Latex output.
1295 | 
1296 | GENERATE_LATEX         = NO
1297 | 
1298 | # The LATEX_OUTPUT tag is used to specify where the LaTeX docs will be put.
1299 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
1300 | # put in front of it. If left blank `latex' will be used as the default path.
1301 | 
1302 | LATEX_OUTPUT           = latex
1303 | 
1304 | # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
1305 | # invoked. If left blank `latex' will be used as the default command name.
1306 | # Note that when enabling USE_PDFLATEX this option is only used for
1307 | # generating bitmaps for formulas in the HTML output, but not in the
1308 | # Makefile that is written to the output directory.
1309 | 
1310 | LATEX_CMD_NAME         = latex
1311 | 
1312 | # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to
1313 | # generate index for LaTeX. If left blank `makeindex' will be used as the
1314 | # default command name.
1315 | 
1316 | MAKEINDEX_CMD_NAME     = makeindex
1317 | 
1318 | # If the COMPACT_LATEX tag is set to YES Doxygen generates more compact
1319 | # LaTeX documents. This may be useful for small projects and may help to
1320 | # save some trees in general.
1321 | 
1322 | COMPACT_LATEX          = NO
1323 | 
1324 | # The PAPER_TYPE tag can be used to set the paper type that is used
1325 | # by the printer. Possible values are: a4, letter, legal and
1326 | # executive. If left blank a4wide will be used.
1327 | 
1328 | PAPER_TYPE             = a4
1329 | 
1330 | # The EXTRA_PACKAGES tag can be to specify one or more names of LaTeX
1331 | # packages that should be included in the LaTeX output.
1332 | 
1333 | EXTRA_PACKAGES         =
1334 | 
1335 | # The LATEX_HEADER tag can be used to specify a personal LaTeX header for
1336 | # the generated latex document. The header should contain everything until
1337 | # the first chapter. If it is left blank doxygen will generate a
1338 | # standard header. Notice: only use this tag if you know what you are doing!
1339 | 
1340 | LATEX_HEADER           =
1341 | 
1342 | # The LATEX_FOOTER tag can be used to specify a personal LaTeX footer for
1343 | # the generated latex document. The footer should contain everything after
1344 | # the last chapter. If it is left blank doxygen will generate a
1345 | # standard footer. Notice: only use this tag if you know what you are doing!
1346 | 
1347 | LATEX_FOOTER           =
1348 | 
1349 | # If the PDF_HYPERLINKS tag is set to YES, the LaTeX that is generated
1350 | # is prepared for conversion to pdf (using ps2pdf). The pdf file will
1351 | # contain links (just like the HTML output) instead of page references
1352 | # This makes the output suitable for online browsing using a pdf viewer.
1353 | 
1354 | PDF_HYPERLINKS         = YES
1355 | 
1356 | # If the USE_PDFLATEX tag is set to YES, pdflatex will be used instead of
1357 | # plain latex in the generated Makefile. Set this option to YES to get a
1358 | # higher quality PDF documentation.
1359 | 
1360 | USE_PDFLATEX           = YES
1361 | 
1362 | # If the LATEX_BATCHMODE tag is set to YES, doxygen will add the \\batchmode.
1363 | # command to the generated LaTeX files. This will instruct LaTeX to keep
1364 | # running if errors occur, instead of asking the user for help.
1365 | # This option is also used when generating formulas in HTML.
1366 | 
1367 | LATEX_BATCHMODE        = NO
1368 | 
1369 | # If LATEX_HIDE_INDICES is set to YES then doxygen will not
1370 | # include the index chapters (such as File Index, Compound Index, etc.)
1371 | # in the output.
1372 | 
1373 | LATEX_HIDE_INDICES     = NO
1374 | 
1375 | # If LATEX_SOURCE_CODE is set to YES then doxygen will include
1376 | # source code with syntax highlighting in the LaTeX output.
1377 | # Note that which sources are shown also depends on other settings
1378 | # such as SOURCE_BROWSER.
1379 | 
1380 | LATEX_SOURCE_CODE      = NO
1381 | 
1382 | # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
1383 | # bibliography, e.g. plainnat, or ieeetr. The default style is "plain". See
1384 | # http://en.wikipedia.org/wiki/BibTeX for more info.
1385 | 
1386 | LATEX_BIB_STYLE        = plain
1387 | 
1388 | #---------------------------------------------------------------------------
1389 | # configuration options related to the RTF output
1390 | #---------------------------------------------------------------------------
1391 | 
1392 | # If the GENERATE_RTF tag is set to YES Doxygen will generate RTF output
1393 | # The RTF output is optimized for Word 97 and may not look very pretty with
1394 | # other RTF readers or editors.
1395 | 
1396 | GENERATE_RTF           = NO
1397 | 
1398 | # The RTF_OUTPUT tag is used to specify where the RTF docs will be put.
1399 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
1400 | # put in front of it. If left blank `rtf' will be used as the default path.
1401 | 
1402 | RTF_OUTPUT             = rtf
1403 | 
1404 | # If the COMPACT_RTF tag is set to YES Doxygen generates more compact
1405 | # RTF documents. This may be useful for small projects and may help to
1406 | # save some trees in general.
1407 | 
1408 | COMPACT_RTF            = NO
1409 | 
1410 | # If the RTF_HYPERLINKS tag is set to YES, the RTF that is generated
1411 | # will contain hyperlink fields. The RTF file will
1412 | # contain links (just like the HTML output) instead of page references.
1413 | # This makes the output suitable for online browsing using WORD or other
1414 | # programs which support those fields.
1415 | # Note: wordpad (write) and others do not support links.
1416 | 
1417 | RTF_HYPERLINKS         = NO
1418 | 
1419 | # Load style sheet definitions from file. Syntax is similar to doxygen's
1420 | # config file, i.e. a series of assignments. You only have to provide
1421 | # replacements, missing definitions are set to their default value.
1422 | 
1423 | RTF_STYLESHEET_FILE    =
1424 | 
1425 | # Set optional variables used in the generation of an rtf document.
1426 | # Syntax is similar to doxygen's config file.
1427 | 
1428 | RTF_EXTENSIONS_FILE    =
1429 | 
1430 | #---------------------------------------------------------------------------
1431 | # configuration options related to the man page output
1432 | #---------------------------------------------------------------------------
1433 | 
1434 | # If the GENERATE_MAN tag is set to YES (the default) Doxygen will
1435 | # generate man pages
1436 | 
1437 | GENERATE_MAN           = NO
1438 | 
1439 | # The MAN_OUTPUT tag is used to specify where the man pages will be put.
1440 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
1441 | # put in front of it. If left blank `man' will be used as the default path.
1442 | 
1443 | MAN_OUTPUT             = man
1444 | 
1445 | # The MAN_EXTENSION tag determines the extension that is added to
1446 | # the generated man pages (default is the subroutine's section .3)
1447 | 
1448 | MAN_EXTENSION          = .3
1449 | 
1450 | # If the MAN_LINKS tag is set to YES and Doxygen generates man output,
1451 | # then it will generate one additional man file for each entity
1452 | # documented in the real man page(s). These additional files
1453 | # only source the real man page, but without them the man command
1454 | # would be unable to find the correct page. The default is NO.
1455 | 
1456 | MAN_LINKS              = NO
1457 | 
1458 | #---------------------------------------------------------------------------
1459 | # configuration options related to the XML output
1460 | #---------------------------------------------------------------------------
1461 | 
1462 | # If the GENERATE_XML tag is set to YES Doxygen will
1463 | # generate an XML file that captures the structure of
1464 | # the code including all documentation.
1465 | 
1466 | GENERATE_XML           = NO
1467 | 
1468 | # The XML_OUTPUT tag is used to specify where the XML pages will be put.
1469 | # If a relative path is entered the value of OUTPUT_DIRECTORY will be
1470 | # put in front of it. If left blank `xml' will be used as the default path.
1471 | 
1472 | XML_OUTPUT             = xml
1473 | 
1474 | # The XML_SCHEMA tag can be used to specify an XML schema,
1475 | # which can be used by a validating XML parser to check the
1476 | # syntax of the XML files.
1477 | 
1478 | XML_SCHEMA             =
1479 | 
1480 | # The XML_DTD tag can be used to specify an XML DTD,
1481 | # which can be used by a validating XML parser to check the
1482 | # syntax of the XML files.
1483 | 
1484 | XML_DTD                =
1485 | 
1486 | # If the XML_PROGRAMLISTING tag is set to YES Doxygen will
1487 | # dump the program listings (including syntax highlighting
1488 | # and cross-referencing information) to the XML output. Note that
1489 | # enabling this will significantly increase the size of the XML output.
1490 | 
1491 | XML_PROGRAMLISTING     = YES
1492 | 
1493 | #---------------------------------------------------------------------------
1494 | # configuration options for the AutoGen Definitions output
1495 | #---------------------------------------------------------------------------
1496 | 
1497 | # If the GENERATE_AUTOGEN_DEF tag is set to YES Doxygen will
1498 | # generate an AutoGen Definitions (see autogen.sf.net) file
1499 | # that captures the structure of the code including all
1500 | # documentation. Note that this feature is still experimental
1501 | # and incomplete at the moment.
1502 | 
1503 | GENERATE_AUTOGEN_DEF   = NO
1504 | 
1505 | #---------------------------------------------------------------------------
1506 | # configuration options related to the Perl module output
1507 | #---------------------------------------------------------------------------
1508 | 
1509 | # If the GENERATE_PERLMOD tag is set to YES Doxygen will
1510 | # generate a Perl module file that captures the structure of
1511 | # the code including all documentation. Note that this
1512 | # feature is still experimental and incomplete at the
1513 | # moment.
1514 | 
1515 | GENERATE_PERLMOD       = NO
1516 | 
1517 | # If the PERLMOD_LATEX tag is set to YES Doxygen will generate
1518 | # the necessary Makefile rules, Perl scripts and LaTeX code to be able
1519 | # to generate PDF and DVI output from the Perl module output.
1520 | 
1521 | PERLMOD_LATEX          = NO
1522 | 
1523 | # If the PERLMOD_PRETTY tag is set to YES the Perl module output will be
1524 | # nicely formatted so it can be parsed by a human reader.
1525 | # This is useful
1526 | # if you want to understand what is going on.
1527 | # On the other hand, if this
1528 | # tag is set to NO the size of the Perl module output will be much smaller
1529 | # and Perl will parse it just the same.
1530 | 
1531 | PERLMOD_PRETTY         = YES
1532 | 
1533 | # The names of the make variables in the generated doxyrules.make file
1534 | # are prefixed with the string contained in PERLMOD_MAKEVAR_PREFIX.
1535 | # This is useful so different doxyrules.make files included by the same
1536 | # Makefile don't overwrite each other's variables.
1537 | 
1538 | PERLMOD_MAKEVAR_PREFIX =
1539 | 
1540 | #---------------------------------------------------------------------------
1541 | # Configuration options related to the preprocessor
1542 | #---------------------------------------------------------------------------
1543 | 
1544 | # If the ENABLE_PREPROCESSING tag is set to YES (the default) Doxygen will
1545 | # evaluate all C-preprocessor directives found in the sources and include
1546 | # files.
1547 | 
1548 | ENABLE_PREPROCESSING   = YES
1549 | 
1550 | # If the MACRO_EXPANSION tag is set to YES Doxygen will expand all macro
1551 | # names in the source code. If set to NO (the default) only conditional
1552 | # compilation will be performed. Macro expansion can be done in a controlled
1553 | # way by setting EXPAND_ONLY_PREDEF to YES.
1554 | 
1555 | MACRO_EXPANSION        = NO
1556 | 
1557 | # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES
1558 | # then the macro expansion is limited to the macros specified with the
1559 | # PREDEFINED and EXPAND_AS_DEFINED tags.
1560 | 
1561 | EXPAND_ONLY_PREDEF     = NO
1562 | 
1563 | # If the SEARCH_INCLUDES tag is set to YES (the default) the includes files
1564 | # pointed to by INCLUDE_PATH will be searched when a #include is found.
1565 | 
1566 | SEARCH_INCLUDES        = YES
1567 | 
1568 | # The INCLUDE_PATH tag can be used to specify one or more directories that
1569 | # contain include files that are not input files but should be processed by
1570 | # the preprocessor.
1571 | 
1572 | INCLUDE_PATH           =
1573 | 
1574 | # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
1575 | # patterns (like *.h and *.hpp) to filter out the header-files in the
1576 | # directories. If left blank, the patterns specified with FILE_PATTERNS will
1577 | # be used.
1578 | 
1579 | INCLUDE_FILE_PATTERNS  =
1580 | 
1581 | # The PREDEFINED tag can be used to specify one or more macro names that
1582 | # are defined before the preprocessor is started (similar to the -D option of
1583 | # gcc). The argument of the tag is a list of macros of the form: name
1584 | # or name=definition (no spaces). If the definition and the = are
1585 | # omitted =1 is assumed. To prevent a macro definition from being
1586 | # undefined via #undef or recursively expanded use the := operator
1587 | # instead of the = operator.
1588 | 
1589 | PREDEFINED             =
1590 | 
1591 | # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then
1592 | # this tag can be used to specify a list of macro names that should be expanded.
1593 | # The macro definition that is found in the sources will be used.
1594 | # Use the PREDEFINED tag if you want to use a different macro definition that
1595 | # overrules the definition found in the source code.
1596 | 
1597 | EXPAND_AS_DEFINED      =
1598 | 
1599 | # If the SKIP_FUNCTION_MACROS tag is set to YES (the default) then
1600 | # doxygen's preprocessor will remove all references to function-like macros
1601 | # that are alone on a line, have an all uppercase name, and do not end with a
1602 | # semicolon, because these will confuse the parser if not removed.
1603 | 
1604 | SKIP_FUNCTION_MACROS   = YES
1605 | 
1606 | #---------------------------------------------------------------------------
1607 | # Configuration::additions related to external references
1608 | #---------------------------------------------------------------------------
1609 | 
1610 | # The TAGFILES option can be used to specify one or more tagfiles. For each
1611 | # tag file the location of the external documentation should be added. The
1612 | # format of a tag file without this location is as follows:
1613 | #
1614 | # TAGFILES = file1 file2 ...
1615 | # Adding location for the tag files is done as follows:
1616 | #
1617 | # TAGFILES = file1=loc1 "file2 = loc2" ...
1618 | # where "loc1" and "loc2" can be relative or absolute paths
1619 | # or URLs. Note that each tag file must have a unique name (where the name does
1620 | # NOT include the path). If a tag file is not located in the directory in which
1621 | # doxygen is run, you must also specify the path to the tagfile here.
1622 | 
1623 | TAGFILES               =
1624 | 
1625 | # When a file name is specified after GENERATE_TAGFILE, doxygen will create
1626 | # a tag file that is based on the input files it reads.
1627 | 
1628 | GENERATE_TAGFILE       =
1629 | 
1630 | # If the ALLEXTERNALS tag is set to YES all external classes will be listed
1631 | # in the class index. If set to NO only the inherited external classes
1632 | # will be listed.
1633 | 
1634 | ALLEXTERNALS           = NO
1635 | 
1636 | # If the EXTERNAL_GROUPS tag is set to YES all external groups will be listed
1637 | # in the modules index. If set to NO, only the current project's groups will
1638 | # be listed.
1639 | 
1640 | EXTERNAL_GROUPS        = YES
1641 | 
1642 | # The PERL_PATH should be the absolute path and name of the perl script
1643 | # interpreter (i.e. the result of `which perl').
1644 | 
1645 | PERL_PATH              = /usr/bin/perl
1646 | 
1647 | #---------------------------------------------------------------------------
1648 | # Configuration options related to the dot tool
1649 | #---------------------------------------------------------------------------
1650 | 
1651 | # If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
1652 | # generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
1653 | # or super classes. Setting the tag to NO turns the diagrams off. Note that
1654 | # this option also works with HAVE_DOT disabled, but it is recommended to
1655 | # install and use dot, since it yields more powerful graphs.
1656 | 
1657 | CLASS_DIAGRAMS         = YES
1658 | 
1659 | # You can define message sequence charts within doxygen comments using the \msc
1660 | # command. Doxygen will then run the mscgen tool (see
1661 | # http://www.mcternan.me.uk/mscgen/) to produce the chart and insert it in the
1662 | # documentation. The MSCGEN_PATH tag allows you to specify the directory where
1663 | # the mscgen tool resides. If left empty the tool is assumed to be found in the
1664 | # default search path.
1665 | 
1666 | MSCGEN_PATH            =
1667 | 
1668 | # If set to YES, the inheritance and collaboration graphs will hide
1669 | # inheritance and usage relations if the target is undocumented
1670 | # or is not a class.
1671 | 
1672 | HIDE_UNDOC_RELATIONS   = YES
1673 | 
1674 | # If you set the HAVE_DOT tag to YES then doxygen will assume the dot tool is
1675 | # available from the path. This tool is part of Graphviz, a graph visualization
1676 | # toolkit from AT&T and Lucent Bell Labs. The other options in this section
1677 | # have no effect if this option is set to NO (the default)
1678 | 
1679 | HAVE_DOT               = NO
1680 | 
1681 | # The DOT_NUM_THREADS specifies the number of dot invocations doxygen is
1682 | # allowed to run in parallel. When set to 0 (the default) doxygen will
1683 | # base this on the number of processors available in the system. You can set it
1684 | # explicitly to a value larger than 0 to get control over the balance
1685 | # between CPU load and processing speed.
1686 | 
1687 | DOT_NUM_THREADS        = 0
1688 | 
1689 | # By default doxygen will use the Helvetica font for all dot files that
1690 | # doxygen generates. When you want a differently looking font you can specify
1691 | # the font name using DOT_FONTNAME. You need to make sure dot is able to find
1692 | # the font, which can be done by putting it in a standard location or by setting
1693 | # the DOTFONTPATH environment variable or by setting DOT_FONTPATH to the
1694 | # directory containing the font.
1695 | 
1696 | DOT_FONTNAME           = Helvetica
1697 | 
1698 | # The DOT_FONTSIZE tag can be used to set the size of the font of dot graphs.
1699 | # The default size is 10pt.
1700 | 
1701 | DOT_FONTSIZE           = 10
1702 | 
1703 | # By default doxygen will tell dot to use the Helvetica font.
1704 | # If you specify a different font using DOT_FONTNAME you can use DOT_FONTPATH to
1705 | # set the path where dot can find it.
1706 | 
1707 | DOT_FONTPATH           =
1708 | 
1709 | # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen
1710 | # will generate a graph for each documented class showing the direct and
1711 | # indirect inheritance relations. Setting this tag to YES will force the
1712 | # CLASS_DIAGRAMS tag to NO.
1713 | 
1714 | CLASS_GRAPH            = YES
1715 | 
1716 | # If the COLLABORATION_GRAPH and HAVE_DOT tags are set to YES then doxygen
1717 | # will generate a graph for each documented class showing the direct and
1718 | # indirect implementation dependencies (inheritance, containment, and
1719 | # class references variables) of the class with other documented classes.
1720 | 
1721 | COLLABORATION_GRAPH    = YES
1722 | 
1723 | # If the GROUP_GRAPHS and HAVE_DOT tags are set to YES then doxygen
1724 | # will generate a graph for groups, showing the direct groups dependencies
1725 | 
1726 | GROUP_GRAPHS           = YES
1727 | 
1728 | # If the UML_LOOK tag is set to YES doxygen will generate inheritance and
1729 | # collaboration diagrams in a style similar to the OMG's Unified Modeling
1730 | # Language.
1731 | 
1732 | UML_LOOK               = NO
1733 | 
1734 | # If the UML_LOOK tag is enabled, the fields and methods are shown inside
1735 | # the class node. If there are many fields or methods and many nodes the
1736 | # graph may become too big to be useful. The UML_LIMIT_NUM_FIELDS
1737 | # threshold limits the number of items for each type to make the size more
1738 | # managable. Set this to 0 for no limit. Note that the threshold may be
1739 | # exceeded by 50% before the limit is enforced.
1740 | 
1741 | UML_LIMIT_NUM_FIELDS   = 10
1742 | 
1743 | # If set to YES, the inheritance and collaboration graphs will show the
1744 | # relations between templates and their instances.
1745 | 
1746 | TEMPLATE_RELATIONS     = NO
1747 | 
1748 | # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDE_GRAPH, and HAVE_DOT
1749 | # tags are set to YES then doxygen will generate a graph for each documented
1750 | # file showing the direct and indirect include dependencies of the file with
1751 | # other documented files.
1752 | 
1753 | INCLUDE_GRAPH          = YES
1754 | 
1755 | # If the ENABLE_PREPROCESSING, SEARCH_INCLUDES, INCLUDED_BY_GRAPH, and
1756 | # HAVE_DOT tags are set to YES then doxygen will generate a graph for each
1757 | # documented header file showing the documented files that directly or
1758 | # indirectly include this file.
1759 | 
1760 | INCLUDED_BY_GRAPH      = YES
1761 | 
1762 | # If the CALL_GRAPH and HAVE_DOT options are set to YES then
1763 | # doxygen will generate a call dependency graph for every global function
1764 | # or class method. Note that enabling this option will significantly increase
1765 | # the time of a run. So in most cases it will be better to enable call graphs
1766 | # for selected functions only using the \callgraph command.
1767 | 
1768 | CALL_GRAPH             = NO
1769 | 
1770 | # If the CALLER_GRAPH and HAVE_DOT tags are set to YES then
1771 | # doxygen will generate a caller dependency graph for every global function
1772 | # or class method. Note that enabling this option will significantly increase
1773 | # the time of a run. So in most cases it will be better to enable caller
1774 | # graphs for selected functions only using the \callergraph command.
1775 | 
1776 | CALLER_GRAPH           = NO
1777 | 
1778 | # If the GRAPHICAL_HIERARCHY and HAVE_DOT tags are set to YES then doxygen
1779 | # will generate a graphical hierarchy of all classes instead of a textual one.
1780 | 
1781 | GRAPHICAL_HIERARCHY    = YES
1782 | 
1783 | # If the DIRECTORY_GRAPH and HAVE_DOT tags are set to YES
1784 | # then doxygen will show the dependencies a directory has on other directories
1785 | # in a graphical way. The dependency relations are determined by the #include
1786 | # relations between the files in the directories.
1787 | 
1788 | DIRECTORY_GRAPH        = YES
1789 | 
1790 | # The DOT_IMAGE_FORMAT tag can be used to set the image format of the images
1791 | # generated by dot. Possible values are svg, png, jpg, or gif.
1792 | # If left blank png will be used. If you choose svg you need to set
1793 | # HTML_FILE_EXTENSION to xhtml in order to make the SVG files
1794 | # visible in IE 9+ (other browsers do not have this requirement).
1795 | 
1796 | DOT_IMAGE_FORMAT       = png
1797 | 
1798 | # If DOT_IMAGE_FORMAT is set to svg, then this option can be set to YES to
1799 | # enable generation of interactive SVG images that allow zooming and panning.
1800 | # Note that this requires a modern browser other than Internet Explorer.
1801 | # Tested and working are Firefox, Chrome, Safari, and Opera. For IE 9+ you
1802 | # need to set HTML_FILE_EXTENSION to xhtml in order to make the SVG files
1803 | # visible. Older versions of IE do not have SVG support.
1804 | 
1805 | INTERACTIVE_SVG        = NO
1806 | 
1807 | # The tag DOT_PATH can be used to specify the path where the dot tool can be
1808 | # found. If left blank, it is assumed the dot tool can be found in the path.
1809 | 
1810 | DOT_PATH               =
1811 | 
1812 | # The DOTFILE_DIRS tag can be used to specify one or more directories that
1813 | # contain dot files that are included in the documentation (see the
1814 | # \dotfile command).
1815 | 
1816 | DOTFILE_DIRS           =
1817 | 
1818 | # The MSCFILE_DIRS tag can be used to specify one or more directories that
1819 | # contain msc files that are included in the documentation (see the
1820 | # \mscfile command).
1821 | 
1822 | MSCFILE_DIRS           =
1823 | 
1824 | # The DOT_GRAPH_MAX_NODES tag can be used to set the maximum number of
1825 | # nodes that will be shown in the graph. If the number of nodes in a graph
1826 | # becomes larger than this value, doxygen will truncate the graph, which is
1827 | # visualized by representing a node as a red box. Note that doxygen if the
1828 | # number of direct children of the root node in a graph is already larger than
1829 | # DOT_GRAPH_MAX_NODES then the graph will not be shown at all. Also note
1830 | # that the size of a graph can be further restricted by MAX_DOT_GRAPH_DEPTH.
1831 | 
1832 | DOT_GRAPH_MAX_NODES    = 50
1833 | 
1834 | # The MAX_DOT_GRAPH_DEPTH tag can be used to set the maximum depth of the
1835 | # graphs generated by dot. A depth value of 3 means that only nodes reachable
1836 | # from the root by following a path via at most 3 edges will be shown. Nodes
1837 | # that lay further from the root node will be omitted. Note that setting this
1838 | # option to 1 or 2 may greatly reduce the computation time needed for large
1839 | # code bases. Also note that the size of a graph can be further restricted by
1840 | # DOT_GRAPH_MAX_NODES. Using a depth of 0 means no depth restriction.
1841 | 
1842 | MAX_DOT_GRAPH_DEPTH    = 0
1843 | 
1844 | # Set the DOT_TRANSPARENT tag to YES to generate images with a transparent
1845 | # background. This is disabled by default, because dot on Windows does not
1846 | # seem to support this out of the box. Warning: Depending on the platform used,
1847 | # enabling this option may lead to badly anti-aliased labels on the edges of
1848 | # a graph (i.e. they become hard to read).
1849 | 
1850 | DOT_TRANSPARENT        = NO
1851 | 
1852 | # Set the DOT_MULTI_TARGETS tag to YES allow dot to generate multiple output
1853 | # files in one run (i.e. multiple -o and -T options on the command line). This
1854 | # makes dot run faster, but since only newer versions of dot (>1.8.10)
1855 | # support this, this feature is disabled by default.
1856 | 
1857 | DOT_MULTI_TARGETS      = NO
1858 | 
1859 | # If the GENERATE_LEGEND tag is set to YES (the default) Doxygen will
1860 | # generate a legend page explaining the meaning of the various boxes and
1861 | # arrows in the dot generated graphs.
1862 | 
1863 | GENERATE_LEGEND        = YES
1864 | 
1865 | # If the DOT_CLEANUP tag is set to YES (the default) Doxygen will
1866 | # remove the intermediate dot files that are used to generate
1867 | # the various graphs.
1868 | 
1869 | DOT_CLEANUP            = YES
1870 | 


--------------------------------------------------------------------------------