search

trelau / pyOCCT_binder

Binding generator for pyOCCT project
GNU Lesser General Public License v2.1
7 stars 1 forks source link

Fix issues with move to Clang/llvm 12 #18

Closed frmdstryr closed 3 years ago

frmdstryr commented 3 years ago

Issue to track what the update to clang/llvm12 broke.. not sure why yet but some templates are not picking up the last type.

Here's a diff of the bindings from the llvm11 and llvm12 ubuntu src (from the actions)

LLVM11 vs LLVM12
```diff
diff --git a/pyocct_src_ubuntu-latest_llvm11/AIS.cxx b/pyocct_src_ubuntu-latest_llvm12/AIS.cxx
index db0d6b5..003c88c 100644
--- a/pyocct_src_ubuntu-latest_llvm11/AIS.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/AIS.cxx
@@ -1417,7 +1417,7 @@ cls_AIS_ConnectedInteractive.def("AcceptShapeDecomposition", (Standard_Boolean (
 cls_AIS_ConnectedInteractive.def("AcceptDisplayMode", (Standard_Boolean (AIS_ConnectedInteractive::*)(const Standard_Integer) const) &AIS_ConnectedInteractive::AcceptDisplayMode, "Return true if reference presentation accepts specified display mode.", py::arg("theMode"));

 // TYPEDEF: AIS_DATAMAPOFINTEGERLISTOFINTERACTIVE
-bind_NCollection_DataMap<int, NCollection_List<opencascade::handle<AIS_InteractiveObject>>, NCollection_DefaultHasher<int>>(mod, "AIS_DataMapofIntegerListOfinteractive", py::module_local(false));
+bind_NCollection_DataMap<int, NCollection_List<opencascade::handle<AIS_InteractiveObject>>>(mod, "AIS_DataMapofIntegerListOfinteractive", py::module_local(false));

 // TYPEDEF: AIS_DATAMAPITERATOROFDATAMAPOFINTEGERLISTOFINTERACTIVE

@@ -1882,7 +1882,7 @@ cls_AIS_MinRadiusDimension.def("DynamicType", (const opencascade::handle<Standar
 */

 // TYPEDEF: AIS_MOUSEGESTUREMAP
-bind_NCollection_DataMap<unsigned int, AIS_MouseGesture, NCollection_DefaultHasher<unsigned int>>(mod, "AIS_MouseGestureMap", py::module_local(false));
+bind_NCollection_DataMap<unsigned int, AIS_MouseGesture>(mod, "AIS_MouseGestureMap", py::module_local(false));

 // CLASS: AIS_MULTIPLECONNECTEDINTERACTIVE
 py::class_<AIS_MultipleConnectedInteractive, opencascade::handle<AIS_MultipleConnectedInteractive>, AIS_InteractiveObject> cls_AIS_MultipleConnectedInteractive(mod, "AIS_MultipleConnectedInteractive", "Defines an Interactive Object by gathering together several object presentations. This is done through a list of interactive objects. These can also be Connected objects. That way memory-costly calculations of presentation are avoided.");
diff --git a/pyocct_src_ubuntu-latest_llvm11/Aspect.cxx b/pyocct_src_ubuntu-latest_llvm12/Aspect.cxx
index bccfee3..8d26729 100644
--- a/pyocct_src_ubuntu-latest_llvm11/Aspect.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/Aspect.cxx
@@ -720,7 +720,7 @@ cls_Aspect_Touch.def_readwrite("IsPreciseDevice", &Aspect_Touch::IsPreciseDevice
 cls_Aspect_Touch.def("Delta", (NCollection_Vec2<Standard_Real> (Aspect_Touch::*)() const) &Aspect_Touch::Delta, "Return values delta.");

 // TYPEDEF: ASPECT_TOUCHMAP
-bind_NCollection_IndexedDataMap<unsigned long, Aspect_Touch, NCollection_DefaultHasher<unsigned long>>(mod, "Aspect_TouchMap", py::module_local(false));
+bind_NCollection_IndexedDataMap<unsigned long, Aspect_Touch>(mod, "Aspect_TouchMap", py::module_local(false));

 // CLASS: ASPECT_XRHAPTICACTIONDATA
 py::class_<Aspect_XRHapticActionData> cls_Aspect_XRHapticActionData(mod, "Aspect_XRHapticActionData", "Haptic output XR action data.");
diff --git a/pyocct_src_ubuntu-latest_llvm11/BOPDS.cxx b/pyocct_src_ubuntu-latest_llvm12/BOPDS.cxx
index 404db17..7fd0bfb 100644
--- a/pyocct_src_ubuntu-latest_llvm11/BOPDS.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/BOPDS.cxx
@@ -359,7 +359,7 @@ cls_BOPDS_CommonBlock.def_static("get_type_descriptor_", (const opencascade::han
 cls_BOPDS_CommonBlock.def("DynamicType", (const opencascade::handle<Standard_Type> & (BOPDS_CommonBlock::*)() const) &BOPDS_CommonBlock::DynamicType, "None");

 // TYPEDEF: BOPDS_DATAMAPOFINTEGERLISTOFPAVEBLOCK
-bind_NCollection_DataMap<int, NCollection_List<opencascade::handle<BOPDS_PaveBlock>>, NCollection_DefaultHasher<int>>(mod, "BOPDS_DataMapOfIntegerListOfPaveBlock", py::module_local(false));
+bind_NCollection_DataMap<int, NCollection_List<opencascade::handle<BOPDS_PaveBlock>>>(mod, "BOPDS_DataMapOfIntegerListOfPaveBlock", py::module_local(false));

 // TYPEDEF: BOPDS_DATAMAPOFPAVEBLOCKCOMMONBLOCK
 bind_NCollection_DataMap<opencascade::handle<BOPDS_PaveBlock>, opencascade::handle<BOPDS_CommonBlock>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "BOPDS_DataMapOfPaveBlockCommonBlock", py::module_local(false));
diff --git a/pyocct_src_ubuntu-latest_llvm11/BRepExtrema.cxx b/pyocct_src_ubuntu-latest_llvm12/BRepExtrema.cxx
index 74876a9..0817c7e 100644
--- a/pyocct_src_ubuntu-latest_llvm11/BRepExtrema.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/BRepExtrema.cxx
@@ -341,7 +341,7 @@ cls_BRepExtrema_ExtPF.def("SetFlag", (void (BRepExtrema_ExtPF::*)(const Extrema_
 cls_BRepExtrema_ExtPF.def("SetAlgo", (void (BRepExtrema_ExtPF::*)(const Extrema_ExtAlgo)) &BRepExtrema_ExtPF::SetAlgo, "None", py::arg("A"));

 // TYPEDEF: BREPEXTREMA_MAPOFINTEGERPACKEDMAPOFINTEGER
-bind_NCollection_DataMap<int, TColStd_PackedMapOfInteger, NCollection_DefaultHasher<int>>(mod, "BRepExtrema_MapOfIntegerPackedMapOfInteger", py::module_local(false));
+bind_NCollection_DataMap<int, TColStd_PackedMapOfInteger>(mod, "BRepExtrema_MapOfIntegerPackedMapOfInteger", py::module_local(false));

 // TYPEDEF: BREPEXTREMA_SHAPELIST
 bind_NCollection_Vector<TopoDS_Face>(mod, "BRepExtrema_ShapeList", py::module_local(false));
diff --git a/pyocct_src_ubuntu-latest_llvm11/BVH.cxx b/pyocct_src_ubuntu-latest_llvm12/BVH.cxx
index eddd86c..9702bd4 100644
--- a/pyocct_src_ubuntu-latest_llvm11/BVH.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/BVH.cxx
@@ -45,15 +45,15 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 #include <bind_NCollection_Mat4.hxx>
 #include <bind_BVH_PrimitiveSet.hxx>

-PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec2<int>, std::allocator<NCollection_Vec2<int>>>)
-PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec3<int>, std::allocator<NCollection_Vec3<int>>>)
-PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec4<int>, std::allocator<NCollection_Vec4<int>>>)
-PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec2<float>, std::allocator<NCollection_Vec2<float>>>)
-PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec3<float>, std::allocator<NCollection_Vec3<float>>>)
-PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec4<float>, std::allocator<NCollection_Vec4<float>>>)
-PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec2<double>, std::allocator<NCollection_Vec2<double>>>)
-PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec3<double>, std::allocator<NCollection_Vec3<double>>>)
-PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec4<double>, std::allocator<NCollection_Vec4<double>>>)
+PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec2<int>>)
+PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec3<int>>)
+PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec4<int>>)
+PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec2<float>>)
+PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec3<float>>)
+PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec4<float>>)
+PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec2<double>>)
+PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec3<double>>)
+PYBIND11_MAKE_OPAQUE(std::vector<NCollection_Vec4<double>>)

 PYBIND11_MODULE(BVH, mod) {

@@ -71,13 +71,13 @@ bind_NCollection_Vec3<int>(mod, "BVH_Vec3i", py::module_local(false));
 bind_NCollection_Vec4<int>(mod, "BVH_Vec4i", py::module_local(false));

 // TYPEDEF: BVH_ARRAY2I
-py::bind_vector<std::vector<NCollection_Vec2<int>, std::allocator<NCollection_Vec2<int>>>>(mod, "BVH_Array2i");
+py::bind_vector<std::vector<NCollection_Vec2<int>>>(mod, "BVH_Array2i");

 // TYPEDEF: BVH_ARRAY3I
-py::bind_vector<std::vector<NCollection_Vec3<int>, std::allocator<NCollection_Vec3<int>>>>(mod, "BVH_Array3i");
+py::bind_vector<std::vector<NCollection_Vec3<int>>>(mod, "BVH_Array3i");

 // TYPEDEF: BVH_ARRAY4I
-py::bind_vector<std::vector<NCollection_Vec4<int>, std::allocator<NCollection_Vec4<int>>>>(mod, "BVH_Array4i");
+py::bind_vector<std::vector<NCollection_Vec4<int>>>(mod, "BVH_Array4i");

 // TYPEDEF: BVH_VEC2F
 bind_NCollection_Vec2<float>(mod, "BVH_Vec2f", py::module_local(false));
@@ -89,13 +89,13 @@ bind_NCollection_Vec3<float>(mod, "BVH_Vec3f", py::module_local(false));
 bind_NCollection_Vec4<float>(mod, "BVH_Vec4f", py::module_local(false));

 // TYPEDEF: BVH_ARRAY2F
-py::bind_vector<std::vector<NCollection_Vec2<float>, std::allocator<NCollection_Vec2<float>>>>(mod, "BVH_Array2f");
+py::bind_vector<std::vector<NCollection_Vec2<float>>>(mod, "BVH_Array2f");

 // TYPEDEF: BVH_ARRAY3F
-py::bind_vector<std::vector<NCollection_Vec3<float>, std::allocator<NCollection_Vec3<float>>>>(mod, "BVH_Array3f");
+py::bind_vector<std::vector<NCollection_Vec3<float>>>(mod, "BVH_Array3f");

 // TYPEDEF: BVH_ARRAY4F
-py::bind_vector<std::vector<NCollection_Vec4<float>, std::allocator<NCollection_Vec4<float>>>>(mod, "BVH_Array4f");
+py::bind_vector<std::vector<NCollection_Vec4<float>>>(mod, "BVH_Array4f");

 // TYPEDEF: BVH_VEC2D
 bind_NCollection_Vec2<double>(mod, "BVH_Vec2d", py::module_local(false));
@@ -107,13 +107,13 @@ bind_NCollection_Vec3<double>(mod, "BVH_Vec3d", py::module_local(false));
 bind_NCollection_Vec4<double>(mod, "BVH_Vec4d", py::module_local(false));

 // TYPEDEF: BVH_ARRAY2D
-py::bind_vector<std::vector<NCollection_Vec2<double>, std::allocator<NCollection_Vec2<double>>>>(mod, "BVH_Array2d");
+py::bind_vector<std::vector<NCollection_Vec2<double>>>(mod, "BVH_Array2d");

 // TYPEDEF: BVH_ARRAY3D
-py::bind_vector<std::vector<NCollection_Vec3<double>, std::allocator<NCollection_Vec3<double>>>>(mod, "BVH_Array3d");
+py::bind_vector<std::vector<NCollection_Vec3<double>>>(mod, "BVH_Array3d");

 // TYPEDEF: BVH_ARRAY4D
-py::bind_vector<std::vector<NCollection_Vec4<double>, std::allocator<NCollection_Vec4<double>>>>(mod, "BVH_Array4d");
+py::bind_vector<std::vector<NCollection_Vec4<double>>>(mod, "BVH_Array4d");

 // TYPEDEF: BVH_MAT4F
 bind_NCollection_Mat4<float>(mod, "BVH_Mat4f", py::module_local(false));
diff --git a/pyocct_src_ubuntu-latest_llvm11/BinMDF.cxx b/pyocct_src_ubuntu-latest_llvm12/BinMDF.cxx
index b9b4a90..b45a4a4 100644
--- a/pyocct_src_ubuntu-latest_llvm11/BinMDF.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/BinMDF.cxx
@@ -97,7 +97,7 @@ bind_NCollection_DataMap<opencascade::handle<Standard_Type>, opencascade::handle

 // TYPEDEF: BINMDF_TYPEIDMAP
 /*
-bind_NCollection_DoubleMap<opencascade::handle<Standard_Type>, int, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>, NCollection_DefaultHasher<int>>(mod, "BinMDF_TypeIdMap", py::module_local(false));
+bind_NCollection_DoubleMap<opencascade::handle<Standard_Type>, int, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "BinMDF_TypeIdMap", py::module_local(false));
 */

 // TYPEDEF: BINMDF_DOUBLEMAPITERATOROFTYPEIDMAP
diff --git a/pyocct_src_ubuntu-latest_llvm11/BinObjMgt.cxx b/pyocct_src_ubuntu-latest_llvm12/BinObjMgt.cxx
index b210b0f..71843f9 100644
--- a/pyocct_src_ubuntu-latest_llvm11/BinObjMgt.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/BinObjMgt.cxx
@@ -166,7 +166,7 @@ cls_BinObjMgt_RRelocationTable.def("Clear", [](BinObjMgt_RRelocationTable &self)
 cls_BinObjMgt_RRelocationTable.def("Clear", (void (BinObjMgt_RRelocationTable::*)(const Standard_Boolean)) &BinObjMgt_RRelocationTable::Clear, "None", py::arg("doReleaseMemory"));

 // TYPEDEF: BINOBJMGT_SRELOCATIONTABLE
-bind_NCollection_IndexedMap<opencascade::handle<Standard_Transient>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "BinObjMgt_SRelocationTable", py::module_local());
+bind_NCollection_IndexedMap<opencascade::handle<Standard_Transient>>(mod, "BinObjMgt_SRelocationTable", py::module_local());

 }
diff --git a/pyocct_src_ubuntu-latest_llvm11/CDM.cxx b/pyocct_src_ubuntu-latest_llvm12/CDM.cxx
index 4c91e1e..a5a8039 100644
--- a/pyocct_src_ubuntu-latest_llvm11/CDM.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/CDM.cxx
@@ -216,14 +216,14 @@ bind_NCollection_TListIterator<opencascade::handle<CDM_Document>>(mod, "CDM_List
 bind_NCollection_DefaultHasher<opencascade::handle<CDM_Document>>(mod, "CDM_DocumentHasher", py::module_local(false));

 // TYPEDEF: CDM_MAPOFDOCUMENT
-bind_NCollection_Map<opencascade::handle<CDM_Document>, NCollection_DefaultHasher<opencascade::handle<CDM_Document>>>(mod, "CDM_MapOfDocument", py::module_local(false));
+bind_NCollection_Map<opencascade::handle<CDM_Document>>(mod, "CDM_MapOfDocument", py::module_local(false));

 // TYPEDEF: CDM_MAPITERATOROFMAPOFDOCUMENT
 py::class_<typename NCollection_Map<opencascade::handle<CDM_Document>, NCollection_DefaultHasher<opencascade::handle<CDM_Document>>>::Iterator, NCollection_BaseMap::Iterator> cls_NCollection_Map_CDM_MapIteratorOfMapOfDocument(mod, "CDM_MapIteratorOfMapOfDocument", "Implementation of the Iterator interface.");

 // Constructors
 cls_NCollection_Map_CDM_MapIteratorOfMapOfDocument.def(py::init<>());
-cls_NCollection_Map_CDM_MapIteratorOfMapOfDocument.def(py::init<const NCollection_Map<opencascade::handle<CDM_Document>, NCollection_DefaultHasher<opencascade::handle<CDM_Document>>> &>(), py::arg("theMap"));
+cls_NCollection_Map_CDM_MapIteratorOfMapOfDocument.def(py::init<const NCollection_Map<opencascade::handle<CDM_Document>> &>(), py::arg("theMap"));

 // Methods
 cls_NCollection_Map_CDM_MapIteratorOfMapOfDocument.def("More", (Standard_Boolean (NCollection_Map<opencascade::handle<CDM_Document>, NCollection_DefaultHasher<opencascade::handle<CDM_Document>>>::Iterator::*)() const) &NCollection_Map<opencascade::handle<CDM_Document>, NCollection_DefaultHasher<opencascade::handle<CDM_Document>>>::Iterator::More, "Query if the end of collection is reached by iterator");
diff --git a/pyocct_src_ubuntu-latest_llvm11/ChFiKPart.cxx b/pyocct_src_ubuntu-latest_llvm12/ChFiKPart.cxx
index 2446206..05808cb 100644
--- a/pyocct_src_ubuntu-latest_llvm11/ChFiKPart.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/ChFiKPart.cxx
@@ -67,7 +67,7 @@ cls_ChFiKPart_ComputeData.def_static("ComputeCorner_", (Standard_Boolean (*)(Top
 cls_ChFiKPart_ComputeData.def_static("ComputeCorner_", (Standard_Boolean (*)(TopOpeBRepDS_DataStructure &, const opencascade::handle<ChFiDS_SurfData> &, const opencascade::handle<Adaptor3d_HSurface> &, const opencascade::handle<Adaptor3d_HSurface> &, const opencascade::handle<Adaptor3d_HSurface> &, const TopAbs_Orientation, const TopAbs_Orientation, const TopAbs_Orientation, const TopAbs_Orientation, const Standard_Real)) &ChFiKPart_ComputeData::ComputeCorner, "Computes a toric corner rotule.", py::arg("DStr"), py::arg("Data"), py::arg("S"), py::arg("S1"), py::arg("S2"), py::arg("OfS"), py::arg("OS"), py::arg("OS1"), py::arg("OS2"), py::arg("Radius"));

 // TYPEDEF: CHFIKPART_RSTMAP
-bind_NCollection_DataMap<int, opencascade::handle<Adaptor2d_HCurve2d>, NCollection_DefaultHasher<int>>(mod, "ChFiKPart_RstMap", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<Adaptor2d_HCurve2d>>(mod, "ChFiKPart_RstMap", py::module_local(false));

 // TYPEDEF: CHFIKPART_DATAMAPITERATOROFRSTMAP

diff --git a/pyocct_src_ubuntu-latest_llvm11/Geom2dHatch.cxx b/pyocct_src_ubuntu-latest_llvm12/Geom2dHatch.cxx
index 4a2b800..11e2870 100644
--- a/pyocct_src_ubuntu-latest_llvm11/Geom2dHatch.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/Geom2dHatch.cxx
@@ -151,14 +151,14 @@ cls_Geom2dHatch_Element.def("Orientation", (void (Geom2dHatch_Element::*)(const
 cls_Geom2dHatch_Element.def("Orientation", (TopAbs_Orientation (Geom2dHatch_Element::*)() const) &Geom2dHatch_Element::Orientation, "Returns the orientation of the element.");

 // TYPEDEF: GEOM2DHATCH_MAPOFELEMENTS
-bind_NCollection_DataMap<int, Geom2dHatch_Element, NCollection_DefaultHasher<int>>(mod, "Geom2dHatch_MapOfElements", py::module_local(false));
+bind_NCollection_DataMap<int, Geom2dHatch_Element>(mod, "Geom2dHatch_MapOfElements", py::module_local(false));

 // TYPEDEF: GEOM2DHATCH_DATAMAPITERATOROFMAPOFELEMENTS
 py::class_<typename NCollection_DataMap<int, Geom2dHatch_Element, NCollection_DefaultHasher<int>>::Iterator, NCollection_BaseMap::Iterator> cls_NCollection_DataMap_Geom2dHatch_DataMapIteratorOfMapOfElements(mod, "Geom2dHatch_DataMapIteratorOfMapOfElements", "None");

 // Constructors
 cls_NCollection_DataMap_Geom2dHatch_DataMapIteratorOfMapOfElements.def(py::init<>());
-cls_NCollection_DataMap_Geom2dHatch_DataMapIteratorOfMapOfElements.def(py::init<const NCollection_DataMap<int, Geom2dHatch_Element, NCollection_DefaultHasher<int>> &>(), py::arg("theMap"));
+cls_NCollection_DataMap_Geom2dHatch_DataMapIteratorOfMapOfElements.def(py::init<const NCollection_DataMap<int, Geom2dHatch_Element> &>(), py::arg("theMap"));

 // Methods
 cls_NCollection_DataMap_Geom2dHatch_DataMapIteratorOfMapOfElements.def("More", (Standard_Boolean (NCollection_DataMap<int, Geom2dHatch_Element, NCollection_DefaultHasher<int>>::Iterator::*)() const) &NCollection_DataMap<int, Geom2dHatch_Element, NCollection_DefaultHasher<int>>::Iterator::More, "Query if the end of collection is reached by iterator");
@@ -241,7 +241,7 @@ cls_Geom2dHatch_Hatching.def("ClrDomains", (void (Geom2dHatch_Hatching::*)()) &G
 cls_Geom2dHatch_Hatching.def("ClassificationPoint", (gp_Pnt2d (Geom2dHatch_Hatching::*)() const) &Geom2dHatch_Hatching::ClassificationPoint, "Returns a point on the curve. This point will be used for the classification.");

 // TYPEDEF: GEOM2DHATCH_HATCHINGS
-bind_NCollection_DataMap<int, Geom2dHatch_Hatching, NCollection_DefaultHasher<int>>(mod, "Geom2dHatch_Hatchings", py::module_local(false));
+bind_NCollection_DataMap<int, Geom2dHatch_Hatching>(mod, "Geom2dHatch_Hatchings", py::module_local(false));

 // TYPEDEF: GEOM2DHATCH_DATAMAPITERATOROFHATCHINGS

diff --git a/pyocct_src_ubuntu-latest_llvm11/Graphic3d.cxx b/pyocct_src_ubuntu-latest_llvm12/Graphic3d.cxx
index ccd6f63..c1bb008 100644
--- a/pyocct_src_ubuntu-latest_llvm11/Graphic3d.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/Graphic3d.cxx
@@ -1538,7 +1538,7 @@ cls_Graphic3d_AspectMarker3d.def("GetMarkerImage", (const opencascade::handle<Gr
 cls_Graphic3d_AspectMarker3d.def("SetBitMap", (void (Graphic3d_AspectMarker3d::*)(const Standard_Integer, const Standard_Integer, const opencascade::handle<TColStd_HArray1OfByte> &)) &Graphic3d_AspectMarker3d::SetBitMap, "None", py::arg("theWidth"), py::arg("theHeight"), py::arg("theTexture"));

 // TYPEDEF: GRAPHIC3D_MAPOFASPECTSTOASPECTS
-bind_NCollection_DataMap<opencascade::handle<Graphic3d_Aspects>, opencascade::handle<Graphic3d_Aspects>, NCollection_DefaultHasher<opencascade::handle<Graphic3d_Aspects>>>(mod, "Graphic3d_MapOfAspectsToAspects", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<Graphic3d_Aspects>, opencascade::handle<Graphic3d_Aspects>>(mod, "Graphic3d_MapOfAspectsToAspects", py::module_local(false));

 // CLASS: GRAPHIC3D_VERTEX
 py::class_<Graphic3d_Vertex> cls_Graphic3d_Vertex(mod, "Graphic3d_Vertex", "This class represents a graphical 3D point.");
@@ -2122,7 +2122,7 @@ cls_Graphic3d_CStructure.def_static("get_type_descriptor_", (const opencascade::
 cls_Graphic3d_CStructure.def("DynamicType", (const opencascade::handle<Standard_Type> & (Graphic3d_CStructure::*)() const) &Graphic3d_CStructure::DynamicType, "None");

 // TYPEDEF: GRAPHIC3D_MAPOFSTRUCTURE
-bind_NCollection_Map<opencascade::handle<Graphic3d_Structure>, NCollection_DefaultHasher<opencascade::handle<Graphic3d_Structure>>>(mod, "Graphic3d_MapOfStructure", py::module_local(false));
+bind_NCollection_Map<opencascade::handle<Graphic3d_Structure>>(mod, "Graphic3d_MapOfStructure", py::module_local(false));

 // CLASS: GRAPHIC3D_STRUCTURE
 py::class_<Graphic3d_Structure, opencascade::handle<Graphic3d_Structure>, Standard_Transient> cls_Graphic3d_Structure(mod, "Graphic3d_Structure", "This class allows the definition a graphic object. This graphic structure can be displayed, erased, or highlighted. This graphic structure can be connected with another graphic structure.");
@@ -2417,7 +2417,7 @@ cls_Graphic3d_GraduatedTrihedron.def("SetValuesSize", (void (Graphic3d_Graduated

 // TYPEDEF: GRAPHIC3D_NMAPOFTRANSIENT
 /*
-bind_NCollection_Shared<NCollection_Map<const Standard_Transient *, NCollection_DefaultHasher<const Standard_Transient *>>, void>(mod, "Graphic3d_NMapOfTransient", py::module_local(false));
+bind_NCollection_Shared<NCollection_Map<const Standard_Transient *>, void>(mod, "Graphic3d_NMapOfTransient", py::module_local(false));
 */

 // CLASS: GRAPHIC3D_RENDERINGPARAMS
@@ -2766,10 +2766,10 @@ cls_Graphic3d_CView.def("DumpJson", [](Graphic3d_CView &self, Standard_OStream &
 cls_Graphic3d_CView.def("DumpJson", (void (Graphic3d_CView::*)(Standard_OStream &, Standard_Integer) const) &Graphic3d_CView::DumpJson, "Dumps the content of me into the stream", py::arg("theOStream"), py::arg("theDepth"));

 // TYPEDEF: GRAPHIC3D_MAPOFOBJECT
-bind_NCollection_DataMap<const Standard_Transient *, opencascade::handle<Graphic3d_ViewAffinity>, NCollection_DefaultHasher<const Standard_Transient *>>(mod, "Graphic3d_MapOfObject", py::module_local(false));
+bind_NCollection_DataMap<const Standard_Transient *, opencascade::handle<Graphic3d_ViewAffinity>>(mod, "Graphic3d_MapOfObject", py::module_local(false));

 // TYPEDEF: GRAPHIC3D_INDEXEDMAPOFVIEW
-bind_NCollection_IndexedMap<Graphic3d_CView *, NCollection_DefaultHasher<Graphic3d_CView *>>(mod, "Graphic3d_IndexedMapOfView", py::module_local(false));
+bind_NCollection_IndexedMap<Graphic3d_CView *>(mod, "Graphic3d_IndexedMapOfView", py::module_local(false));

 // CLASS: GRAPHIC3D_STRUCTUREMANAGER
 py::class_<Graphic3d_StructureManager, opencascade::handle<Graphic3d_StructureManager>, Standard_Transient> cls_Graphic3d_StructureManager(mod, "Graphic3d_StructureManager", "This class allows the definition of a manager to which the graphic objects are associated. It allows them to be globally manipulated. It defines the global attributes. Keywords: Structure, Structure Manager, Update Mode, Destroy, Highlight, Visible");
@@ -3312,7 +3312,7 @@ cls_Graphic3d_FrameStats.def("ChangeTimer", (Standard_Real & (Graphic3d_FrameSta
 cls_Graphic3d_FrameStats.def("ActiveDataFrame", (Graphic3d_FrameStatsDataTmp & (Graphic3d_FrameStats::*)()) &Graphic3d_FrameStats::ActiveDataFrame, "Returns currently filling data frame for modification, should be called between ::FrameStart() and ::FrameEnd() calls.");

 // TYPEDEF: GRAPHIC3D_MAPOFZLAYERSETTINGS
-bind_NCollection_DataMap<int, Graphic3d_ZLayerSettings, NCollection_DefaultHasher<int>>(mod, "Graphic3d_MapOfZLayerSettings", py::module_local(false));
+bind_NCollection_DataMap<int, Graphic3d_ZLayerSettings>(mod, "Graphic3d_MapOfZLayerSettings", py::module_local(false));

 // CLASS: GRAPHIC3D_GRAPHICDRIVER
 py::class_<Graphic3d_GraphicDriver, opencascade::handle<Graphic3d_GraphicDriver>, Standard_Transient> cls_Graphic3d_GraphicDriver(mod, "Graphic3d_GraphicDriver", "This class allows the definition of a graphic driver for 3d interface (currently only OpenGl driver is used).");
@@ -3362,10 +3362,10 @@ cls_Graphic3d_GroupDefinitionError.def_static("get_type_descriptor_", (const ope
 cls_Graphic3d_GroupDefinitionError.def("DynamicType", (const opencascade::handle<Standard_Type> & (Graphic3d_GroupDefinitionError::*)() const) &Graphic3d_GroupDefinitionError::DynamicType, "None");

 // TYPEDEF: GRAPHIC3D_INDEXEDMAPOFSTRUCTURE
-bind_NCollection_IndexedMap<const Graphic3d_CStructure *, NCollection_DefaultHasher<const Graphic3d_CStructure *>>(mod, "Graphic3d_IndexedMapOfStructure", py::module_local(false));
+bind_NCollection_IndexedMap<const Graphic3d_CStructure *>(mod, "Graphic3d_IndexedMapOfStructure", py::module_local(false));

 // TYPEDEF: GRAPHIC3D_ARRAYOFINDEXEDMAPOFSTRUCTURE
-bind_NCollection_Array1<NCollection_IndexedMap<const Graphic3d_CStructure *, NCollection_DefaultHasher<const Graphic3d_CStructure *>>>(mod, "Graphic3d_ArrayOfIndexedMapOfStructure", py::module_local(false));
+bind_NCollection_Array1<NCollection_IndexedMap<const Graphic3d_CStructure *>>(mod, "Graphic3d_ArrayOfIndexedMapOfStructure", py::module_local(false));

 // CLASS: GRAPHIC3D_LAYER
 /*
diff --git a/pyocct_src_ubuntu-latest_llvm11/IVtk.cxx b/pyocct_src_ubuntu-latest_llvm12/IVtk.cxx
index 5436437..bab1ff0 100644
--- a/pyocct_src_ubuntu-latest_llvm11/IVtk.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/IVtk.cxx
@@ -86,10 +86,10 @@ if (py::hasattr(mod, "IVtk_ShapeIdList")) {
 }

 // TYPEDEF: IVTK_SUBSHAPEMAP
-bind_NCollection_DataMap<long long, NCollection_List<long long>, NCollection_DefaultHasher<long long>>(mod, "IVtk_SubShapeMap", py::module_local(false));
+bind_NCollection_DataMap<long long, NCollection_List<long long>>(mod, "IVtk_SubShapeMap", py::module_local(false));

 // TYPEDEF: IVTK_IDTYPEMAP
-bind_NCollection_Map<long long, NCollection_DefaultHasher<long long>>(mod, "IVtk_IdTypeMap", py::module_local(false));
+bind_NCollection_Map<long long>(mod, "IVtk_IdTypeMap", py::module_local(false));

 // TYPEDEF: IVTK_PNT2DLIST
 bind_NCollection_List<gp_XY>(mod, "IVtk_Pnt2dList", py::module_local(false));
diff --git a/pyocct_src_ubuntu-latest_llvm11/Interface.cxx b/pyocct_src_ubuntu-latest_llvm12/Interface.cxx
index d63d565..0b91af2 100644
--- a/pyocct_src_ubuntu-latest_llvm11/Interface.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/Interface.cxx
@@ -185,7 +185,7 @@ bind_NCollection_Array1<opencascade::handle<TCollection_HAsciiString>>(mod, "Int
 bind_Define_HArray1<Interface_HArray1OfHAsciiString, Interface_Array1OfHAsciiString>(mod, "Interface_HArray1OfHAsciiString");

 // TYPEDEF: INTERFACE_DATAMAPOFTRANSIENTINTEGER
-bind_NCollection_DataMap<opencascade::handle<Standard_Transient>, int, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "Interface_DataMapOfTransientInteger", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<Standard_Transient>, int>(mod, "Interface_DataMapOfTransientInteger", py::module_local(false));

 // TYPEDEF: INTERFACE_DATAMAPITERATOROFDATAMAPOFTRANSIENTINTEGER

diff --git a/pyocct_src_ubuntu-latest_llvm11/MAT.cxx b/pyocct_src_ubuntu-latest_llvm12/MAT.cxx
index 73559a0..5f4df4c 100644
--- a/pyocct_src_ubuntu-latest_llvm11/MAT.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/MAT.cxx
@@ -138,7 +138,7 @@ cls_MAT_Node.def_static("get_type_descriptor_", (const opencascade::handle<Stand
 cls_MAT_Node.def("DynamicType", (const opencascade::handle<Standard_Type> & (MAT_Node::*)() const) &MAT_Node::DynamicType, "None");

 // TYPEDEF: MAT_DATAMAPOFINTEGERBASICELT
-bind_NCollection_DataMap<int, opencascade::handle<MAT_BasicElt>, NCollection_DefaultHasher<int>>(mod, "MAT_DataMapOfIntegerBasicElt", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<MAT_BasicElt>>(mod, "MAT_DataMapOfIntegerBasicElt", py::module_local(false));

 // TYPEDEF: MAT_DATAMAPITERATOROFDATAMAPOFINTEGERBASICELT

@@ -183,17 +183,17 @@ cls_MAT_Bisector.def_static("get_type_descriptor_", (const opencascade::handle<S
 cls_MAT_Bisector.def("DynamicType", (const opencascade::handle<Standard_Type> & (MAT_Bisector::*)() const) &MAT_Bisector::DynamicType, "None");

 // TYPEDEF: MAT_DATAMAPOFINTEGERBISECTOR
-bind_NCollection_DataMap<int, opencascade::handle<MAT_Bisector>, NCollection_DefaultHasher<int>>(mod, "MAT_DataMapOfIntegerBisector", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<MAT_Bisector>>(mod, "MAT_DataMapOfIntegerBisector", py::module_local(false));

 // TYPEDEF: MAT_DATAMAPITERATOROFDATAMAPOFINTEGERBISECTOR

 // TYPEDEF: MAT_DATAMAPOFINTEGERARC
-bind_NCollection_DataMap<int, opencascade::handle<MAT_Arc>, NCollection_DefaultHasher<int>>(mod, "MAT_DataMapOfIntegerArc", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<MAT_Arc>>(mod, "MAT_DataMapOfIntegerArc", py::module_local(false));

 // TYPEDEF: MAT_DATAMAPITERATOROFDATAMAPOFINTEGERARC

 // TYPEDEF: MAT_DATAMAPOFINTEGERNODE
-bind_NCollection_DataMap<int, opencascade::handle<MAT_Node>, NCollection_DefaultHasher<int>>(mod, "MAT_DataMapOfIntegerNode", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<MAT_Node>>(mod, "MAT_DataMapOfIntegerNode", py::module_local(false));

 // TYPEDEF: MAT_DATAMAPITERATOROFDATAMAPOFINTEGERNODE

diff --git a/pyocct_src_ubuntu-latest_llvm11/MAT2d.cxx b/pyocct_src_ubuntu-latest_llvm12/MAT2d.cxx
index e526b9a..9d20f31 100644
--- a/pyocct_src_ubuntu-latest_llvm11/MAT2d.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/MAT2d.cxx
@@ -83,17 +83,17 @@ py::module::import("OCCT.Geom2d");
 py::module::import("OCCT.TColGeom2d");

 // TYPEDEF: MAT2D_DATAMAPOFINTEGERBISEC
-bind_NCollection_DataMap<int, Bisector_Bisec, NCollection_DefaultHasher<int>>(mod, "MAT2d_DataMapOfIntegerBisec", py::module_local(false));
+bind_NCollection_DataMap<int, Bisector_Bisec>(mod, "MAT2d_DataMapOfIntegerBisec", py::module_local(false));

 // TYPEDEF: MAT2D_DATAMAPITERATOROFDATAMAPOFINTEGERBISEC

 // TYPEDEF: MAT2D_DATAMAPOFINTEGERPNT2D
-bind_NCollection_DataMap<int, gp_Pnt2d, NCollection_DefaultHasher<int>>(mod, "MAT2d_DataMapOfIntegerPnt2d", py::module_local(false));
+bind_NCollection_DataMap<int, gp_Pnt2d>(mod, "MAT2d_DataMapOfIntegerPnt2d", py::module_local(false));

 // TYPEDEF: MAT2D_DATAMAPITERATOROFDATAMAPOFINTEGERPNT2D

 // TYPEDEF: MAT2D_DATAMAPOFINTEGERVEC2D
-bind_NCollection_DataMap<int, gp_Vec2d, NCollection_DefaultHasher<int>>(mod, "MAT2d_DataMapOfIntegerVec2d", py::module_local(false));
+bind_NCollection_DataMap<int, gp_Vec2d>(mod, "MAT2d_DataMapOfIntegerVec2d", py::module_local(false));

 // TYPEDEF: MAT2D_DATAMAPITERATOROFDATAMAPOFINTEGERVEC2D

@@ -216,7 +216,7 @@ cls_MAT2d_Connexion.def("DynamicType", (const opencascade::handle<Standard_Type>
 bind_NCollection_Array2<opencascade::handle<MAT2d_Connexion>>(mod, "MAT2d_Array2OfConnexion", py::module_local(false));

 // TYPEDEF: MAT2D_DATAMAPOFINTEGERCONNEXION
-bind_NCollection_DataMap<int, opencascade::handle<MAT2d_Connexion>, NCollection_DefaultHasher<int>>(mod, "MAT2d_DataMapOfIntegerConnexion", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<MAT2d_Connexion>>(mod, "MAT2d_DataMapOfIntegerConnexion", py::module_local(false));

 // TYPEDEF: MAT2D_DATAMAPITERATOROFDATAMAPOFINTEGERCONNEXION

@@ -273,7 +273,7 @@ cls_MAT2d_CutCurve.def("NbCurves", (Standard_Integer (MAT2d_CutCurve::*)() const
 cls_MAT2d_CutCurve.def("Value", (opencascade::handle<Geom2d_TrimmedCurve> (MAT2d_CutCurve::*)(const Standard_Integer) const) &MAT2d_CutCurve::Value, "Returns the Indexth curve. raises if Index not in the range [1,NbCurves()]", py::arg("Index"));

 // TYPEDEF: MAT2D_DATAMAPOFINTEGERSEQUENCEOFCONNEXION
-bind_NCollection_DataMap<int, NCollection_Sequence<opencascade::handle<MAT2d_Connexion>>, NCollection_DefaultHasher<int>>(mod, "MAT2d_DataMapOfIntegerSequenceOfConnexion", py::module_local(false));
+bind_NCollection_DataMap<int, NCollection_Sequence<opencascade::handle<MAT2d_Connexion>>>(mod, "MAT2d_DataMapOfIntegerSequenceOfConnexion", py::module_local(false));

 // TYPEDEF: MAT2D_DATAMAPITERATOROFDATAMAPOFINTEGERSEQUENCEOFCONNEXION

diff --git a/pyocct_src_ubuntu-latest_llvm11/MeshVS.cxx b/pyocct_src_ubuntu-latest_llvm12/MeshVS.cxx
index 1a89859..98c8f37 100644
--- a/pyocct_src_ubuntu-latest_llvm11/MeshVS.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/MeshVS.cxx
@@ -301,7 +301,7 @@ cls_MeshVS_PrsBuilder.def("DynamicType", (const opencascade::handle<Standard_Typ
 bind_NCollection_Sequence<opencascade::handle<MeshVS_PrsBuilder>>(mod, "MeshVS_SequenceOfPrsBuilder", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPOFINTEGEROWNER
-bind_NCollection_DataMap<int, opencascade::handle<SelectMgr_EntityOwner>, NCollection_DefaultHasher<int>>(mod, "MeshVS_DataMapOfIntegerOwner", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<SelectMgr_EntityOwner>>(mod, "MeshVS_DataMapOfIntegerOwner", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFINTEGEROWNER

@@ -375,32 +375,32 @@ cls_MeshVS_CommonSensitiveEntity.def("CenterOfGeometry", (gp_Pnt (MeshVS_CommonS
 cls_MeshVS_CommonSensitiveEntity.def("GetConnected", (opencascade::handle<Select3D_SensitiveEntity> (MeshVS_CommonSensitiveEntity::*)()) &MeshVS_CommonSensitiveEntity::GetConnected, "Create a copy.");

 // TYPEDEF: MESHVS_DATAMAPOFCOLORMAPOFINTEGER
-bind_NCollection_DataMap<Quantity_Color, NCollection_Map<int, NCollection_DefaultHasher<int>>, Quantity_ColorHasher>(mod, "MeshVS_DataMapOfColorMapOfInteger", py::module_local(false));
+bind_NCollection_DataMap<Quantity_Color, NCollection_Map<int>, Quantity_ColorHasher>(mod, "MeshVS_DataMapOfColorMapOfInteger", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFCOLORMAPOFINTEGER

 // TYPEDEF: MESHVS_DATAMAPOFHARRAY1OFSEQUENCEOFINTEGER
-bind_NCollection_DataMap<int, opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>, NCollection_DefaultHasher<int>>(mod, "MeshVS_DataMapOfHArray1OfSequenceOfInteger", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>>(mod, "MeshVS_DataMapOfHArray1OfSequenceOfInteger", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFHARRAY1OFSEQUENCEOFINTEGER

 // TYPEDEF: MESHVS_DATAMAPOFINTEGERASCIISTRING
-bind_NCollection_DataMap<int, TCollection_AsciiString, NCollection_DefaultHasher<int>>(mod, "MeshVS_DataMapOfIntegerAsciiString", py::module_local(false));
+bind_NCollection_DataMap<int, TCollection_AsciiString>(mod, "MeshVS_DataMapOfIntegerAsciiString", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFINTEGERASCIISTRING

 // TYPEDEF: MESHVS_DATAMAPOFINTEGERBOOLEAN
-bind_NCollection_DataMap<int, bool, NCollection_DefaultHasher<int>>(mod, "MeshVS_DataMapOfIntegerBoolean", py::module_local(false));
+bind_NCollection_DataMap<int, bool>(mod, "MeshVS_DataMapOfIntegerBoolean", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFINTEGERBOOLEAN

 // TYPEDEF: MESHVS_DATAMAPOFINTEGERCOLOR
-bind_NCollection_DataMap<int, Quantity_Color, NCollection_DefaultHasher<int>>(mod, "MeshVS_DataMapOfIntegerColor", py::module_local(false));
+bind_NCollection_DataMap<int, Quantity_Color>(mod, "MeshVS_DataMapOfIntegerColor", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFINTEGERCOLOR

 // TYPEDEF: MESHVS_DATAMAPOFINTEGERMATERIAL
-bind_NCollection_DataMap<int, Graphic3d_MaterialAspect, NCollection_DefaultHasher<int>>(mod, "MeshVS_DataMapOfIntegerMaterial", py::module_local(false));
+bind_NCollection_DataMap<int, Graphic3d_MaterialAspect>(mod, "MeshVS_DataMapOfIntegerMaterial", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFINTEGERMATERIAL

@@ -430,7 +430,7 @@ cls_MeshVS_MeshEntityOwner.def_static("get_type_descriptor_", (const opencascade
 cls_MeshVS_MeshEntityOwner.def("DynamicType", (const opencascade::handle<Standard_Type> & (MeshVS_MeshEntityOwner::*)() const) &MeshVS_MeshEntityOwner::DynamicType, "None");

 // TYPEDEF: MESHVS_DATAMAPOFINTEGERMESHENTITYOWNER
-bind_NCollection_DataMap<int, opencascade::handle<MeshVS_MeshEntityOwner>, NCollection_DefaultHasher<int>>(mod, "MeshVS_DataMapOfIntegerMeshEntityOwner", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<MeshVS_MeshEntityOwner>>(mod, "MeshVS_DataMapOfIntegerMeshEntityOwner", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFINTEGERMESHENTITYOWNER

@@ -451,12 +451,12 @@ cls_MeshVS_TwoColors.def_readwrite("b2", &b2, "None");
 */

 // TYPEDEF: MESHVS_DATAMAPOFINTEGERTWOCOLORS
-bind_NCollection_DataMap<int, MeshVS_TwoColors, NCollection_DefaultHasher<int>>(mod, "MeshVS_DataMapOfIntegerTwoColors", py::module_local(false));
+bind_NCollection_DataMap<int, MeshVS_TwoColors>(mod, "MeshVS_DataMapOfIntegerTwoColors", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFINTEGERTWOCOLORS

 // TYPEDEF: MESHVS_DATAMAPOFINTEGERVECTOR
-bind_NCollection_DataMap<int, gp_Vec, NCollection_DefaultHasher<int>>(mod, "MeshVS_DataMapOfIntegerVector", py::module_local(false));
+bind_NCollection_DataMap<int, gp_Vec>(mod, "MeshVS_DataMapOfIntegerVector", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFINTEGERVECTOR

@@ -464,7 +464,7 @@ bind_NCollection_DataMap<int, gp_Vec, NCollection_DefaultHasher<int>>(mod, "Mesh
 bind_NCollection_DefaultHasher<MeshVS_TwoColors>(mod, "MeshVS_TwoColorsHasher", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPOFTWOCOLORSMAPOFINTEGER
-bind_NCollection_DataMap<MeshVS_TwoColors, NCollection_Map<int, NCollection_DefaultHasher<int>>, NCollection_DefaultHasher<MeshVS_TwoColors>>(mod, "MeshVS_DataMapOfTwoColorsMapOfInteger", py::module_local(false));
+bind_NCollection_DataMap<MeshVS_TwoColors, NCollection_Map<int>>(mod, "MeshVS_DataMapOfTwoColorsMapOfInteger", py::module_local(false));

 // TYPEDEF: MESHVS_DATAMAPITERATOROFDATAMAPOFTWOCOLORSMAPOFINTEGER

@@ -600,7 +600,7 @@ cls_MeshVS_TwoNodes.def_readwrite("Second", &MeshVS_TwoNodes::Second, "None");
 bind_NCollection_DefaultHasher<MeshVS_TwoNodes>(mod, "MeshVS_TwoNodesHasher", py::module_local(false));

 // TYPEDEF: MESHVS_MAPOFTWONODES
-bind_NCollection_Map<MeshVS_TwoNodes, NCollection_DefaultHasher<MeshVS_TwoNodes>>(mod, "MeshVS_MapOfTwoNodes", py::module_local(false));
+bind_NCollection_Map<MeshVS_TwoNodes>(mod, "MeshVS_MapOfTwoNodes", py::module_local(false));

 // TYPEDEF: MESHVS_MAPITERATOROFMAPOFTWONODES

diff --git a/pyocct_src_ubuntu-latest_llvm11/OpenGl.cxx b/pyocct_src_ubuntu-latest_llvm12/OpenGl.cxx
index 7aec234..7a5b3f1 100644
--- a/pyocct_src_ubuntu-latest_llvm11/OpenGl.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/OpenGl.cxx
@@ -1662,7 +1662,7 @@ cls_OpenGl_Caps.def_static("get_type_descriptor_", (const opencascade::handle<St
 cls_OpenGl_Caps.def("DynamicType", (const opencascade::handle<Standard_Type> & (OpenGl_Caps::*)() const) &OpenGl_Caps::DynamicType, "None");

 // TYPEDEF: OPENGL_MAPOFHATCHSTYLESANDIDS
-bind_NCollection_DataMap<opencascade::handle<Graphic3d_HatchStyle>, unsigned int, NCollection_DefaultHasher<opencascade::handle<Graphic3d_HatchStyle>>>(mod, "OpenGl_MapOfHatchStylesAndIds", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<Graphic3d_HatchStyle>, unsigned int>(mod, "OpenGl_MapOfHatchStylesAndIds", py::module_local(false));

 // CLASS: OPENGL_LINEATTRIBUTES
 /*
@@ -2258,7 +2258,7 @@ bind_NCollection_Sequence<opencascade::handle<OpenGl_ShaderObject>>(mod, "OpenGl

 // TYPEDEF: OPENGL_SETTERLIST
 /*
-bind_NCollection_DataMap<unsigned long, OpenGl_SetterInterface *, NCollection_DefaultHasher<unsigned long>>(mod, "OpenGl_SetterList", py::module_local(false));
+bind_NCollection_DataMap<unsigned long, OpenGl_SetterInterface *>(mod, "OpenGl_SetterList", py::module_local(false));
 */

 // CLASS: OPENGL_VARIABLESETTERSELECTOR
@@ -3506,7 +3506,7 @@ cls_OpenGl_SetOfShaderPrograms.def("DynamicType", (const opencascade::handle<Sta
 cls_OpenGl_SetOfShaderPrograms.def("ChangeValue", (opencascade::handle<OpenGl_ShaderProgram> & (OpenGl_SetOfShaderPrograms::*)(Graphic3d_TypeOfShadingModel, Standard_Integer)) &OpenGl_SetOfShaderPrograms::ChangeValue, "Access program by index", py::arg("theShadingModel"), py::arg("theProgramBits"));

 // TYPEDEF: OPENGL_MAPOFSHADERPROGRAMS
-bind_NCollection_DataMap<TCollection_AsciiString, opencascade::handle<OpenGl_SetOfShaderPrograms>, NCollection_DefaultHasher<TCollection_AsciiString>>(mod, "OpenGl_MapOfShaderPrograms", py::module_local(false));
+bind_NCollection_DataMap<TCollection_AsciiString, opencascade::handle<OpenGl_SetOfShaderPrograms>>(mod, "OpenGl_MapOfShaderPrograms", py::module_local(false));

 // TYPEDEF: OPENGL_SHADERPROGRAMLIST
 bind_NCollection_Sequence<opencascade::handle<OpenGl_ShaderProgram>>(mod, "OpenGl_ShaderProgramList", py::module_local(false));
diff --git a/pyocct_src_ubuntu-latest_llvm11/Select3D.cxx b/pyocct_src_ubuntu-latest_llvm12/Select3D.cxx
index 3c33259..4eefdcc 100644
--- a/pyocct_src_ubuntu-latest_llvm11/Select3D.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/Select3D.cxx
@@ -246,7 +246,7 @@ bind_NCollection_Sequence<opencascade::handle<Select3D_SensitiveEntity>>(mod, "S
 // TYPEDEF: SELECT3D_ENTITYSEQUENCEITER

 // TYPEDEF: SELECT3D_INDEXEDMAPOFENTITY
-bind_NCollection_IndexedMap<opencascade::handle<Select3D_SensitiveEntity>, NCollection_DefaultHasher<opencascade::handle<Select3D_SensitiveEntity>>>(mod, "Select3D_IndexedMapOfEntity", py::module_local(false));
+bind_NCollection_IndexedMap<opencascade::handle<Select3D_SensitiveEntity>>(mod, "Select3D_IndexedMapOfEntity", py::module_local(false));

 // CLASS: SELECT3D_PNT
 py::class_<Select3D_Pnt> cls_Select3D_Pnt(mod, "Select3D_Pnt", "None");
diff --git a/pyocct_src_ubuntu-latest_llvm11/SelectMgr.cxx b/pyocct_src_ubuntu-latest_llvm12/SelectMgr.cxx
index c3745cf..bf890be 100644
--- a/pyocct_src_ubuntu-latest_llvm11/SelectMgr.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/SelectMgr.cxx
@@ -222,7 +222,7 @@ py::enum_<SelectMgr_TypeOfDepthTolerance>(mod, "SelectMgr_TypeOfDepthTolerance",

 // TYPEDEF: SELECTMGR_INDEXEDMAPOFOWNER
 /*
-bind_NCollection_Shared<NCollection_IndexedMap<opencascade::handle<SelectMgr_EntityOwner>, NCollection_DefaultHasher<opencascade::handle<SelectMgr_EntityOwner>>>, void>(mod, "SelectMgr_IndexedMapOfOwner", py::module_local(false));
+bind_NCollection_Shared<NCollection_IndexedMap<opencascade::handle<SelectMgr_EntityOwner>>, void>(mod, "SelectMgr_IndexedMapOfOwner", py::module_local(false));
 */

 // TYPEDEF: SELECTMGR_VEC3
@@ -731,12 +731,12 @@ cls_SelectMgr_BVHThreadPool.def("WaitThreads", (void (SelectMgr_BVHThreadPool::*
 cls_SelectMgr_BVHThreadPool.def("Threads", (NCollection_Array1<SelectMgr_BVHThreadPool::BVHThread> & (SelectMgr_BVHThreadPool::*)()) &SelectMgr_BVHThreadPool::Threads, "Returns array of threads");

 // TYPEDEF: SELECTMGR_MAPOFOBJECTSENSITIVES
-bind_NCollection_DataMap<opencascade::handle<SelectMgr_SelectableObject>, opencascade::handle<SelectMgr_SensitiveEntitySet>, NCollection_DefaultHasher<opencascade::handle<SelectMgr_SelectableObject>>>(mod, "SelectMgr_MapOfObjectSensitives", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<SelectMgr_SelectableObject>, opencascade::handle<SelectMgr_SensitiveEntitySet>>(mod, "SelectMgr_MapOfObjectSensitives", py::module_local(false));

 // TYPEDEF: SELECTMGR_MAPOFOBJECTSENSITIVESITERATOR

 // TYPEDEF: SELECTMGR_FRUSTUMCACHE
-bind_NCollection_DataMap<int, SelectMgr_SelectingVolumeManager, NCollection_DefaultHasher<int>>(mod, "SelectMgr_FrustumCache", py::module_local(false));
+bind_NCollection_DataMap<int, SelectMgr_SelectingVolumeManager>(mod, "SelectMgr_FrustumCache", py::module_local(false));

 // CLASS: SELECTMGR_VIEWERSELECTOR
 py::class_<SelectMgr_ViewerSelector, opencascade::handle<SelectMgr_ViewerSelector>, Standard_Transient> cls_SelectMgr_ViewerSelector(mod, "SelectMgr_ViewerSelector", "A framework to define finding, sorting the sensitive primitives in a view. Services are also provided to define the return of the owners of those primitives selected. The primitives are sorted by criteria such as priority of the primitive or its depth in the view relative to that of other primitives. Note that in 3D, the inheriting framework StdSelect_ViewerSelector3d is only to be used if you do not want to use the services provided by AIS. Two tools are available to find and select objects found at a given position in the view. If you want to select the owners of all the objects detected at point x,y,z you use the Init - More - Next - Picked loop. If, on the other hand, you want to select only one object detected at that point, you use the Init - More - OnePicked loop. In this iteration, More is used to see if an object was picked and OnePicked, to get the object closest to the pick position. Viewer selectors are driven by SelectMgr_SelectionManager, and manipulate the SelectMgr_Selection objects given to them by the selection manager.");
@@ -901,7 +901,7 @@ cls_SelectMgr_SelectionManager.def("SetSelectionSensitivity", (void (SelectMgr_S
 cls_SelectMgr_SelectionManager.def("UpdateSelection", (void (SelectMgr_SelectionManager::*)(const opencascade::handle<SelectMgr_SelectableObject> &)) &SelectMgr_SelectionManager::UpdateSelection, "Re-adds selectable object in BVHs in all viewer selectors.", py::arg("theObj"));

 // TYPEDEF: SELECTMGR_INDEXEDMAPOFHSENSITIVE
-bind_NCollection_IndexedMap<opencascade::handle<SelectMgr_SensitiveEntity>, NCollection_DefaultHasher<opencascade::handle<SelectMgr_SensitiveEntity>>>(mod, "SelectMgr_IndexedMapOfHSensitive", py::module_local(false));
+bind_NCollection_IndexedMap<opencascade::handle<SelectMgr_SensitiveEntity>>(mod, "SelectMgr_IndexedMapOfHSensitive", py::module_local(false));

 // CLASS: SELECTMGR_SENSITIVEENTITYSET
 py::class_<SelectMgr_SensitiveEntitySet, opencascade::handle<SelectMgr_SensitiveEntitySet>, BVH_PrimitiveSet3d> cls_SelectMgr_SensitiveEntitySet(mod, "SelectMgr_SensitiveEntitySet", "This class is used to store all calculated sensitive entites of one selectable object. It provides an interface for building BVH tree which is used to speed-up the performance of searching for overlap among sensitives of one selectable object");
diff --git a/pyocct_src_ubuntu-latest_llvm11/ShapeExtend.cxx b/pyocct_src_ubuntu-latest_llvm12/ShapeExtend.cxx
index 7e8c67d..4d3231a 100644
--- a/pyocct_src_ubuntu-latest_llvm11/ShapeExtend.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/ShapeExtend.cxx
@@ -291,7 +291,7 @@ bind_NCollection_DataMap<TopoDS_Shape, NCollection_List<Message_Msg>, TopTools_S
 // TYPEDEF: SHAPEEXTEND_DATAMAPITERATOROFDATAMAPOFSHAPELISTOFMSG

 // TYPEDEF: SHAPEEXTEND_DATAMAPOFTRANSIENTLISTOFMSG
-bind_NCollection_DataMap<opencascade::handle<Standard_Transient>, NCollection_List<Message_Msg>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "ShapeExtend_DataMapOfTransientListOfMsg", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<Standard_Transient>, NCollection_List<Message_Msg>>(mod, "ShapeExtend_DataMapOfTransientListOfMsg", py::module_local(false));

 // TYPEDEF: SHAPEEXTEND_DATAMAPITERATOROFDATAMAPOFTRANSIENTLISTOFMSG

diff --git a/pyocct_src_ubuntu-latest_llvm11/Standard.cxx b/pyocct_src_ubuntu-latest_llvm12/Standard.cxx
index 2577289..3b74a54 100644
--- a/pyocct_src_ubuntu-latest_llvm11/Standard.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/Standard.cxx
@@ -492,7 +492,7 @@ cls_Standard_Type.def("DynamicType", (const opencascade::handle<Standard_Type> &

 // TYPEDEF: STANDARD_SSTREAM
 /*
-bind_std::__cxx11::basic_stringstream<char>(mod, "Standard_SStream", py::module_local(false));
+bind_std::basic_stringstream<char>(mod, "Standard_SStream", py::module_local(false));
 */

 // CLASS: STANDARD_FAILURE
diff --git a/pyocct_src_ubuntu-latest_llvm11/StdObjMgt.cxx b/pyocct_src_ubuntu-latest_llvm12/StdObjMgt.cxx
index 9f09e36..c26b4a0 100644
--- a/pyocct_src_ubuntu-latest_llvm11/StdObjMgt.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/StdObjMgt.cxx
@@ -114,7 +114,7 @@ cls_StdObjMgt_WriteData.def("bits_left", (StdObjMgt_WriteData & (StdObjMgt_Write
 cls_StdObjMgt_WriteData.def("bits_left", (StdObjMgt_WriteData & (StdObjMgt_WriteData::*)(const Standard_ShortReal &)) &StdObjMgt_WriteData::operator<<, py::is_operator(), "None", py::arg("theValue"));

 // TYPEDEF: STDOBJMGT_TRANSIENTPERSISTENTMAP
-bind_NCollection_DataMap<opencascade::handle<Standard_Transient>, opencascade::handle<StdObjMgt_Persistent>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "StdObjMgt_TransientPersistentMap", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<Standard_Transient>, opencascade::handle<StdObjMgt_Persistent>>(mod, "StdObjMgt_TransientPersistentMap", py::module_local(false));

 // CLASS: STDOBJMGT_MAPOFINSTANTIATORS
 py::class_<StdObjMgt_MapOfInstantiators> cls_StdObjMgt_MapOfInstantiators(mod, "StdObjMgt_MapOfInstantiators", "None");
diff --git a/pyocct_src_ubuntu-latest_llvm11/TColStd.cxx b/pyocct_src_ubuntu-latest_llvm12/TColStd.cxx
index 2343d51..08430da 100644
--- a/pyocct_src_ubuntu-latest_llvm11/TColStd.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/TColStd.cxx
@@ -186,7 +186,7 @@ bind_NCollection_DefaultHasher<int>(mod, "TColStd_MapIntegerHasher", py::module_
 bind_NCollection_Sequence<TCollection_ExtendedString>(mod, "TColStd_SequenceOfExtendedString", py::module_local(false));

 // TYPEDEF: TCOLSTD_DATAMAPOFINTEGERLISTOFINTEGER
-bind_NCollection_DataMap<int, NCollection_List<int>, NCollection_DefaultHasher<int>>(mod, "TColStd_DataMapOfIntegerListOfInteger", py::module_local(false));
+bind_NCollection_DataMap<int, NCollection_List<int>>(mod, "TColStd_DataMapOfIntegerListOfInteger", py::module_local(false));

 // TYPEDEF: TCOLSTD_DATAMAPITERATOROFDATAMAPOFINTEGERLISTOFINTEGER

@@ -197,7 +197,7 @@ bind_NCollection_List<opencascade::handle<Standard_Transient>>(mod, "TColStd_Lis
 bind_NCollection_TListIterator<opencascade::handle<Standard_Transient>>(mod, "TColStd_ListIteratorOfListOfTransient", py::module_local(false));

 // TYPEDEF: TCOLSTD_MAPOFINTEGER
-bind_NCollection_Map<int, NCollection_DefaultHasher<int>>(mod, "TColStd_MapOfInteger", py::module_local(false));
+bind_NCollection_Map<int>(mod, "TColStd_MapOfInteger", py::module_local(false));

 // TYPEDEF: TCOLSTD_MAPITERATOROFMAPOFINTEGER

@@ -226,7 +226,7 @@ bind_NCollection_Sequence<TCollection_AsciiString>(mod, "TColStd_SequenceOfAscii
 bind_NCollection_Sequence<void *>(mod, "TColStd_SequenceOfAddress", py::module_local(false));

 // TYPEDEF: TCOLSTD_DATAMAPOFINTEGERTRANSIENT
-bind_NCollection_DataMap<int, opencascade::handle<Standard_Transient>, NCollection_DefaultHasher<int>>(mod, "TColStd_DataMapOfIntegerTransient", py::module_local(false));
+bind_NCollection_DataMap<int, opencascade::handle<Standard_Transient>>(mod, "TColStd_DataMapOfIntegerTransient", py::module_local(false));

 // TYPEDEF: TCOLSTD_DATAMAPITERATOROFDATAMAPOFINTEGERTRANSIENT

@@ -234,10 +234,10 @@ bind_NCollection_DataMap<int, opencascade::handle<Standard_Transient>, NCollecti
 bind_Define_HSequence<TColStd_HSequenceOfAsciiString, TColStd_SequenceOfAsciiString>(mod, "TColStd_HSequenceOfAsciiString");

 // TYPEDEF: TCOLSTD_INDEXEDMAPOFTRANSIENT
-bind_NCollection_IndexedMap<opencascade::handle<Standard_Transient>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "TColStd_IndexedMapOfTransient", py::module_local(false));
+bind_NCollection_IndexedMap<opencascade::handle<Standard_Transient>>(mod, "TColStd_IndexedMapOfTransient", py::module_local(false));

 // TYPEDEF: TCOLSTD_MAPOFTRANSIENT
-bind_NCollection_Map<opencascade::handle<Standard_Transient>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "TColStd_MapOfTransient", py::module_local(false));
+bind_NCollection_Map<opencascade::handle<Standard_Transient>>(mod, "TColStd_MapOfTransient", py::module_local(false));

 // TYPEDEF: TCOLSTD_MAPITERATOROFMAPOFTRANSIENT

@@ -247,7 +247,7 @@ bind_NCollection_DataMap<TCollection_AsciiString, int, TCollection_AsciiString>(
 // TYPEDEF: TCOLSTD_DATAMAPITERATOROFDATAMAPOFASCIISTRINGINTEGER

 // TYPEDEF: TCOLSTD_DATAMAPOFINTEGERINTEGER
-bind_NCollection_DataMap<int, int, NCollection_DefaultHasher<int>>(mod, "TColStd_DataMapOfIntegerInteger", py::module_local(false));
+bind_NCollection_DataMap<int, int>(mod, "TColStd_DataMapOfIntegerInteger", py::module_local(false));

 // TYPEDEF: TCOLSTD_DATAMAPITERATOROFDATAMAPOFINTEGERINTEGER

@@ -258,12 +258,12 @@ bind_NCollection_Array1<NCollection_List<int>>(mod, "TColStd_Array1OfListOfInteg
 bind_Define_HArray1<TColStd_HArray1OfListOfInteger, TColStd_Array1OfListOfInteger>(mod, "TColStd_HArray1OfListOfInteger");

 // TYPEDEF: TCOLSTD_DATAMAPOFINTEGERREAL
-bind_NCollection_DataMap<int, double, NCollection_DefaultHasher<int>>(mod, "TColStd_DataMapOfIntegerReal", py::module_local(false));
+bind_NCollection_DataMap<int, double>(mod, "TColStd_DataMapOfIntegerReal", py::module_local(false));

 // TYPEDEF: TCOLSTD_DATAMAPITERATOROFDATAMAPOFINTEGERREAL

 // TYPEDEF: TCOLSTD_INDEXEDMAPOFINTEGER
-bind_NCollection_IndexedMap<int, NCollection_DefaultHasher<int>>(mod, "TColStd_IndexedMapOfInteger", py::module_local(false));
+bind_NCollection_IndexedMap<int>(mod, "TColStd_IndexedMapOfInteger", py::module_local(false));

 // TYPEDEF: TCOLSTD_SEQUENCEOFBOOLEAN
 bind_NCollection_Sequence<bool>(mod, "TColStd_SequenceOfBoolean", py::module_local(false));
@@ -348,7 +348,7 @@ bind_NCollection_Map<TCollection_AsciiString, TCollection_AsciiString>(mod, "TCo
 bind_NCollection_Array2<bool>(mod, "TColStd_Array2OfBoolean", py::module_local(false));

 // TYPEDEF: TCOLSTD_INDEXEDDATAMAPOFTRANSIENTTRANSIENT
-bind_NCollection_IndexedDataMap<opencascade::handle<Standard_Transient>, opencascade::handle<Standard_Transient>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "TColStd_IndexedDataMapOfTransientTransient", py::module_local(false));
+bind_NCollection_IndexedDataMap<opencascade::handle<Standard_Transient>, opencascade::handle<Standard_Transient>>(mod, "TColStd_IndexedDataMapOfTransientTransient", py::module_local(false));

 // TYPEDEF: TCOLSTD_DATAMAPOFSTRINGINTEGER
 bind_NCollection_DataMap<TCollection_ExtendedString, int, TCollection_ExtendedString>(mod, "TColStd_DataMapOfStringInteger", py::module_local(false));
@@ -416,7 +416,7 @@ bind_NCollection_Array1<char>(mod, "TColStd_Array1OfCharacter", py::module_local
 bind_NCollection_Array2<char>(mod, "TColStd_Array2OfCharacter", py::module_local(false));

 // TYPEDEF: TCOLSTD_DATAMAPOFTRANSIENTTRANSIENT
-bind_NCollection_DataMap<opencascade::handle<Standard_Transient>, opencascade::handle<Standard_Transient>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "TColStd_DataMapOfTransientTransient", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<Standard_Transient>, opencascade::handle<Standard_Transient>>(mod, "TColStd_DataMapOfTransientTransient", py::module_local(false));

 // TYPEDEF: TCOLSTD_DATAMAPITERATOROFDATAMAPOFTRANSIENTTRANSIENT

@@ -436,10 +436,10 @@ bind_Define_HSequence<TColStd_HSequenceOfExtendedString, TColStd_SequenceOfExten
 bind_NCollection_DefaultHasher<double>(mod, "TColStd_MapRealHasher", py::module_local(false));

 // TYPEDEF: TCOLSTD_INDEXEDMAPOFREAL
-bind_NCollection_IndexedMap<double, NCollection_DefaultHasher<double>>(mod, "TColStd_IndexedMapOfReal", py::module_local(false));
+bind_NCollection_IndexedMap<double>(mod, "TColStd_IndexedMapOfReal", py::module_local(false));

 // TYPEDEF: TCOLSTD_MAPOFREAL
-bind_NCollection_Map<double, NCollection_DefaultHasher<double>>(mod, "TColStd_MapOfReal", py::module_local(false));
+bind_NCollection_Map<double>(mod, "TColStd_MapOfReal", py::module_local(false));

 // TYPEDEF: TCOLSTD_MAPITERATOROFMAPOFREAL

diff --git a/pyocct_src_ubuntu-latest_llvm11/TNaming.cxx b/pyocct_src_ubuntu-latest_llvm12/TNaming.cxx
index 0a50644..18ce709 100644
--- a/pyocct_src_ubuntu-latest_llvm11/TNaming.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/TNaming.cxx
@@ -476,7 +476,7 @@ bind_NCollection_TListIterator<NCollection_Map<TopoDS_Shape, TopTools_ShapeMapHa
 bind_NCollection_DefaultHasher<opencascade::handle<TNaming_NamedShape>>(mod, "TNaming_NamedShapeHasher", py::module_local(false));

 // TYPEDEF: TNAMING_MAPOFNAMEDSHAPE
-bind_NCollection_Map<opencascade::handle<TNaming_NamedShape>, NCollection_DefaultHasher<opencascade::handle<TNaming_NamedShape>>>(mod, "TNaming_MapOfNamedShape", py::module_local(false));
+bind_NCollection_Map<opencascade::handle<TNaming_NamedShape>>(mod, "TNaming_MapOfNamedShape", py::module_local(false));

 // TYPEDEF: TNAMING_MAPITERATOROFMAPOFNAMEDSHAPE

@@ -522,12 +522,12 @@ cls_TNaming_NamingTool.def_static("CurrentShapeFromShape_", (void (*)(const TDF_
 cls_TNaming_NamingTool.def_static("BuildDescendants_", (void (*)(const opencascade::handle<TNaming_NamedShape> &, TDF_LabelMap &)) &TNaming_NamingTool::BuildDescendants, "None", py::arg("NS"), py::arg("Labels"));

 // TYPEDEF: TNAMING_MAPOFSHAPE
-bind_NCollection_Map<TopoDS_Shape, NCollection_DefaultHasher<TopoDS_Shape>>(mod, "TNaming_MapOfShape", py::module_local(false));
+bind_NCollection_Map<TopoDS_Shape>(mod, "TNaming_MapOfShape", py::module_local(false));

 // TYPEDEF: TNAMING_MAPITERATOROFMAPOFSHAPE

 // TYPEDEF: TNAMING_DATAMAPOFSHAPEMAPOFSHAPE
-bind_NCollection_DataMap<TopoDS_Shape, NCollection_Map<TopoDS_Shape, NCollection_DefaultHasher<TopoDS_Shape>>, NCollection_DefaultHasher<TopoDS_Shape>>(mod, "TNaming_DataMapOfShapeMapOfShape", py::module_local(false));
+bind_NCollection_DataMap<TopoDS_Shape, NCollection_Map<TopoDS_Shape>>(mod, "TNaming_DataMapOfShapeMapOfShape", py::module_local(false));

 // TYPEDEF: TNAMING_DATAMAPITERATOROFDATAMAPOFSHAPEMAPOFSHAPE

diff --git a/pyocct_src_ubuntu-latest_llvm11/TObj.cxx b/pyocct_src_ubuntu-latest_llvm12/TObj.cxx
index 4a5031a..a733d22 100644
--- a/pyocct_src_ubuntu-latest_llvm11/TObj.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/TObj.cxx
@@ -230,13 +230,13 @@ py::enum_<TObj_Object::ObjectState>(cls_TObj_Object, "ObjectState", "enumeration
    .export_values();

 // TYPEDEF: TOBJ_DATAMAPOFNAMELABEL
-bind_NCollection_DataMap<opencascade::handle<TCollection_HExtendedString>, TDF_Label, NCollection_DefaultHasher<opencascade::handle<TCollection_HExtendedString>>>(mod, "TObj_DataMapOfNameLabel", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<TCollection_HExtendedString>, TDF_Label>(mod, "TObj_DataMapOfNameLabel", py::module_local(false));

 // TYPEDEF: TOBJ_DATAMAPOFOBJECTHSEQUENCEOCAFOBJECTS
-bind_NCollection_DataMap<opencascade::handle<TObj_Object>, opencascade::handle<TObj_HSequenceOfObject>, NCollection_DefaultHasher<opencascade::handle<TObj_Object>>>(mod, "TObj_DataMapOfObjectHSequenceOcafObjects", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<TObj_Object>, opencascade::handle<TObj_HSequenceOfObject>>(mod, "TObj_DataMapOfObjectHSequenceOcafObjects", py::module_local(false));

 // TYPEDEF: TOBJ_DATAMAPOFSTRINGPOINTER
-bind_NCollection_DataMap<TCollection_AsciiString, void *, NCollection_DefaultHasher<TCollection_AsciiString>>(mod, "TObj_DataMapOfStringPointer", py::module_local(false));
+bind_NCollection_DataMap<TCollection_AsciiString, void *>(mod, "TObj_DataMapOfStringPointer", py::module_local(false));

 // CLASS: TOBJ_PERSISTENCE
 py::class_<TObj_Persistence, std::unique_ptr<TObj_Persistence, py::nodelete>> cls_TObj_Persistence(mod, "TObj_Persistence", "This class is intended to be a root of tools (one per class) to manage persistence of objects inherited from TObj_Object It provides a mechanism to recover correctly typed objects (subtypes of TObj_Object) out of their persistent names");
diff --git a/pyocct_src_ubuntu-latest_llvm11/TopLoc.cxx b/pyocct_src_ubuntu-latest_llvm12/TopLoc.cxx
index 1724f95..322b2ae 100644
--- a/pyocct_src_ubuntu-latest_llvm11/TopLoc.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/TopLoc.cxx
@@ -161,10 +161,10 @@ cls_TopLoc_ItemLocation.def("DumpJson", (void (TopLoc_ItemLocation::*)(Standard_
 bind_NCollection_DefaultHasher<TopLoc_Location>(mod, "TopLoc_MapLocationHasher", py::module_local(false));

 // TYPEDEF: TOPLOC_INDEXEDMAPOFLOCATION
-bind_NCollection_IndexedMap<TopLoc_Location, NCollection_DefaultHasher<TopLoc_Location>>(mod, "TopLoc_IndexedMapOfLocation", py::module_local(false));
+bind_NCollection_IndexedMap<TopLoc_Location>(mod, "TopLoc_IndexedMapOfLocation", py::module_local(false));

 // TYPEDEF: TOPLOC_MAPOFLOCATION
-bind_NCollection_Map<TopLoc_Location, NCollection_DefaultHasher<TopLoc_Location>>(mod, "TopLoc_MapOfLocation", py::module_local(false));
+bind_NCollection_Map<TopLoc_Location>(mod, "TopLoc_MapOfLocation", py::module_local(false));

 // TYPEDEF: TOPLOC_MAPITERATOROFMAPOFLOCATION

diff --git a/pyocct_src_ubuntu-latest_llvm11/TopOpeBRepDS.cxx b/pyocct_src_ubuntu-latest_llvm12/TopOpeBRepDS.cxx
index 02af20f..a7dafdd 100644
--- a/pyocct_src_ubuntu-latest_llvm11/TopOpeBRepDS.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/TopOpeBRepDS.cxx
@@ -352,7 +352,7 @@ cls_TopOpeBRepDS_SurfaceData.def(py::init<const TopOpeBRepDS_Surface &>(), py::a
 // excluded // cls_TopOpeBRepDS_SurfaceData.def_static("operator delete_", (void (*)(void *, void *)) &TopOpeBRepDS_SurfaceData::operator delete, "None", py::arg(""), py::arg(""));

 // TYPEDEF: TOPOPEBREPDS_MAPOFSURFACE
-bind_NCollection_DataMap<int, TopOpeBRepDS_SurfaceData, NCollection_DefaultHasher<int>>(mod, "TopOpeBRepDS_MapOfSurface", py::module_local(false));
+bind_NCollection_DataMap<int, TopOpeBRepDS_SurfaceData>(mod, "TopOpeBRepDS_MapOfSurface", py::module_local(false));

 // TYPEDEF: TOPOPEBREPDS_DATAMAPITERATOROFMAPOFSURFACE

@@ -418,7 +418,7 @@ cls_TopOpeBRepDS_CurveData.def(py::init<const TopOpeBRepDS_Curve &>(), py::arg("
 // excluded // cls_TopOpeBRepDS_CurveData.def_static("operator delete_", (void (*)(void *, void *)) &TopOpeBRepDS_CurveData::operator delete, "None", py::arg(""), py::arg(""));

 // TYPEDEF: TOPOPEBREPDS_MAPOFCURVE
-bind_NCollection_DataMap<int, TopOpeBRepDS_CurveData, NCollection_DefaultHasher<int>>(mod, "TopOpeBRepDS_MapOfCurve", py::module_local(false));
+bind_NCollection_DataMap<int, TopOpeBRepDS_CurveData>(mod, "TopOpeBRepDS_MapOfCurve", py::module_local(false));

 // TYPEDEF: TOPOPEBREPDS_DATAMAPITERATOROFMAPOFCURVE

@@ -464,7 +464,7 @@ cls_TopOpeBRepDS_PointData.def("SetShapes", (void (TopOpeBRepDS_PointData::*)(co
 cls_TopOpeBRepDS_PointData.def("GetShapes", [](TopOpeBRepDS_PointData &self, Standard_Integer & I1, Standard_Integer & I2){ self.GetShapes(I1, I2); return std::tuple<Standard_Integer &, Standard_Integer &>(I1, I2); }, "None", py::arg("I1"), py::arg("I2"));

 // TYPEDEF: TOPOPEBREPDS_MAPOFPOINT
-bind_NCollection_DataMap<int, TopOpeBRepDS_PointData, NCollection_DefaultHasher<int>>(mod, "TopOpeBRepDS_MapOfPoint", py::module_local(false));
+bind_NCollection_DataMap<int, TopOpeBRepDS_PointData>(mod, "TopOpeBRepDS_MapOfPoint", py::module_local(false));

 // TYPEDEF: TOPOPEBREPDS_DATAMAPITERATOROFMAPOFPOINT

@@ -898,14 +898,14 @@ cls_TopOpeBRepDS.def_static("KindToShape_", (TopAbs_ShapeEnum (*)(const TopOpeBR
 cls_TopOpeBRepDS.def_static("ShapeToKind_", (TopOpeBRepDS_Kind (*)(const TopAbs_ShapeEnum)) &TopOpeBRepDS::ShapeToKind, "None", py::arg("S"));

 // TYPEDEF: TOPOPEBREPDS_DATAMAPOFINTEGERLISTOFINTERFERENCE
-bind_NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>, NCollection_DefaultHasher<int>>(mod, "TopOpeBRepDS_DataMapOfIntegerListOfInterference", py::module_local(false));
+bind_NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>>(mod, "TopOpeBRepDS_DataMapOfIntegerListOfInterference", py::module_local(false));

 // TYPEDEF: TOPOPEBREPDS_DATAMAPITERATOROFDATAMAPOFINTEGERLISTOFINTERFERENCE
 py::class_<typename NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>, NCollection_DefaultHasher<int>>::Iterator, NCollection_BaseMap::Iterator> cls_NCollection_DataMap_TopOpeBRepDS_DataMapIteratorOfDataMapOfIntegerListOfInterference(mod, "TopOpeBRepDS_DataMapIteratorOfDataMapOfIntegerListOfInterference", "None");

 // Constructors
 cls_NCollection_DataMap_TopOpeBRepDS_DataMapIteratorOfDataMapOfIntegerListOfInterference.def(py::init<>());
-cls_NCollection_DataMap_TopOpeBRepDS_DataMapIteratorOfDataMapOfIntegerListOfInterference.def(py::init<const NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>, NCollection_DefaultHasher<int>> &>(), py::arg("theMap"));
+cls_NCollection_DataMap_TopOpeBRepDS_DataMapIteratorOfDataMapOfIntegerListOfInterference.def(py::init<const NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>> &>(), py::arg("theMap"));

 // Methods
 cls_NCollection_DataMap_TopOpeBRepDS_DataMapIteratorOfDataMapOfIntegerListOfInterference.def("More", (Standard_Boolean (NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>, NCollection_DefaultHasher<int>>::Iterator::*)() const) &NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>, NCollection_DefaultHasher<int>>::Iterator::More, "Query if the end of collection is reached by iterator");
@@ -915,7 +915,7 @@ cls_NCollection_DataMap_TopOpeBRepDS_DataMapIteratorOfDataMapOfIntegerListOfInte
 cls_NCollection_DataMap_TopOpeBRepDS_DataMapIteratorOfDataMapOfIntegerListOfInterference.def("Key", (const int & (NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>, NCollection_DefaultHasher<int>>::Iterator::*)() const) &NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>, NCollection_DefaultHasher<int>>::Iterator::Key, "Key");

 // TYPEDEF: TOPOPEBREPDS_ARRAY1OFDATAMAPOFINTEGERLISTOFINTERFERENCE
-bind_NCollection_Array1<NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>, NCollection_DefaultHasher<int>>>(mod, "TopOpeBRepDS_Array1OfDataMapOfIntegerListOfInterference", py::module_local(false));
+bind_NCollection_Array1<NCollection_DataMap<int, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>>>(mod, "TopOpeBRepDS_Array1OfDataMapOfIntegerListOfInterference", py::module_local(false));

 // TYPEDEF: TOPOPEBREPDS_DATAMAPOFINTERFERENCELISTOFINTERFERENCE
 bind_NCollection_DataMap<opencascade::handle<TopOpeBRepDS_Interference>, NCollection_List<opencascade::handle<TopOpeBRepDS_Interference>>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "TopOpeBRepDS_DataMapOfInterferenceListOfInterference", py::module_local(false));
@@ -939,7 +939,7 @@ cls_TopOpeBRepDS_Association.def_static("get_type_descriptor_", (const opencasca
 cls_TopOpeBRepDS_Association.def("DynamicType", (const opencascade::handle<Standard_Type> & (TopOpeBRepDS_Association::*)() const) &TopOpeBRepDS_Association::DynamicType, "None");

 // TYPEDEF: TOPOPEBREPDS_DATAMAPOFCHECKSTATUS
-bind_NCollection_DataMap<int, TopOpeBRepDS_CheckStatus, NCollection_DefaultHasher<int>>(mod, "TopOpeBRepDS_DataMapOfCheckStatus", py::module_local(false));
+bind_NCollection_DataMap<int, TopOpeBRepDS_CheckStatus>(mod, "TopOpeBRepDS_DataMapOfCheckStatus", py::module_local(false));

 // TYPEDEF: TOPOPEBREPDS_DATAMAPITERATOROFDATAMAPOFCHECKSTATUS

@@ -1017,7 +1017,7 @@ bind_NCollection_DataMap<opencascade::handle<TopOpeBRepDS_Interference>, TopoDS_
 // TYPEDEF: TOPOPEBREPDS_DATAMAPITERATOROFDATAMAPOFINTERFERENCESHAPE

 // TYPEDEF: TOPOPEBREPDS_MAPOFINTEGERSHAPEDATA
-bind_NCollection_DataMap<int, TopOpeBRepDS_ShapeData, NCollection_DefaultHasher<int>>(mod, "TopOpeBRepDS_MapOfIntegerShapeData", py::module_local(false));
+bind_NCollection_DataMap<int, TopOpeBRepDS_ShapeData>(mod, "TopOpeBRepDS_MapOfIntegerShapeData", py::module_local(false));

 // TYPEDEF: TOPOPEBREPDS_DATAMAPITERATOROFMAPOFINTEGERSHAPEDATA

diff --git a/pyocct_src_ubuntu-latest_llvm11/TopTools.cxx b/pyocct_src_ubuntu-latest_llvm12/TopTools.cxx
index 5bf9106..a7accbc 100644
--- a/pyocct_src_ubuntu-latest_llvm11/TopTools.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/TopTools.cxx
@@ -116,7 +116,7 @@ bind_NCollection_List<TopoDS_Shape>(mod, "TopTools_ListOfShape", py::module_loca
 bind_NCollection_TListIterator<TopoDS_Shape>(mod, "TopTools_ListIteratorOfListOfShape", py::module_local());

 // TYPEDEF: TOPTOOLS_DATAMAPOFINTEGERLISTOFSHAPE
-bind_NCollection_DataMap<int, NCollection_List<TopoDS_Shape>, NCollection_DefaultHasher<int>>(mod, "TopTools_DataMapOfIntegerListOfShape", py::module_local(false));
+bind_NCollection_DataMap<int, NCollection_List<TopoDS_Shape>>(mod, "TopTools_DataMapOfIntegerListOfShape", py::module_local(false));

 // TYPEDEF: TOPTOOLS_DATAMAPITERATOROFDATAMAPOFINTEGERLISTOFSHAPE

@@ -247,7 +247,7 @@ bind_NCollection_DataMap<TopoDS_Shape, NCollection_List<int>, TopTools_ShapeMapH
 // TYPEDEF: TOPTOOLS_DATAMAPITERATOROFDATAMAPOFSHAPELISTOFINTEGER

 // TYPEDEF: TOPTOOLS_DATAMAPOFINTEGERSHAPE
-bind_NCollection_DataMap<int, TopoDS_Shape, NCollection_DefaultHasher<int>>(mod, "TopTools_DataMapOfIntegerShape", py::module_local(false));
+bind_NCollection_DataMap<int, TopoDS_Shape>(mod, "TopTools_DataMapOfIntegerShape", py::module_local(false));

 // TYPEDEF: TOPTOOLS_DATAMAPITERATOROFDATAMAPOFINTEGERSHAPE

diff --git a/pyocct_src_ubuntu-latest_llvm11/Transfer.cxx b/pyocct_src_ubuntu-latest_llvm12/Transfer.cxx
index 9596c33..4b0c18c 100644
--- a/pyocct_src_ubuntu-latest_llvm11/Transfer.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/Transfer.cxx
@@ -256,7 +256,7 @@ cls_Transfer_ActorOfFinderProcess.def_static("get_type_descriptor_", (const open
 cls_Transfer_ActorOfFinderProcess.def("DynamicType", (const opencascade::handle<Standard_Type> & (Transfer_ActorOfFinderProcess::*)() const) &Transfer_ActorOfFinderProcess::DynamicType, "None");

 // TYPEDEF: TRANSFER_TRANSFERMAPOFPROCESSFORTRANSIENT
-bind_NCollection_IndexedDataMap<opencascade::handle<Standard_Transient>, opencascade::handle<Transfer_Binder>, NCollection_DefaultHasher<opencascade::handle<Standard_Transient>>>(mod, "Transfer_TransferMapOfProcessForTransient", py::module_local(false));
+bind_NCollection_IndexedDataMap<opencascade::handle<Standard_Transient>, opencascade::handle<Transfer_Binder>>(mod, "Transfer_TransferMapOfProcessForTransient", py::module_local(false));

 // CLASS: TRANSFER_PROCESSFORTRANSIENT
 py::class_<Transfer_ProcessForTransient, opencascade::handle<Transfer_ProcessForTransient>, Standard_Transient> cls_Transfer_ProcessForTransient(mod, "Transfer_ProcessForTransient", "Manages Transfer of Transient Objects. Produces also ActorOfTransientProcess (deferred class), IteratorOfTransientProcess (for Results), TransferMapOfTransientProcess (internally used) Normally uses as TransientProcess, which adds some specifics");
diff --git a/pyocct_src_ubuntu-latest_llvm11/VrmlData.cxx b/pyocct_src_ubuntu-latest_llvm12/VrmlData.cxx
index 8ba7f13..ababd5a 100644
--- a/pyocct_src_ubuntu-latest_llvm11/VrmlData.cxx
+++ b/pyocct_src_ubuntu-latest_llvm12/VrmlData.cxx
@@ -362,7 +362,7 @@ cls_VrmlData_Cylinder.def_static("get_type_descriptor_", (const opencascade::han
 cls_VrmlData_Cylinder.def("DynamicType", (const opencascade::handle<Standard_Type> & (VrmlData_Cylinder::*)() const) &VrmlData_Cylinder::DynamicType, "None");

 // TYPEDEF: VRMLDATA_DATAMAPOFSHAPEAPPEARANCE
-bind_NCollection_DataMap<opencascade::handle<TopoDS_TShape>, opencascade::handle<VrmlData_Appearance>, NCollection_DefaultHasher<opencascade::handle<TopoDS_TShape>>>(mod, "VrmlData_DataMapOfShapeAppearance", py::module_local(false));
+bind_NCollection_DataMap<opencascade::handle<TopoDS_TShape>, opencascade::handle<VrmlData_Appearance>>(mod, "VrmlData_DataMapOfShapeAppearance", py::module_local(false));

 // CLASS: VRMLDATA_FACETED
 py::class_<VrmlData_Faceted, opencascade::handle<VrmlData_Faceted>, VrmlData_Geometry> cls_VrmlData_Faceted(mod, "VrmlData_Faceted", "Common API of faceted Geometry nodes: IndexedFaceSet, ElevationGrid, Extrusion.");
@@ -553,7 +553,7 @@ cls_VrmlData_IndexedLineSet.def_static("get_type_descriptor_", (const opencascad
 cls_VrmlData_IndexedLineSet.def("DynamicType", (const opencascade::handle<Standard_Type> & (VrmlData_IndexedLineSet::*)() const) &VrmlData_IndexedLineSet::DynamicType, "None");

 // TYPEDEF: VRMLDATA_MAPOFNODE
-bind_NCollection_Map<opencascade::handle<VrmlData_Node>, NCollection_DefaultHasher<opencascade::handle<VrmlData_Node>>>(mod, "VrmlData_MapOfNode", py::module_local(false));
+bind_NCollection_Map<opencascade::handle<VrmlData_Node>>(mod, "VrmlData_MapOfNode", py::module_local(false));

 // CLASS: VRMLDATA_WORLDINFO
 py::class_<VrmlData_WorldInfo, opencascade::handle<VrmlData_WorldInfo>, VrmlData_Node> cls_VrmlData_WorldInfo(mod, "VrmlData_WorldInfo", "Data type for WorldInfo node");
diff --git a/pyocct_src_ubuntu-latest_llvm11/bind_BOPTools_BoxSelector.hxx b/pyocct_src_ubuntu-latest_llvm12/bind_BOPTools_BoxSelector.hxx
index baed0ba..5ff2601 100644
--- a/pyocct_src_ubuntu-latest_llvm11/bind_BOPTools_BoxSelector.hxx
+++ b/pyocct_src_ubuntu-latest_llvm12/bind_BOPTools_BoxSelector.hxx
@@ -37,7 +37,7 @@ void bind_BOPTools_BoxSelector(py::module &mod, std::string const &name, py::mod
 // Before type
 bind_BVH_Traverse<Standard_Real, Dimension, BVH_BoxSet<Standard_Real, Dimension, Standard_Integer>, Standard_Boolean>(mod, "BOPTools_BoxSelector_Base", py::module_local());

-py::class_<BOPTools_BoxSelector<Dimension>, BVH_Traverse<Standard_Real, Dimension, BVH_BoxSet<Standard_Real, Dimension, Standard_Integer>, Standard_Boolean>> cls_BOPTools_BoxSelector(mod, name.c_str(), "Template Selector for elements selection from BVH tree.", local);
+py::class_<BOPTools_BoxSelector<Dimension>, BVH_Traverse<Standard_Real, Dimension, BVH_BoxSet<Standard_Real, Dimension>, Standard_Boolean>> cls_BOPTools_BoxSelector(mod, name.c_str(), "Template Selector for elements selection from BVH tree.", local);

 // Constructors
 cls_BOPTools_BoxSelector.def(py::init<>());
diff --git a/pyocct_src_ubuntu-latest_llvm11/bind_BOPTools_PairSelector.hxx b/pyocct_src_ubuntu-latest_llvm12/bind_BOPTools_PairSelector.hxx
index 04f474d..f787a44 100644
--- a/pyocct_src_ubuntu-latest_llvm11/bind_BOPTools_PairSelector.hxx
+++ b/pyocct_src_ubuntu-latest_llvm12/bind_BOPTools_PairSelector.hxx
@@ -32,7 +32,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 template <int Dimension>
 void bind_BOPTools_PairSelector(py::module &mod, std::string const &name, py::module_local const &local){

-py::class_<BOPTools_PairSelector<Dimension>, BVH_PairTraverse<Standard_Real, Dimension, BVH_BoxSet<Standard_Real, Dimension, Standard_Integer>>> cls_BOPTools_PairSelector(mod, name.c_str(), "Template Selector for selection of the elements from two BVH trees.", local);
+py::class_<BOPTools_PairSelector<Dimension>, BVH_PairTraverse<Standard_Real, Dimension, BVH_BoxSet<Standard_Real, Dimension>>> cls_BOPTools_PairSelector(mod, name.c_str(), "Template Selector for selection of the elements from two BVH trees.", local);

 // Constructors
 cls_BOPTools_PairSelector.def(py::init<>());
diff --git a/pyocct_src_ubuntu-latest_llvm11/bind_BVH_Distance.hxx b/pyocct_src_ubuntu-latest_llvm12/bind_BVH_Distance.hxx
index 489b737..8a14f51 100644
--- a/pyocct_src_ubuntu-latest_llvm11/bind_BVH_Distance.hxx
+++ b/pyocct_src_ubuntu-latest_llvm12/bind_BVH_Distance.hxx
@@ -29,7 +29,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 template <typename NumType, int Dimension, typename ObjectType, typename BVHSetType>
 void bind_BVH_Distance(py::module &mod, std::string const &name, py::module_local const &local){

-py::class_<BVH_Distance<NumType, Dimension, ObjectType, BVHSetType>, BVH_Traverse<NumType, Dimension, BVHSetType, NumType>> cls_BVH_Distance(mod, name.c_str(), "Abstract class for computation of the min distance between some Object and elements of BVH tree. To use this class it is required to define two methods: - *RejectNode* to compute distance from the object to bounding box - *Accept* to compute distance from the object to the element of tree", local);
+py::class_<BVH_Distance<NumType, Dimension, ObjectType, BVHSetType>, BVH_Traverse<NumType, Dimension, BVHSetType>> cls_BVH_Distance(mod, name.c_str(), "Abstract class for computation of the min distance between some Object and elements of BVH tree. To use this class it is required to define two methods: - *RejectNode* to compute distance from the object to bounding box - *Accept* to compute distance from the object to the element of tree", local);

 // Constructors
 cls_BVH_Distance.def(py::init<>());
diff --git a/pyocct_src_ubuntu-latest_llvm11/bind_BVH_PairDistance.hxx b/pyocct_src_ubuntu-latest_llvm12/bind_BVH_PairDistance.hxx
index 7c0650c..11c7b4b 100644
--- a/pyocct_src_ubuntu-latest_llvm11/bind_BVH_PairDistance.hxx
+++ b/pyocct_src_ubuntu-latest_llvm12/bind_BVH_PairDistance.hxx
@@ -30,7 +30,7 @@ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 template <typename NumType, int Dimension, typename BVHSetType>
 void bind_BVH_PairDistance(py::module &mod, std::string const &name, py::module_local const &local){

-py::class_<BVH_PairDistance<NumType, Dimension, BVHSetType>, BVH_PairTraverse<NumType, Dimension, BVHSetType, NumType>> cls_BVH_PairDistance(mod, name.c_str(), "Abstract class for computation of the min distance between elements of two BVH trees. To use this class it is required to define only the method *Accept* to compute the distance between elements of the trees.", local);
+py::class_<BVH_PairDistance<NumType, Dimension, BVHSetType>, BVH_PairTraverse<NumType, Dimension, BVHSetType>> cls_BVH_PairDistance(mod, name.c_str(), "Abstract class for computation of the min distance between elements of two BVH trees. To use this class it is required to define only the method *Accept* to compute the distance between elements of the trees.", local);

 // Constructors
 cls_BVH_PairDistance.def(py::init<>());
frmdstryr commented 3 years ago

It looks like the default template parameters are omitted from the type spelling:

template < class TheKeyType, 
           class Hasher = NCollection_DefaultHasher<TheKeyType> >
class NCollection_Map : public NCollection_BaseMap