├── version.py ├── deploy.sh ├── setup.py ├── test ├── speed_test.py ├── test.py └── leaky_test.py ├── post_process.py ├── generate_swig.py ├── README.md └── supported_containers.md /version.py: -------------------------------------------------------------------------------- 1 | __version__ = "0.0.5" 2 | -------------------------------------------------------------------------------- /deploy.sh: -------------------------------------------------------------------------------- 1 | rm -rf dist 2 | rm -rf build 3 | rm -rf *.egg-info 4 | cp version.py cstl/ 5 | python setup.py sdist bdist_wheel 6 | twine upload dist/* -------------------------------------------------------------------------------- /setup.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | from setuptools import setup, find_packages 3 | 4 | from pathlib import Path 5 | this_directory = Path(__file__).parent 6 | long_description = (this_directory / "README.md").read_text() 7 | from cstl.version import __version__ 8 | 9 | setup( 10 | name='cstl', 11 | version=__version__, 12 | description='The C++ Standard Template Library (STL) for Python', 13 | url='https://github.com/fuzihaofzh/cstl', 14 | author='', 15 | author_email='', 16 | license='', 17 | classifiers=[ 18 | 'Programming Language :: Python :: 3.8', 19 | ], 20 | keywords='C++ STL List Dict Set', 21 | packages = find_packages(), 22 | package_data={'': ['_cstl.so']}, 23 | long_description=long_description, 24 | long_description_content_type='text/markdown', 25 | include_package_data=True 26 | ) 27 | -------------------------------------------------------------------------------- /test/speed_test.py: -------------------------------------------------------------------------------- 1 | import cstl 2 | import time 3 | import numpy as np 4 | from collections import defaultdict 5 | import pandas as pd 6 | import torch 7 | 8 | total = 1000000 9 | 10 | def rand_access_test(lst, func, name): 11 | st = time.time() 12 | for i in range(len(lst) - 100): 13 | func(lst, i, name) 14 | if time.time() - st > 10: 15 | break 16 | return round(time.time() - st, 3) 17 | 18 | 19 | data = { 20 | "python" : list(range(total)), 21 | "numpy" : np.array(range(total)), 22 | "cstl" : cstl.VecInt(range(total)), 23 | "pytorch" : torch.tensor(range(total)) 24 | } 25 | 26 | print("rand_access_test") 27 | res = defaultdict(dict) 28 | def add1(lst, i, name): 29 | lst[i] += 1 30 | def read(lst, i, name): 31 | a = lst[i] 32 | def sliceread(lst, i, name): 33 | a = lst[i : i + 100] 34 | def append(lst, i, name): 35 | if name == "numpy": 36 | np.append(lst, i) 37 | elif name == "python": 38 | lst.append(i) 39 | elif name == "pytorch": 40 | lst = torch.cat([lst, torch.tensor(1).unsqueeze(0)]) 41 | else: 42 | lst.push_back(i) 43 | def pop(lst, i, name): 44 | if name == "cstl": 45 | lst.pop() 46 | elif name == "python": 47 | lst.pop(0) 48 | else: 49 | np.delete(lst, i) 50 | 51 | 52 | for func in [add1, read, sliceread, append, pop]: 53 | for l in ["python", "numpy", "cstl", "pytorch"]: 54 | print(func.__name__, l) 55 | res[l][func.__name__] = rand_access_test(data[l], func, l) 56 | 57 | df = pd.DataFrame(res) 58 | print(df.to_markdown()) 59 | -------------------------------------------------------------------------------- /test/test.py: -------------------------------------------------------------------------------- 1 | import sys 2 | sys.path.append("cstl") 3 | import cstl 4 | import unittest 5 | 6 | 7 | class TestAddNumbers(unittest.TestCase): 8 | def test_tofrom(self): 9 | vss = [ 10 | [{1:4, 5:6}, {3:5, 7:8, 10:3}], 11 | {1:2, 3:4, 5:6}, 12 | {1, 2, 3, 4}, 13 | set([1,2,3,4]), 14 | {1:[3,4,5], 3:[5,4,2], 5:[3,3,5]}, 15 | {1:set([3,4,5]), 3:set([5,4,2]), 5:set([3,3,5])}, 16 | ] 17 | for vs in vss: 18 | cv = cstl.frompy(vs) 19 | v1 = cstl.topy(cv) 20 | self.assertEqual(vs, v1) 21 | 22 | def test_vecint(self): 23 | # create a vector of integers 24 | vec_int = cstl.VecInt() 25 | vec_int.push_back(1) 26 | vec_int.push_back(2) 27 | vec_int.push_back(3) 28 | self.assertEqual(vec_int[1], 2) 29 | self.assertEqual(cstl.topy(vec_int), [1,2,3]) 30 | 31 | def test_vecstr(self): 32 | # create a vector of strings 33 | vec_str = cstl.VecStr() 34 | vec_str.push_back('hello') 35 | vec_str.push_back('world') 36 | self.assertEqual(cstl.topy(vec_str), ['hello', 'world']) 37 | 38 | def test_vecstr(self): 39 | # create a map from string to int 40 | map_str_int = cstl.MapStrInt() 41 | map_str_int['one'] = 1 42 | map_str_int['two'] = 2 43 | map_str_int['three'] = 3 44 | self.assertEqual(cstl.topy(map_str_int), {'one' : 1, 'two' : 2, 'three' : 3}) 45 | 46 | def test_compose(self): 47 | cmsi = cstl.MapStrVecInt() 48 | v1 = cstl.VecInt([1,2,3]) 49 | v2 = cstl.VecInt([1,5,3]) 50 | v3 = cstl.VecInt([1,6,3]) 51 | cmsi['v1'] = v1 52 | cmsi['v2'] = v2 53 | cmsi['v3'] = v3 54 | self.assertEqual(cstl.topy(cmsi), {'v3': [1, 6, 3], 'v2': [1, 5, 3], 'v1': [1, 2, 3]}) 55 | 56 | def test_return_ref(self): 57 | a = cstl.frompy([[1,2,3], [4,5,6]]) 58 | b1 = a[0] 59 | b2 = a[0] 60 | b1[1] = 10 61 | self.assertEqual(b2[1], 10) 62 | 63 | 64 | unittest.main() -------------------------------------------------------------------------------- /post_process.py: -------------------------------------------------------------------------------- 1 | mywrapper = """ 2 | #====Wrapper==== 3 | import sys 4 | 5 | def _get_type(pyobj): 6 | container_map = {"list" : "Vec", "dict" : "Map", "set" : "Set"} 7 | type_map = {'int': 'Int', 'str': 'Str', 'float': 'Float', 'double': 'Double', 'bool': 'Bool', 'std::int64_t': 'Long'} 8 | stype = type(pyobj).__name__ 9 | if stype not in container_map: 10 | return type_map[stype] 11 | if len(pyobj) == 0: 12 | raise AttributeError(f"Contain Empty {stype} and cannot infer the Type. Please give a non empty list or direct use the specific class to define the object.") 13 | if stype == "list": 14 | return container_map[stype] + _get_type(pyobj[0]) 15 | elif stype == "dict": 16 | k0 = list(pyobj.keys())[0] 17 | return container_map[stype] + _get_type(k0) + _get_type(pyobj[k0]) 18 | elif stype == "set": 19 | v0 = list(pyobj)[0] 20 | return container_map[stype] + _get_type(v0) 21 | 22 | def _convert_set(pyobj): 23 | container_map = {"list" : "Vec", "dict" : "Map", "set" : "Set"} 24 | stype = type(pyobj).__name__ 25 | if len(pyobj) == 0: 26 | raise AttributeError(f"Contain Empty {stype} and cannot infer the Type. Please give a non empty list or direct use the specific class to define the object.") 27 | if stype == "list": 28 | if type(pyobj[0]).__name__ in container_map: 29 | return [_convert_set(c) for c in pyobj] 30 | else: 31 | return pyobj 32 | elif stype == "dict": 33 | v0 = list(pyobj.values())[0] 34 | if type(v0).__name__ in container_map: 35 | return {c : _convert_set(pyobj[c]) for c in pyobj} 36 | else: 37 | return pyobj 38 | elif stype == "set": 39 | return list(pyobj) 40 | else: 41 | raise AttributeError(f"Not handle {stype}") 42 | 43 | def frompy(pyobj): 44 | if type(pyobj) not in [list, set, dict]: 45 | raise AttributeError("You should give a container within list, set, or dict.") 46 | class_name = _get_type(pyobj) 47 | class_obj = getattr(sys.modules[__name__], class_name) 48 | my_obj = class_obj(_convert_set(pyobj)) 49 | return my_obj 50 | 51 | def topy(cstlobj): 52 | stype = type(cstlobj).__name__ 53 | if stype.startswith("Vec"): 54 | obj = list(cstlobj) 55 | if len(obj) > 0 and "cstl" in type(obj[0]).__module__: 56 | obj = [topy(o) for o in obj] 57 | elif stype.startswith("Map"): 58 | obj = dict(cstlobj) 59 | if len(obj) > 0 and "cstl" in type(list(obj.values())[0]).__module__: 60 | obj = {o : topy(obj[o]) for o in obj} 61 | elif stype.startswith("Set"): 62 | obj = set(cstlobj) 63 | else: 64 | raise AttributeError(f"Fail to find the match type for '{cstlobj}' with type {stype}.") 65 | return obj 66 | 67 | """ 68 | 69 | open("cstl/cstl.py", "a").write(mywrapper) -------------------------------------------------------------------------------- /test/leaky_test.py: -------------------------------------------------------------------------------- 1 | from torch.utils.data import Dataset, DataLoader 2 | import numpy as np 3 | import torch 4 | import copy 5 | from collections import OrderedDict 6 | import gc 7 | from multiprocessing import Manager 8 | import sys 9 | import cstl 10 | from tqdm.auto import tqdm 11 | 12 | class MyDict(object): 13 | def __init__(self, d = {}): 14 | self.cnt = 0 15 | if type(d) is dict: 16 | for key in d: 17 | setattr(self, self._convert_key(key), d[key]) 18 | self.cnt += 1 19 | elif type(d) is set: 20 | for key in d: 21 | setattr(self, self._convert_key(key), None) 22 | self.cnt += 1 23 | elif type(d) is list: 24 | for key in range(len(d)): 25 | setattr(self, self._convert_key(key), d[key]) 26 | self.cnt += 1 27 | 28 | def __getitem__(self, key): 29 | return getattr(self, self._convert_key(key)) 30 | 31 | def __setitem__(self, key, value): 32 | if not hasattr(self, self._convert_key(key)): 33 | self.cnt += 1 34 | setattr(self, self._convert_key(key), value) 35 | 36 | def __contains__(self, key): 37 | return hasattr(self, self._convert_key(key)) 38 | 39 | def __len__(self): 40 | return self.cnt 41 | 42 | def _convert_key(self, key): 43 | if type(key) is str: 44 | return "str" + key 45 | else: 46 | return "int" + str(key) 47 | 48 | 49 | class DataIter(Dataset): 50 | def __init__(self): 51 | cnt = 24000000 52 | self.cnt = cnt 53 | #self.data = np.array([x for x in range(cnt)]) # Good 54 | self.data = [x for x in range(cnt)] #Leaky 55 | #self.data = "1" * cnt # Good 56 | #self.data = {x : x for x in range(cnt)} # Leaky 57 | #self.data = OrderedDict({x : x for x in range(cnt)}) # Leaky 58 | #self.data = MyDict({x : x for x in range(cnt)}) # Leaky?? 59 | #self.data = np.array([{x : x for x in range(cnt)}]) # Leaky 60 | #self.data = {"1": np.array([x for x in range(cnt)])}# Good 61 | #self.data = tuple([x for x in range(cnt)])# Leaky 62 | #self.data = Manager().list([x for x in range(cnt)])# too slow 63 | #self.data = np.array([str(x) for x in range(cnt)]).astype(np.string_)# Good, save memory than directly save var in numpy 64 | #self.data = Foo(5) 65 | #self.data = cmap.IntMap() 66 | #for i in range(24000000): 67 | # self.data.set(i, i) 68 | self.data = cstl.VecInt(range(24000000)) # Good 69 | self.data = cstl.MapIntInt({i : i for i in range(24000000)}) 70 | 71 | def __len__(self): 72 | #return len(self.data.item()) 73 | return self.cnt 74 | 75 | def __getitem__(self, idx): 76 | """ 77 | if not hasattr(self, "ddata"): # Good 78 | self.ddata = copy.deepcopy(set(self.data)) 79 | #del self.data 80 | gc.collect()#""" 81 | data = self.data[idx] 82 | data = np.array([int(data)], dtype=np.int64) 83 | return torch.tensor(data) 84 | 85 | 86 | train_data = DataIter() 87 | train_loader = DataLoader(train_data, batch_size=300, 88 | shuffle=True, 89 | drop_last=True, 90 | pin_memory=False, 91 | num_workers=18) 92 | 93 | for i, item in tqdm(enumerate(train_loader)): 94 | torch.cuda.empty_cache() 95 | if i % 1000 == 0: 96 | print(i) -------------------------------------------------------------------------------- /generate_swig.py: -------------------------------------------------------------------------------- 1 | import os 2 | ktypes = {"Int" : "int", "Str" : "std::string", "Long" : "std::int64_t"} 3 | bvtypes = {"Int" : {"cname" : "int"}, "Str" : {"cname" : "std::string"}, "Float" : {"cname" : "float"}, "Double" : {"cname" : "double"}, "Bool" : {"cname" : "bool"} , "Long" : {"cname" : "std::int64_t"}} 4 | 5 | header = """%module cstl 6 | 7 | %{ 8 | //define this to avoid automatically convert std::vector to python list. User should do it manually when needed. 9 | # define SWIG_PYTHON_EXTRA_NATIVE_CONTAINERS 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | %} 16 | 17 | %include "std_vector.i" 18 | %include "std_string.i" 19 | %include "std_unordered_map.i" 20 | %include "std_pair.i" 21 | %include "std_unordered_set.i" 22 | 23 | """ 24 | 25 | 26 | def make_vec(types): 27 | res = {} 28 | for t in types: 29 | conversion = f"$result = swig::from(static_cast< std::vector<{types[t]['cname']},std::allocator< {types[t]['cname']} > >* >($1));" 30 | res["Vec" + t] = {"cname" : f"std::vector<{types[t]['cname']}> ", "typemap" : f"%typemap(out) std::vector<{types[t]['cname']} >::value_type & {{\n {types[t]['conversion']}\n}}" if 'conversion' in types[t] else "", "conversion" : conversion} 31 | return res 32 | 33 | def make_map(keys, vtypes): 34 | res = {} 35 | for key in keys: 36 | for t in vtypes: 37 | conversion = f"resultobj = swig::from(static_cast< std::unordered_map< {keys[key]}, {vtypes[t]['cname']},std::hash< {keys[key]} >,std::equal_to< {keys[key]} >,std::allocator< std::pair< {keys[key]} const,{vtypes[t]['cname']} > > > * >(result));" 38 | res["Map" + key + t] = {"cname" : f"std::unordered_map<{keys[key]}, {vtypes[t]['cname']}> ", "typemap" : f"%typemap(out) std::unordered_map<{keys[key]}, {vtypes[t]['cname']} >::mapped_type & {{\n {vtypes[t]['conversion']}\n}}" if "conversion" in vtypes[t] else "", "conversion" : conversion} 39 | return res 40 | 41 | def make_set(types): 42 | res = {} 43 | for t in types: 44 | conversion = f"$result = swig::from(static_cast< std::unordered_set< {types[t]},std::hash< {types[t]} >,std::equal_to< {types[t]} >,std::allocator< {types[t]} > > * >(result));" 45 | res["Set" + t] = {"cname" : f"std::unordered_set<{types[t]}> ", "typemap" : "", "conversion" : conversion} 46 | return res 47 | 48 | def render(tmap): 49 | return [f"{tmap[t]['typemap']}\n%template({t}) {tmap[t]['cname']};\n" for t in tmap] 50 | 51 | first = {} 52 | first.update(make_vec(bvtypes)) 53 | first.update(make_set(ktypes)) 54 | first.update(make_map(ktypes, bvtypes)) 55 | 56 | second = {} 57 | second.update(make_vec(first)) 58 | second.update(make_map(ktypes, first)) 59 | 60 | third = {} 61 | third.update(make_vec(second)) 62 | third.update(make_map(ktypes, second)) 63 | 64 | fourth = {} 65 | fourth.update(make_vec(third)) 66 | fourth.update(make_map(ktypes, third)) 67 | 68 | full = {} 69 | full.update(first) 70 | full.update(second) 71 | full.update(third) 72 | #full.update(fourth) 73 | 74 | os.system("mkdir cstl -p") 75 | content = header + "\n".join(render(full)) 76 | open("cstl/cstl.i", "w").write(content) 77 | 78 | 79 | open("cstl/cstl.i", "w").write(content) 80 | open("cstl/__init__.py", "w").write("from cstl.version import __version__\nfrom cstl.cstl import *") 81 | os.system("cp version.py cstl/version.py") 82 | 83 | 84 | 85 | 86 | supported_containers_header = """ 87 | |cstl name|C++ class| 88 | |---|---| 89 | """ 90 | md = [] 91 | for f in full: 92 | md.append(f"| {f} | `{full[f]['cname']}` |") 93 | open("supported_containers.md", "w").write(supported_containers_header + "\n".join(md)) 94 | 95 | 96 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # CSTL : The C++ Standard Template Library (STL) for Python 2 | 3 | In this `cstl` tool, we wrap several C++ STL containers (`std::vector`, `std::unordered_map`, and `std::unordered_set`) to replace the corresponding structures (`list`, `dict`, and `set`) in Python. The containers use native C++ implementation and does not have the [Copy-on-Write issue](#copy-on-Write-issue-in-python) like native `list`, and `dict` in Python (Someone refers to it as memory leakage in multiprocessing which always happens in all Python native objects with ref count). Though it is designed to solve the CoW issue, it can also be used in scenarios where a standard C++ container is needed. Get more details of the motivation with this article: [Harnessing the Power of C++ STL in Python with CSTL](http://localhost:4000/blog/2023/04/03/Harnessing-the-Power-of-C-STL-in-Python-with-CSTL/) 4 | 5 | ## Install 6 | Install from `pip`: 7 | ``` 8 | pip install cstl 9 | ``` 10 | Build from source: 11 | ``` 12 | conda install swig # You should first install swig 13 | git clone https://github.com/fuzihaofzh/cstl.git 14 | cd cstl 15 | ./build.sh 16 | python setup.py install --single-version-externally-managed --record files.txt 17 | ``` 18 | 19 | For users on windows or MacOS. Please compile from the source. 20 | 21 | ## Usage 22 | ```python 23 | import cstl 24 | 25 | # Directly covert containers from python 26 | v = cstl.frompy({"1":[1,2,3], "2":[4,5,6]}) # convert python object to cstl object 27 | v["1"][2] = 10 # access cstl object 28 | pv = cstl.topy(v) # convert cstl object to python object 29 | print(pv) 30 | 31 | # You can also explictly specify the type 32 | vec = cstl.VecInt([1,2,3,4,5,6,7]) 33 | print(vec[2]) #3 34 | 35 | vec[2] = 1 36 | print(vec[2]) #1 37 | 38 | vec.append(10) 39 | print(vec[-1]) #10 40 | 41 | # User should explictly convert std::vector into list as follows: 42 | print(list(vec)) #[1, 2, 1, 4, 5, 6, 7, 10] 43 | 44 | vmif = cstl.VecMapIntFloat([{1:3.4},{4:5.5}]) 45 | print(vmif[0][1]) #3.4000000953674316 46 | ``` 47 | 48 | Please refer to more usage in `test/test.py`. 49 | 50 | ## Supported Datatype 51 | 52 | We support the following data types as the elements in the containers 53 | |Python Type|C++ Type| Can be dict key| 54 | |---|---|---| 55 | |int|int|Yes| 56 | |int|std::int64|Yes| 57 | |str|std::string|Yes| 58 | |float|float|No| 59 | |double|double|No| 60 | |bool|bool|No| 61 | 62 | ## Supported Containers 63 | The supported containers are listed as follows 64 | |Python Structure|C++ Container| 65 | |---|---| 66 | |list|std::vector| 67 | |dict|std::unordered_map| 68 | |set|std::unordered_set| 69 | 70 | 71 | We also support nested container, namely, structure like `std::unordered_map< std::string,std::vector< bool > > ` is supported. Currently, at most 3 nested layers are supported. If you want to support more layers, simply uncomment the line `full.update(fourth)` in `generate_swig.py` and compile from the source. But please note the the generated files could be very large. We suggest modifying the generated `cstl/cstl.i` file to only keep the containers you will use and compile the lib manually. 72 | 73 | Please be noted that if you want to pass a Python set to set in `cstl`, you should first convert it into a list. This is a [known issue](https://stackoverflow.com/questions/73900661/using-swig-python-wrapper-argument-2-of-type-stdunordered-set-stdstring) for swig, let's see whether it will be resolved soon. 74 | 75 | ## Speed Comparison 76 | 77 | | | python | numpy | cstl | pytorch | 78 | |:----------|---------:|--------:|-------:|----------:| 79 | | add1 | 0.19 | 0.28 | 0.911 | 4.714 | 80 | | read | 0.161 | 0.2 | 0.526 | 1.033 | 81 | | sliceread | 0.327 | 0.264 | 0.683 | 1.381 | 82 | | append | 0.204 | >10 | 0.351 | >10 | 83 | | pop | >10 | >10 | 0.595 | >10 | 84 | 85 | It can be concluded from the table that cstl is slower than python native list and numpy in basic tasks. However, it is faster in some specific task. Most importantly, it sovles the CoW issue and provide more data structures than numpy. 86 | 87 | ## Copy-on-Write Issue in Python 88 | [Copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write) is a feature and not a bug for Python. Usually, in python multiprocessing, if we have a large data shared by each process, we will see as the program runs, the engaged memory grows gradually and finally occupy all the machine's memory and raise a Memory Error. Someone refers to it as memory leaky in the multiprocess. However, this is caused by a feature of Python. It is because, in multi-processing programs, the shared object will be copied to each process if they access the data. However, if the data is large and we use several processes, the memory cannot hold a separate copy for each process. This cannot be solved in Python as all Python's native structures with ref count have such problems (feature?). A more detailed discussion can be found at https://github.com/pytorch/pytorch/issues/13246 . Many other containers like pytorch, numpy. However, they do not support data structure like nested map. 89 | 90 | 91 | 92 | ## Supported STL Containers List 93 | We support the following nested containers. If you need more than 3 layers of nested containers please refer to [Supported Containers](#supported-containers) 94 | 95 | See [All Supported Containers](./supported_containers.md) for details of other containers. 96 | 97 | 98 | 99 | ## Reference 100 | [1] [Harnessing the Power of C++ STL in Python with CSTL](http://localhost:4000/blog/2023/04/03/Harnessing-the-Power-of-C-STL-in-Python-with-CSTL/) 101 | 102 | -------------------------------------------------------------------------------- /supported_containers.md: -------------------------------------------------------------------------------- 1 | 2 | |cstl name|C++ class| 3 | |---|---| 4 | | VecInt | `std::vector ` | 5 | | VecStr | `std::vector ` | 6 | | VecFloat | `std::vector ` | 7 | | VecDouble | `std::vector ` | 8 | | VecBool | `std::vector ` | 9 | | VecLong | `std::vector ` | 10 | | SetInt | `std::unordered_set ` | 11 | | SetStr | `std::unordered_set ` | 12 | | SetLong | `std::unordered_set ` | 13 | | MapIntInt | `std::unordered_map ` | 14 | | MapIntStr | `std::unordered_map ` | 15 | | MapIntFloat | `std::unordered_map ` | 16 | | MapIntDouble | `std::unordered_map ` | 17 | | MapIntBool | `std::unordered_map ` | 18 | | MapIntLong | `std::unordered_map ` | 19 | | MapStrInt | `std::unordered_map ` | 20 | | MapStrStr | `std::unordered_map ` | 21 | | MapStrFloat | `std::unordered_map ` | 22 | | MapStrDouble | `std::unordered_map ` | 23 | | MapStrBool | `std::unordered_map ` | 24 | | MapStrLong | `std::unordered_map ` | 25 | | MapLongInt | `std::unordered_map ` | 26 | | MapLongStr | `std::unordered_map ` | 27 | | MapLongFloat | `std::unordered_map ` | 28 | | MapLongDouble | `std::unordered_map ` | 29 | | MapLongBool | `std::unordered_map ` | 30 | | MapLongLong | `std::unordered_map ` | 31 | | VecVecInt | `std::vector > ` | 32 | | VecVecStr | `std::vector > ` | 33 | | VecVecFloat | `std::vector > ` | 34 | | VecVecDouble | `std::vector > ` | 35 | | VecVecBool | `std::vector > ` | 36 | | VecVecLong | `std::vector > ` | 37 | | VecSetInt | `std::vector > ` | 38 | | VecSetStr | `std::vector > ` | 39 | | VecSetLong | `std::vector > ` | 40 | | VecMapIntInt | `std::vector > ` | 41 | | VecMapIntStr | `std::vector > ` | 42 | | VecMapIntFloat | `std::vector > ` | 43 | | VecMapIntDouble | `std::vector > ` | 44 | | VecMapIntBool | `std::vector > ` | 45 | | VecMapIntLong | `std::vector > ` | 46 | | VecMapStrInt | `std::vector > ` | 47 | | VecMapStrStr | `std::vector > ` | 48 | | VecMapStrFloat | `std::vector > ` | 49 | | VecMapStrDouble | `std::vector > ` | 50 | | VecMapStrBool | `std::vector > ` | 51 | | VecMapStrLong | `std::vector > ` | 52 | | VecMapLongInt | `std::vector > ` | 53 | | VecMapLongStr | `std::vector > ` | 54 | | VecMapLongFloat | `std::vector > ` | 55 | | VecMapLongDouble | `std::vector > ` | 56 | | VecMapLongBool | `std::vector > ` | 57 | | VecMapLongLong | `std::vector > ` | 58 | | MapIntVecInt | `std::unordered_map > ` | 59 | | MapIntVecStr | `std::unordered_map > ` | 60 | | MapIntVecFloat | `std::unordered_map > ` | 61 | | MapIntVecDouble | `std::unordered_map > ` | 62 | | MapIntVecBool | `std::unordered_map > ` | 63 | | MapIntVecLong | `std::unordered_map > ` | 64 | | MapIntSetInt | `std::unordered_map > ` | 65 | | MapIntSetStr | `std::unordered_map > ` | 66 | | MapIntSetLong | `std::unordered_map > ` | 67 | | MapIntMapIntInt | `std::unordered_map > ` | 68 | | MapIntMapIntStr | `std::unordered_map > ` | 69 | | MapIntMapIntFloat | `std::unordered_map > ` | 70 | | MapIntMapIntDouble | `std::unordered_map > ` | 71 | | MapIntMapIntBool | `std::unordered_map > ` | 72 | | MapIntMapIntLong | `std::unordered_map > ` | 73 | | MapIntMapStrInt | `std::unordered_map > ` | 74 | | MapIntMapStrStr | `std::unordered_map > ` | 75 | | MapIntMapStrFloat | `std::unordered_map > ` | 76 | | MapIntMapStrDouble | `std::unordered_map > ` | 77 | | MapIntMapStrBool | `std::unordered_map > ` | 78 | | MapIntMapStrLong | `std::unordered_map > ` | 79 | | MapIntMapLongInt | `std::unordered_map > ` | 80 | | MapIntMapLongStr | `std::unordered_map > ` | 81 | | MapIntMapLongFloat | `std::unordered_map > ` | 82 | | MapIntMapLongDouble | `std::unordered_map > ` | 83 | | MapIntMapLongBool | `std::unordered_map > ` | 84 | | MapIntMapLongLong | `std::unordered_map > ` | 85 | | MapStrVecInt | `std::unordered_map > ` | 86 | | MapStrVecStr | `std::unordered_map > ` | 87 | | MapStrVecFloat | `std::unordered_map > ` | 88 | | MapStrVecDouble | `std::unordered_map > ` | 89 | | MapStrVecBool | `std::unordered_map > ` | 90 | | MapStrVecLong | `std::unordered_map > ` | 91 | | MapStrSetInt | `std::unordered_map > ` | 92 | | MapStrSetStr | `std::unordered_map > ` | 93 | | MapStrSetLong | `std::unordered_map > ` | 94 | | MapStrMapIntInt | `std::unordered_map > ` | 95 | | MapStrMapIntStr | `std::unordered_map > ` | 96 | | MapStrMapIntFloat | `std::unordered_map > ` | 97 | | MapStrMapIntDouble | `std::unordered_map > ` | 98 | | MapStrMapIntBool | `std::unordered_map > ` | 99 | | MapStrMapIntLong | `std::unordered_map > ` | 100 | | MapStrMapStrInt | `std::unordered_map > ` | 101 | | MapStrMapStrStr | `std::unordered_map > ` | 102 | | MapStrMapStrFloat | `std::unordered_map > ` | 103 | | MapStrMapStrDouble | `std::unordered_map > ` | 104 | | MapStrMapStrBool | `std::unordered_map > ` | 105 | | MapStrMapStrLong | `std::unordered_map > ` | 106 | | MapStrMapLongInt | `std::unordered_map > ` | 107 | | MapStrMapLongStr | `std::unordered_map > ` | 108 | | MapStrMapLongFloat | `std::unordered_map > ` | 109 | | MapStrMapLongDouble | `std::unordered_map > ` | 110 | | MapStrMapLongBool | `std::unordered_map > ` | 111 | | MapStrMapLongLong | `std::unordered_map > ` | 112 | | MapLongVecInt | `std::unordered_map > ` | 113 | | MapLongVecStr | `std::unordered_map > ` | 114 | | MapLongVecFloat | `std::unordered_map > ` | 115 | | MapLongVecDouble | `std::unordered_map > ` | 116 | | MapLongVecBool | `std::unordered_map > ` | 117 | | MapLongVecLong | `std::unordered_map > ` | 118 | | MapLongSetInt | `std::unordered_map > ` | 119 | | MapLongSetStr | `std::unordered_map > ` | 120 | | MapLongSetLong | `std::unordered_map > ` | 121 | | MapLongMapIntInt | `std::unordered_map > ` | 122 | | MapLongMapIntStr | `std::unordered_map > ` | 123 | | MapLongMapIntFloat | `std::unordered_map > ` | 124 | | MapLongMapIntDouble | `std::unordered_map > ` | 125 | | MapLongMapIntBool | `std::unordered_map > ` | 126 | | MapLongMapIntLong | `std::unordered_map > ` | 127 | | MapLongMapStrInt | `std::unordered_map > ` | 128 | | MapLongMapStrStr | `std::unordered_map > ` | 129 | | MapLongMapStrFloat | `std::unordered_map > ` | 130 | | MapLongMapStrDouble | `std::unordered_map > ` | 131 | | MapLongMapStrBool | `std::unordered_map > ` | 132 | | MapLongMapStrLong | `std::unordered_map > ` | 133 | | MapLongMapLongInt | `std::unordered_map > ` | 134 | | MapLongMapLongStr | `std::unordered_map > ` | 135 | | MapLongMapLongFloat | `std::unordered_map > ` | 136 | | MapLongMapLongDouble | `std::unordered_map > ` | 137 | | MapLongMapLongBool | `std::unordered_map > ` | 138 | | MapLongMapLongLong | `std::unordered_map > ` | 139 | | VecVecVecInt | `std::vector > > ` | 140 | | VecVecVecStr | `std::vector > > ` | 141 | | VecVecVecFloat | `std::vector > > ` | 142 | | VecVecVecDouble | `std::vector > > ` | 143 | | VecVecVecBool | `std::vector > > ` | 144 | | VecVecVecLong | `std::vector > > ` | 145 | | VecVecSetInt | `std::vector > > ` | 146 | | VecVecSetStr | `std::vector > > ` | 147 | | VecVecSetLong | `std::vector > > ` | 148 | | VecVecMapIntInt | `std::vector > > ` | 149 | | VecVecMapIntStr | `std::vector > > ` | 150 | | VecVecMapIntFloat | `std::vector > > ` | 151 | | VecVecMapIntDouble | `std::vector > > ` | 152 | | VecVecMapIntBool | `std::vector > > ` | 153 | | VecVecMapIntLong | `std::vector > > ` | 154 | | VecVecMapStrInt | `std::vector > > ` | 155 | | VecVecMapStrStr | `std::vector > > ` | 156 | | VecVecMapStrFloat | `std::vector > > ` | 157 | | VecVecMapStrDouble | `std::vector > > ` | 158 | | VecVecMapStrBool | `std::vector > > ` | 159 | | VecVecMapStrLong | `std::vector > > ` | 160 | | VecVecMapLongInt | `std::vector > > ` | 161 | | VecVecMapLongStr | `std::vector > > ` | 162 | | VecVecMapLongFloat | `std::vector > > ` | 163 | | VecVecMapLongDouble | `std::vector > > ` | 164 | | VecVecMapLongBool | `std::vector > > ` | 165 | | VecVecMapLongLong | `std::vector > > ` | 166 | | VecMapIntVecInt | `std::vector > > ` | 167 | | VecMapIntVecStr | `std::vector > > ` | 168 | | VecMapIntVecFloat | `std::vector > > ` | 169 | | VecMapIntVecDouble | `std::vector > > ` | 170 | | VecMapIntVecBool | `std::vector > > ` | 171 | | VecMapIntVecLong | `std::vector > > ` | 172 | | VecMapIntSetInt | `std::vector > > ` | 173 | | VecMapIntSetStr | `std::vector > > ` | 174 | | VecMapIntSetLong | `std::vector > > ` | 175 | | VecMapIntMapIntInt | `std::vector > > ` | 176 | | VecMapIntMapIntStr | `std::vector > > ` | 177 | | VecMapIntMapIntFloat | `std::vector > > ` | 178 | | VecMapIntMapIntDouble | `std::vector > > ` | 179 | | VecMapIntMapIntBool | `std::vector > > ` | 180 | | VecMapIntMapIntLong | `std::vector > > ` | 181 | | VecMapIntMapStrInt | `std::vector > > ` | 182 | | VecMapIntMapStrStr | `std::vector > > ` | 183 | | VecMapIntMapStrFloat | `std::vector > > ` | 184 | | VecMapIntMapStrDouble | `std::vector > > ` | 185 | | VecMapIntMapStrBool | `std::vector > > ` | 186 | | VecMapIntMapStrLong | `std::vector > > ` | 187 | | VecMapIntMapLongInt | `std::vector > > ` | 188 | | VecMapIntMapLongStr | `std::vector > > ` | 189 | | VecMapIntMapLongFloat | `std::vector > > ` | 190 | | VecMapIntMapLongDouble | `std::vector > > ` | 191 | | VecMapIntMapLongBool | `std::vector > > ` | 192 | | VecMapIntMapLongLong | `std::vector > > ` | 193 | | VecMapStrVecInt | `std::vector > > ` | 194 | | VecMapStrVecStr | `std::vector > > ` | 195 | | VecMapStrVecFloat | `std::vector > > ` | 196 | | VecMapStrVecDouble | `std::vector > > ` | 197 | | VecMapStrVecBool | `std::vector > > ` | 198 | | VecMapStrVecLong | `std::vector > > ` | 199 | | VecMapStrSetInt | `std::vector > > ` | 200 | | VecMapStrSetStr | `std::vector > > ` | 201 | | VecMapStrSetLong | `std::vector > > ` | 202 | | VecMapStrMapIntInt | `std::vector > > ` | 203 | | VecMapStrMapIntStr | `std::vector > > ` | 204 | | VecMapStrMapIntFloat | `std::vector > > ` | 205 | | VecMapStrMapIntDouble | `std::vector > > ` | 206 | | VecMapStrMapIntBool | `std::vector > > ` | 207 | | VecMapStrMapIntLong | `std::vector > > ` | 208 | | VecMapStrMapStrInt | `std::vector > > ` | 209 | | VecMapStrMapStrStr | `std::vector > > ` | 210 | | VecMapStrMapStrFloat | `std::vector > > ` | 211 | | VecMapStrMapStrDouble | `std::vector > > ` | 212 | | VecMapStrMapStrBool | `std::vector > > ` | 213 | | VecMapStrMapStrLong | `std::vector > > ` | 214 | | VecMapStrMapLongInt | `std::vector > > ` | 215 | | VecMapStrMapLongStr | `std::vector > > ` | 216 | | VecMapStrMapLongFloat | `std::vector > > ` | 217 | | VecMapStrMapLongDouble | `std::vector > > ` | 218 | | VecMapStrMapLongBool | `std::vector > > ` | 219 | | VecMapStrMapLongLong | `std::vector > > ` | 220 | | VecMapLongVecInt | `std::vector > > ` | 221 | | VecMapLongVecStr | `std::vector > > ` | 222 | | VecMapLongVecFloat | `std::vector > > ` | 223 | | VecMapLongVecDouble | `std::vector > > ` | 224 | | VecMapLongVecBool | `std::vector > > ` | 225 | | VecMapLongVecLong | `std::vector > > ` | 226 | | VecMapLongSetInt | `std::vector > > ` | 227 | | VecMapLongSetStr | `std::vector > > ` | 228 | | VecMapLongSetLong | `std::vector > > ` | 229 | | VecMapLongMapIntInt | `std::vector > > ` | 230 | | VecMapLongMapIntStr | `std::vector > > ` | 231 | | VecMapLongMapIntFloat | `std::vector > > ` | 232 | | VecMapLongMapIntDouble | `std::vector > > ` | 233 | | VecMapLongMapIntBool | `std::vector > > ` | 234 | | VecMapLongMapIntLong | `std::vector > > ` | 235 | | VecMapLongMapStrInt | `std::vector > > ` | 236 | | VecMapLongMapStrStr | `std::vector > > ` | 237 | | VecMapLongMapStrFloat | `std::vector > > ` | 238 | | VecMapLongMapStrDouble | `std::vector > > ` | 239 | | VecMapLongMapStrBool | `std::vector > > ` | 240 | | VecMapLongMapStrLong | `std::vector > > ` | 241 | | VecMapLongMapLongInt | `std::vector > > ` | 242 | | VecMapLongMapLongStr | `std::vector > > ` | 243 | | VecMapLongMapLongFloat | `std::vector > > ` | 244 | | VecMapLongMapLongDouble | `std::vector > > ` | 245 | | VecMapLongMapLongBool | `std::vector > > ` | 246 | | VecMapLongMapLongLong | `std::vector > > ` | 247 | | MapIntVecVecInt | `std::unordered_map > > ` | 248 | | MapIntVecVecStr | `std::unordered_map > > ` | 249 | | MapIntVecVecFloat | `std::unordered_map > > ` | 250 | | MapIntVecVecDouble | `std::unordered_map > > ` | 251 | | MapIntVecVecBool | `std::unordered_map > > ` | 252 | | MapIntVecVecLong | `std::unordered_map > > ` | 253 | | MapIntVecSetInt | `std::unordered_map > > ` | 254 | | MapIntVecSetStr | `std::unordered_map > > ` | 255 | | MapIntVecSetLong | `std::unordered_map > > ` | 256 | | MapIntVecMapIntInt | `std::unordered_map > > ` | 257 | | MapIntVecMapIntStr | `std::unordered_map > > ` | 258 | | MapIntVecMapIntFloat | `std::unordered_map > > ` | 259 | | MapIntVecMapIntDouble | `std::unordered_map > > ` | 260 | | MapIntVecMapIntBool | `std::unordered_map > > ` | 261 | | MapIntVecMapIntLong | `std::unordered_map > > ` | 262 | | MapIntVecMapStrInt | `std::unordered_map > > ` | 263 | | MapIntVecMapStrStr | `std::unordered_map > > ` | 264 | | MapIntVecMapStrFloat | `std::unordered_map > > ` | 265 | | MapIntVecMapStrDouble | `std::unordered_map > > ` | 266 | | MapIntVecMapStrBool | `std::unordered_map > > ` | 267 | | MapIntVecMapStrLong | `std::unordered_map > > ` | 268 | | MapIntVecMapLongInt | `std::unordered_map > > ` | 269 | | MapIntVecMapLongStr | `std::unordered_map > > ` | 270 | | MapIntVecMapLongFloat | `std::unordered_map > > ` | 271 | | MapIntVecMapLongDouble | `std::unordered_map > > ` | 272 | | MapIntVecMapLongBool | `std::unordered_map > > ` | 273 | | MapIntVecMapLongLong | `std::unordered_map > > ` | 274 | | MapIntMapIntVecInt | `std::unordered_map > > ` | 275 | | MapIntMapIntVecStr | `std::unordered_map > > ` | 276 | | MapIntMapIntVecFloat | `std::unordered_map > > ` | 277 | | MapIntMapIntVecDouble | `std::unordered_map > > ` | 278 | | MapIntMapIntVecBool | `std::unordered_map > > ` | 279 | | MapIntMapIntVecLong | `std::unordered_map > > ` | 280 | | MapIntMapIntSetInt | `std::unordered_map > > ` | 281 | | MapIntMapIntSetStr | `std::unordered_map > > ` | 282 | | MapIntMapIntSetLong | `std::unordered_map > > ` | 283 | | MapIntMapIntMapIntInt | `std::unordered_map > > ` | 284 | | MapIntMapIntMapIntStr | `std::unordered_map > > ` | 285 | | MapIntMapIntMapIntFloat | `std::unordered_map > > ` | 286 | | MapIntMapIntMapIntDouble | `std::unordered_map > > ` | 287 | | MapIntMapIntMapIntBool | `std::unordered_map > > ` | 288 | | MapIntMapIntMapIntLong | `std::unordered_map > > ` | 289 | | MapIntMapIntMapStrInt | `std::unordered_map > > ` | 290 | | MapIntMapIntMapStrStr | `std::unordered_map > > ` | 291 | | MapIntMapIntMapStrFloat | `std::unordered_map > > ` | 292 | | MapIntMapIntMapStrDouble | `std::unordered_map > > ` | 293 | | MapIntMapIntMapStrBool | `std::unordered_map > > ` | 294 | | MapIntMapIntMapStrLong | `std::unordered_map > > ` | 295 | | MapIntMapIntMapLongInt | `std::unordered_map > > ` | 296 | | MapIntMapIntMapLongStr | `std::unordered_map > > ` | 297 | | MapIntMapIntMapLongFloat | `std::unordered_map > > ` | 298 | | MapIntMapIntMapLongDouble | `std::unordered_map > > ` | 299 | | MapIntMapIntMapLongBool | `std::unordered_map > > ` | 300 | | MapIntMapIntMapLongLong | `std::unordered_map > > ` | 301 | | MapIntMapStrVecInt | `std::unordered_map > > ` | 302 | | MapIntMapStrVecStr | `std::unordered_map > > ` | 303 | | MapIntMapStrVecFloat | `std::unordered_map > > ` | 304 | | MapIntMapStrVecDouble | `std::unordered_map > > ` | 305 | | MapIntMapStrVecBool | `std::unordered_map > > ` | 306 | | MapIntMapStrVecLong | `std::unordered_map > > ` | 307 | | MapIntMapStrSetInt | `std::unordered_map > > ` | 308 | | MapIntMapStrSetStr | `std::unordered_map > > ` | 309 | | MapIntMapStrSetLong | `std::unordered_map > > ` | 310 | | MapIntMapStrMapIntInt | `std::unordered_map > > ` | 311 | | MapIntMapStrMapIntStr | `std::unordered_map > > ` | 312 | | MapIntMapStrMapIntFloat | `std::unordered_map > > ` | 313 | | MapIntMapStrMapIntDouble | `std::unordered_map > > ` | 314 | | MapIntMapStrMapIntBool | `std::unordered_map > > ` | 315 | | MapIntMapStrMapIntLong | `std::unordered_map > > ` | 316 | | MapIntMapStrMapStrInt | `std::unordered_map > > ` | 317 | | MapIntMapStrMapStrStr | `std::unordered_map > > ` | 318 | | MapIntMapStrMapStrFloat | `std::unordered_map > > ` | 319 | | MapIntMapStrMapStrDouble | `std::unordered_map > > ` | 320 | | MapIntMapStrMapStrBool | `std::unordered_map > > ` | 321 | | MapIntMapStrMapStrLong | `std::unordered_map > > ` | 322 | | MapIntMapStrMapLongInt | `std::unordered_map > > ` | 323 | | MapIntMapStrMapLongStr | `std::unordered_map > > ` | 324 | | MapIntMapStrMapLongFloat | `std::unordered_map > > ` | 325 | | MapIntMapStrMapLongDouble | `std::unordered_map > > ` | 326 | | MapIntMapStrMapLongBool | `std::unordered_map > > ` | 327 | | MapIntMapStrMapLongLong | `std::unordered_map > > ` | 328 | | MapIntMapLongVecInt | `std::unordered_map > > ` | 329 | | MapIntMapLongVecStr | `std::unordered_map > > ` | 330 | | MapIntMapLongVecFloat | `std::unordered_map > > ` | 331 | | MapIntMapLongVecDouble | `std::unordered_map > > ` | 332 | | MapIntMapLongVecBool | `std::unordered_map > > ` | 333 | | MapIntMapLongVecLong | `std::unordered_map > > ` | 334 | | MapIntMapLongSetInt | `std::unordered_map > > ` | 335 | | MapIntMapLongSetStr | `std::unordered_map > > ` | 336 | | MapIntMapLongSetLong | `std::unordered_map > > ` | 337 | | MapIntMapLongMapIntInt | `std::unordered_map > > ` | 338 | | MapIntMapLongMapIntStr | `std::unordered_map > > ` | 339 | | MapIntMapLongMapIntFloat | `std::unordered_map > > ` | 340 | | MapIntMapLongMapIntDouble | `std::unordered_map > > ` | 341 | | MapIntMapLongMapIntBool | `std::unordered_map > > ` | 342 | | MapIntMapLongMapIntLong | `std::unordered_map > > ` | 343 | | MapIntMapLongMapStrInt | `std::unordered_map > > ` | 344 | | MapIntMapLongMapStrStr | `std::unordered_map > > ` | 345 | | MapIntMapLongMapStrFloat | `std::unordered_map > > ` | 346 | | MapIntMapLongMapStrDouble | `std::unordered_map > > ` | 347 | | MapIntMapLongMapStrBool | `std::unordered_map > > ` | 348 | | MapIntMapLongMapStrLong | `std::unordered_map > > ` | 349 | | MapIntMapLongMapLongInt | `std::unordered_map > > ` | 350 | | MapIntMapLongMapLongStr | `std::unordered_map > > ` | 351 | | MapIntMapLongMapLongFloat | `std::unordered_map > > ` | 352 | | MapIntMapLongMapLongDouble | `std::unordered_map > > ` | 353 | | MapIntMapLongMapLongBool | `std::unordered_map > > ` | 354 | | MapIntMapLongMapLongLong | `std::unordered_map > > ` | 355 | | MapStrVecVecInt | `std::unordered_map > > ` | 356 | | MapStrVecVecStr | `std::unordered_map > > ` | 357 | | MapStrVecVecFloat | `std::unordered_map > > ` | 358 | | MapStrVecVecDouble | `std::unordered_map > > ` | 359 | | MapStrVecVecBool | `std::unordered_map > > ` | 360 | | MapStrVecVecLong | `std::unordered_map > > ` | 361 | | MapStrVecSetInt | `std::unordered_map > > ` | 362 | | MapStrVecSetStr | `std::unordered_map > > ` | 363 | | MapStrVecSetLong | `std::unordered_map > > ` | 364 | | MapStrVecMapIntInt | `std::unordered_map > > ` | 365 | | MapStrVecMapIntStr | `std::unordered_map > > ` | 366 | | MapStrVecMapIntFloat | `std::unordered_map > > ` | 367 | | MapStrVecMapIntDouble | `std::unordered_map > > ` | 368 | | MapStrVecMapIntBool | `std::unordered_map > > ` | 369 | | MapStrVecMapIntLong | `std::unordered_map > > ` | 370 | | MapStrVecMapStrInt | `std::unordered_map > > ` | 371 | | MapStrVecMapStrStr | `std::unordered_map > > ` | 372 | | MapStrVecMapStrFloat | `std::unordered_map > > ` | 373 | | MapStrVecMapStrDouble | `std::unordered_map > > ` | 374 | | MapStrVecMapStrBool | `std::unordered_map > > ` | 375 | | MapStrVecMapStrLong | `std::unordered_map > > ` | 376 | | MapStrVecMapLongInt | `std::unordered_map > > ` | 377 | | MapStrVecMapLongStr | `std::unordered_map > > ` | 378 | | MapStrVecMapLongFloat | `std::unordered_map > > ` | 379 | | MapStrVecMapLongDouble | `std::unordered_map > > ` | 380 | | MapStrVecMapLongBool | `std::unordered_map > > ` | 381 | | MapStrVecMapLongLong | `std::unordered_map > > ` | 382 | | MapStrMapIntVecInt | `std::unordered_map > > ` | 383 | | MapStrMapIntVecStr | `std::unordered_map > > ` | 384 | | MapStrMapIntVecFloat | `std::unordered_map > > ` | 385 | | MapStrMapIntVecDouble | `std::unordered_map > > ` | 386 | | MapStrMapIntVecBool | `std::unordered_map > > ` | 387 | | MapStrMapIntVecLong | `std::unordered_map > > ` | 388 | | MapStrMapIntSetInt | `std::unordered_map > > ` | 389 | | MapStrMapIntSetStr | `std::unordered_map > > ` | 390 | | MapStrMapIntSetLong | `std::unordered_map > > ` | 391 | | MapStrMapIntMapIntInt | `std::unordered_map > > ` | 392 | | MapStrMapIntMapIntStr | `std::unordered_map > > ` | 393 | | MapStrMapIntMapIntFloat | `std::unordered_map > > ` | 394 | | MapStrMapIntMapIntDouble | `std::unordered_map > > ` | 395 | | MapStrMapIntMapIntBool | `std::unordered_map > > ` | 396 | | MapStrMapIntMapIntLong | `std::unordered_map > > ` | 397 | | MapStrMapIntMapStrInt | `std::unordered_map > > ` | 398 | | MapStrMapIntMapStrStr | `std::unordered_map > > ` | 399 | | MapStrMapIntMapStrFloat | `std::unordered_map > > ` | 400 | | MapStrMapIntMapStrDouble | `std::unordered_map > > ` | 401 | | MapStrMapIntMapStrBool | `std::unordered_map > > ` | 402 | | MapStrMapIntMapStrLong | `std::unordered_map > > ` | 403 | | MapStrMapIntMapLongInt | `std::unordered_map > > ` | 404 | | MapStrMapIntMapLongStr | `std::unordered_map > > ` | 405 | | MapStrMapIntMapLongFloat | `std::unordered_map > > ` | 406 | | MapStrMapIntMapLongDouble | `std::unordered_map > > ` | 407 | | MapStrMapIntMapLongBool | `std::unordered_map > > ` | 408 | | MapStrMapIntMapLongLong | `std::unordered_map > > ` | 409 | | MapStrMapStrVecInt | `std::unordered_map > > ` | 410 | | MapStrMapStrVecStr | `std::unordered_map > > ` | 411 | | MapStrMapStrVecFloat | `std::unordered_map > > ` | 412 | | MapStrMapStrVecDouble | `std::unordered_map > > ` | 413 | | MapStrMapStrVecBool | `std::unordered_map > > ` | 414 | | MapStrMapStrVecLong | `std::unordered_map > > ` | 415 | | MapStrMapStrSetInt | `std::unordered_map > > ` | 416 | | MapStrMapStrSetStr | `std::unordered_map > > ` | 417 | | MapStrMapStrSetLong | `std::unordered_map > > ` | 418 | | MapStrMapStrMapIntInt | `std::unordered_map > > ` | 419 | | MapStrMapStrMapIntStr | `std::unordered_map > > ` | 420 | | MapStrMapStrMapIntFloat | `std::unordered_map > > ` | 421 | | MapStrMapStrMapIntDouble | `std::unordered_map > > ` | 422 | | MapStrMapStrMapIntBool | `std::unordered_map > > ` | 423 | | MapStrMapStrMapIntLong | `std::unordered_map > > ` | 424 | | MapStrMapStrMapStrInt | `std::unordered_map > > ` | 425 | | MapStrMapStrMapStrStr | `std::unordered_map > > ` | 426 | | MapStrMapStrMapStrFloat | `std::unordered_map > > ` | 427 | | MapStrMapStrMapStrDouble | `std::unordered_map > > ` | 428 | | MapStrMapStrMapStrBool | `std::unordered_map > > ` | 429 | | MapStrMapStrMapStrLong | `std::unordered_map > > ` | 430 | | MapStrMapStrMapLongInt | `std::unordered_map > > ` | 431 | | MapStrMapStrMapLongStr | `std::unordered_map > > ` | 432 | | MapStrMapStrMapLongFloat | `std::unordered_map > > ` | 433 | | MapStrMapStrMapLongDouble | `std::unordered_map > > ` | 434 | | MapStrMapStrMapLongBool | `std::unordered_map > > ` | 435 | | MapStrMapStrMapLongLong | `std::unordered_map > > ` | 436 | | MapStrMapLongVecInt | `std::unordered_map > > ` | 437 | | MapStrMapLongVecStr | `std::unordered_map > > ` | 438 | | MapStrMapLongVecFloat | `std::unordered_map > > ` | 439 | | MapStrMapLongVecDouble | `std::unordered_map > > ` | 440 | | MapStrMapLongVecBool | `std::unordered_map > > ` | 441 | | MapStrMapLongVecLong | `std::unordered_map > > ` | 442 | | MapStrMapLongSetInt | `std::unordered_map > > ` | 443 | | MapStrMapLongSetStr | `std::unordered_map > > ` | 444 | | MapStrMapLongSetLong | `std::unordered_map > > ` | 445 | | MapStrMapLongMapIntInt | `std::unordered_map > > ` | 446 | | MapStrMapLongMapIntStr | `std::unordered_map > > ` | 447 | | MapStrMapLongMapIntFloat | `std::unordered_map > > ` | 448 | | MapStrMapLongMapIntDouble | `std::unordered_map > > ` | 449 | | MapStrMapLongMapIntBool | `std::unordered_map > > ` | 450 | | MapStrMapLongMapIntLong | `std::unordered_map > > ` | 451 | | MapStrMapLongMapStrInt | `std::unordered_map > > ` | 452 | | MapStrMapLongMapStrStr | `std::unordered_map > > ` | 453 | | MapStrMapLongMapStrFloat | `std::unordered_map > > ` | 454 | | MapStrMapLongMapStrDouble | `std::unordered_map > > ` | 455 | | MapStrMapLongMapStrBool | `std::unordered_map > > ` | 456 | | MapStrMapLongMapStrLong | `std::unordered_map > > ` | 457 | | MapStrMapLongMapLongInt | `std::unordered_map > > ` | 458 | | MapStrMapLongMapLongStr | `std::unordered_map > > ` | 459 | | MapStrMapLongMapLongFloat | `std::unordered_map > > ` | 460 | | MapStrMapLongMapLongDouble | `std::unordered_map > > ` | 461 | | MapStrMapLongMapLongBool | `std::unordered_map > > ` | 462 | | MapStrMapLongMapLongLong | `std::unordered_map > > ` | 463 | | MapLongVecVecInt | `std::unordered_map > > ` | 464 | | MapLongVecVecStr | `std::unordered_map > > ` | 465 | | MapLongVecVecFloat | `std::unordered_map > > ` | 466 | | MapLongVecVecDouble | `std::unordered_map > > ` | 467 | | MapLongVecVecBool | `std::unordered_map > > ` | 468 | | MapLongVecVecLong | `std::unordered_map > > ` | 469 | | MapLongVecSetInt | `std::unordered_map > > ` | 470 | | MapLongVecSetStr | `std::unordered_map > > ` | 471 | | MapLongVecSetLong | `std::unordered_map > > ` | 472 | | MapLongVecMapIntInt | `std::unordered_map > > ` | 473 | | MapLongVecMapIntStr | `std::unordered_map > > ` | 474 | | MapLongVecMapIntFloat | `std::unordered_map > > ` | 475 | | MapLongVecMapIntDouble | `std::unordered_map > > ` | 476 | | MapLongVecMapIntBool | `std::unordered_map > > ` | 477 | | MapLongVecMapIntLong | `std::unordered_map > > ` | 478 | | MapLongVecMapStrInt | `std::unordered_map > > ` | 479 | | MapLongVecMapStrStr | `std::unordered_map > > ` | 480 | | MapLongVecMapStrFloat | `std::unordered_map > > ` | 481 | | MapLongVecMapStrDouble | `std::unordered_map > > ` | 482 | | MapLongVecMapStrBool | `std::unordered_map > > ` | 483 | | MapLongVecMapStrLong | `std::unordered_map > > ` | 484 | | MapLongVecMapLongInt | `std::unordered_map > > ` | 485 | | MapLongVecMapLongStr | `std::unordered_map > > ` | 486 | | MapLongVecMapLongFloat | `std::unordered_map > > ` | 487 | | MapLongVecMapLongDouble | `std::unordered_map > > ` | 488 | | MapLongVecMapLongBool | `std::unordered_map > > ` | 489 | | MapLongVecMapLongLong | `std::unordered_map > > ` | 490 | | MapLongMapIntVecInt | `std::unordered_map > > ` | 491 | | MapLongMapIntVecStr | `std::unordered_map > > ` | 492 | | MapLongMapIntVecFloat | `std::unordered_map > > ` | 493 | | MapLongMapIntVecDouble | `std::unordered_map > > ` | 494 | | MapLongMapIntVecBool | `std::unordered_map > > ` | 495 | | MapLongMapIntVecLong | `std::unordered_map > > ` | 496 | | MapLongMapIntSetInt | `std::unordered_map > > ` | 497 | | MapLongMapIntSetStr | `std::unordered_map > > ` | 498 | | MapLongMapIntSetLong | `std::unordered_map > > ` | 499 | | MapLongMapIntMapIntInt | `std::unordered_map > > ` | 500 | | MapLongMapIntMapIntStr | `std::unordered_map > > ` | 501 | | MapLongMapIntMapIntFloat | `std::unordered_map > > ` | 502 | | MapLongMapIntMapIntDouble | `std::unordered_map > > ` | 503 | | MapLongMapIntMapIntBool | `std::unordered_map > > ` | 504 | | MapLongMapIntMapIntLong | `std::unordered_map > > ` | 505 | | MapLongMapIntMapStrInt | `std::unordered_map > > ` | 506 | | MapLongMapIntMapStrStr | `std::unordered_map > > ` | 507 | | MapLongMapIntMapStrFloat | `std::unordered_map > > ` | 508 | | MapLongMapIntMapStrDouble | `std::unordered_map > > ` | 509 | | MapLongMapIntMapStrBool | `std::unordered_map > > ` | 510 | | MapLongMapIntMapStrLong | `std::unordered_map > > ` | 511 | | MapLongMapIntMapLongInt | `std::unordered_map > > ` | 512 | | MapLongMapIntMapLongStr | `std::unordered_map > > ` | 513 | | MapLongMapIntMapLongFloat | `std::unordered_map > > ` | 514 | | MapLongMapIntMapLongDouble | `std::unordered_map > > ` | 515 | | MapLongMapIntMapLongBool | `std::unordered_map > > ` | 516 | | MapLongMapIntMapLongLong | `std::unordered_map > > ` | 517 | | MapLongMapStrVecInt | `std::unordered_map > > ` | 518 | | MapLongMapStrVecStr | `std::unordered_map > > ` | 519 | | MapLongMapStrVecFloat | `std::unordered_map > > ` | 520 | | MapLongMapStrVecDouble | `std::unordered_map > > ` | 521 | | MapLongMapStrVecBool | `std::unordered_map > > ` | 522 | | MapLongMapStrVecLong | `std::unordered_map > > ` | 523 | | MapLongMapStrSetInt | `std::unordered_map > > ` | 524 | | MapLongMapStrSetStr | `std::unordered_map > > ` | 525 | | MapLongMapStrSetLong | `std::unordered_map > > ` | 526 | | MapLongMapStrMapIntInt | `std::unordered_map > > ` | 527 | | MapLongMapStrMapIntStr | `std::unordered_map > > ` | 528 | | MapLongMapStrMapIntFloat | `std::unordered_map > > ` | 529 | | MapLongMapStrMapIntDouble | `std::unordered_map > > ` | 530 | | MapLongMapStrMapIntBool | `std::unordered_map > > ` | 531 | | MapLongMapStrMapIntLong | `std::unordered_map > > ` | 532 | | MapLongMapStrMapStrInt | `std::unordered_map > > ` | 533 | | MapLongMapStrMapStrStr | `std::unordered_map > > ` | 534 | | MapLongMapStrMapStrFloat | `std::unordered_map > > ` | 535 | | MapLongMapStrMapStrDouble | `std::unordered_map > > ` | 536 | | MapLongMapStrMapStrBool | `std::unordered_map > > ` | 537 | | MapLongMapStrMapStrLong | `std::unordered_map > > ` | 538 | | MapLongMapStrMapLongInt | `std::unordered_map > > ` | 539 | | MapLongMapStrMapLongStr | `std::unordered_map > > ` | 540 | | MapLongMapStrMapLongFloat | `std::unordered_map > > ` | 541 | | MapLongMapStrMapLongDouble | `std::unordered_map > > ` | 542 | | MapLongMapStrMapLongBool | `std::unordered_map > > ` | 543 | | MapLongMapStrMapLongLong | `std::unordered_map > > ` | 544 | | MapLongMapLongVecInt | `std::unordered_map > > ` | 545 | | MapLongMapLongVecStr | `std::unordered_map > > ` | 546 | | MapLongMapLongVecFloat | `std::unordered_map > > ` | 547 | | MapLongMapLongVecDouble | `std::unordered_map > > ` | 548 | | MapLongMapLongVecBool | `std::unordered_map > > ` | 549 | | MapLongMapLongVecLong | `std::unordered_map > > ` | 550 | | MapLongMapLongSetInt | `std::unordered_map > > ` | 551 | | MapLongMapLongSetStr | `std::unordered_map > > ` | 552 | | MapLongMapLongSetLong | `std::unordered_map > > ` | 553 | | MapLongMapLongMapIntInt | `std::unordered_map > > ` | 554 | | MapLongMapLongMapIntStr | `std::unordered_map > > ` | 555 | | MapLongMapLongMapIntFloat | `std::unordered_map > > ` | 556 | | MapLongMapLongMapIntDouble | `std::unordered_map > > ` | 557 | | MapLongMapLongMapIntBool | `std::unordered_map > > ` | 558 | | MapLongMapLongMapIntLong | `std::unordered_map > > ` | 559 | | MapLongMapLongMapStrInt | `std::unordered_map > > ` | 560 | | MapLongMapLongMapStrStr | `std::unordered_map > > ` | 561 | | MapLongMapLongMapStrFloat | `std::unordered_map > > ` | 562 | | MapLongMapLongMapStrDouble | `std::unordered_map > > ` | 563 | | MapLongMapLongMapStrBool | `std::unordered_map > > ` | 564 | | MapLongMapLongMapStrLong | `std::unordered_map > > ` | 565 | | MapLongMapLongMapLongInt | `std::unordered_map > > ` | 566 | | MapLongMapLongMapLongStr | `std::unordered_map > > ` | 567 | | MapLongMapLongMapLongFloat | `std::unordered_map > > ` | 568 | | MapLongMapLongMapLongDouble | `std::unordered_map > > ` | 569 | | MapLongMapLongMapLongBool | `std::unordered_map > > ` | 570 | | MapLongMapLongMapLongLong | `std::unordered_map > > ` | --------------------------------------------------------------------------------