Apollo 10.0
自动驾驶开放平台
apollo::cyber::class_loader::utility 命名空间参考

class  AbstractClassFactory
 
class  AbstractClassFactoryBase
 
class  ClassFactory
 

类型定义

using SharedLibraryPtr = std::shared_ptr< SharedLibrary >
 
using ClassClassFactoryMap = std::map< std::string, utility::AbstractClassFactoryBase * >
 
using BaseToClassFactoryMapMap = std::map< std::string, ClassClassFactoryMap >
 
using LibPathSharedLibVector = std::vector< std::pair< std::string, SharedLibraryPtr > >
 
using ClassFactoryVector = std::vector< AbstractClassFactoryBase * >
 

函数

std::recursive_mutex & GetClassFactoryMapMapMutex ()
 
std::recursive_mutex & GetLibPathSharedLibMutex ()
 
BaseToClassFactoryMapMapGetClassFactoryMapMap ()
 
LibPathSharedLibVectorGetLibPathSharedLibVector ()
 
ClassClassFactoryMapGetClassFactoryMapByBaseClass (const std::string &typeid_base_class_name)
 
std::string & GetCurLoadingLibraryNameReference ()
 
std::string GetCurLoadingLibraryName ()
 
void SetCurLoadingLibraryName (const std::string &library_name)
 
ClassLoader *& GetCurActiveClassLoaderReference ()
 
ClassLoaderGetCurActiveClassLoader ()
 
void SetCurActiveClassLoader (ClassLoader *loader)
 
ClassFactoryVector GetAllClassFactoryObjects (const ClassClassFactoryMap &factories)
 
ClassFactoryVector GetAllClassFactoryObjects ()
 
ClassFactoryVector GetAllClassFactoryObjectsOfLibrary (const std::string &library_path)
 
void DestroyClassFactoryObjectsOfLibrary (const std::string &library_path, const ClassLoader *class_loader, ClassClassFactoryMap *class_factory_map)
 
void DestroyClassFactoryObjectsOfLibrary (const std::string &library_path, const ClassLoader *loader)
 
LibPathSharedLibVector::iterator FindLoadedLibrary (const std::string &library_path)
 
bool IsLibraryLoadedByAnybody (const std::string &library_path)
 
bool IsLibraryLoaded (const std::string &library_path, ClassLoader *class_loader)
 
bool LoadLibrary (const std::string &library_path, ClassLoader *loader)
 
void UnloadLibrary (const std::string &library_path, ClassLoader *loader)
 
template<typename Derived , typename Base >
void RegisterClass (const std::string &class_name, const std::string &base_class_name)
 
template<typename Base >
BaseCreateClassObj (const std::string &class_name, ClassLoader *loader)
 
template<typename Base >
std::vector< std::string > GetValidClassNames (ClassLoader *loader)
 

类型定义说明

◆ BaseToClassFactoryMapMap

◆ ClassClassFactoryMap

◆ ClassFactoryVector

◆ LibPathSharedLibVector

using apollo::cyber::class_loader::utility::LibPathSharedLibVector = typedef std::vector<std::pair<std::string, SharedLibraryPtr> >

在文件 class_loader_utility.h50 行定义.

◆ SharedLibraryPtr

在文件 class_loader_utility.h46 行定义.

函数说明

◆ CreateClassObj()

template<typename Base >
Base * apollo::cyber::class_loader::utility::CreateClassObj ( const std::string &  class_name,
ClassLoader loader 
)

在文件 class_loader_utility.h95 行定义.

95 {
97 ClassClassFactoryMap& factoryMap =
98 GetClassFactoryMapByBaseClass(typeid(Base).name());
99 AbstractClassFactory<Base>* factory = nullptr;
100 if (factoryMap.find(class_name) != factoryMap.end()) {
101 factory = dynamic_cast<utility::AbstractClassFactory<Base>*>(
102 factoryMap[class_name]);
103 }
104 GetClassFactoryMapMapMutex().unlock();
105
106 Base* classobj = nullptr;
107 if (factory && factory->IsOwnedBy(loader)) {
108 classobj = factory->CreateObj();
109 }
110
111 return classobj;
112}
Definition base.h:20
ClassClassFactoryMap & GetClassFactoryMapByBaseClass(const std::string &typeid_base_class_name)
std::map< std::string, utility::AbstractClassFactoryBase * > ClassClassFactoryMap
std::recursive_mutex & GetClassFactoryMapMapMutex()

◆ DestroyClassFactoryObjectsOfLibrary() [1/2]

void apollo::cyber::class_loader::utility::DestroyClassFactoryObjectsOfLibrary ( const std::string &  library_path,
const ClassLoader class_loader,
ClassClassFactoryMap class_factory_map 
)

在文件 class_loader_utility.cc119 行定义.

121 {
122 for (ClassClassFactoryMap::iterator itr = class_factory_map->begin();
123 itr != class_factory_map->end();) {
124 AbstractClassFactoryBase* class_factory_object = itr->second;
125 if (class_factory_object->GetRelativeLibraryPath() == library_path &&
126 class_factory_object->IsOwnedBy(class_loader)) {
127 class_factory_object->RemoveOwnedClassLoader(class_loader);
128 // when no anybody owner, delete && erase
129 if (!class_factory_object->IsOwnedByAnybody()) {
130 itr = class_factory_map->erase(itr);
131 delete class_factory_object;
132 } else {
133 ++itr;
134 }
135 } else {
136 ++itr;
137 }
138 }
139}

◆ DestroyClassFactoryObjectsOfLibrary() [2/2]

void apollo::cyber::class_loader::utility::DestroyClassFactoryObjectsOfLibrary ( const std::string &  library_path,
const ClassLoader loader 
)

在文件 class_loader_utility.cc141 行定义.

142 {
143 std::lock_guard<std::recursive_mutex> lck(GetClassFactoryMapMapMutex());
144
146 for (auto& baseclass_map : factory_map_map) {
147 DestroyClassFactoryObjectsOfLibrary(library_path, loader,
148 &baseclass_map.second);
149 }
150}
BaseToClassFactoryMapMap & GetClassFactoryMapMap()
void DestroyClassFactoryObjectsOfLibrary(const std::string &library_path, const ClassLoader *class_loader, ClassClassFactoryMap *class_factory_map)
std::map< std::string, ClassClassFactoryMap > BaseToClassFactoryMapMap

◆ FindLoadedLibrary()

LibPathSharedLibVector::iterator apollo::cyber::class_loader::utility::FindLoadedLibrary ( const std::string &  library_path)

在文件 class_loader_utility.cc152 行定义.

153 {
155 LibPathSharedLibVector::iterator itr;
156 for (itr = opened_libraries.begin(); itr != opened_libraries.end(); ++itr) {
157 if (itr->first == library_path) {
158 break;
159 }
160 }
161 return itr;
162}
LibPathSharedLibVector & GetLibPathSharedLibVector()
std::vector< std::pair< std::string, SharedLibraryPtr > > LibPathSharedLibVector

◆ GetAllClassFactoryObjects() [1/2]

ClassFactoryVector apollo::cyber::class_loader::utility::GetAllClassFactoryObjects ( )

在文件 class_loader_utility.cc93 行定义.

93 {
94 std::lock_guard<std::recursive_mutex> lck(GetClassFactoryMapMapMutex());
95
96 ClassFactoryVector all_class_factory_objs;
98 for (auto& baseclass_map : factory_map_map) {
99 ClassFactoryVector objs = GetAllClassFactoryObjects(baseclass_map.second);
100 all_class_factory_objs.insert(all_class_factory_objs.end(), objs.begin(),
101 objs.end());
102 }
103
104 return all_class_factory_objs;
105}
ClassFactoryVector GetAllClassFactoryObjects(const ClassClassFactoryMap &factories)
std::vector< AbstractClassFactoryBase * > ClassFactoryVector

◆ GetAllClassFactoryObjects() [2/2]

ClassFactoryVector apollo::cyber::class_loader::utility::GetAllClassFactoryObjects ( const ClassClassFactoryMap factories)

在文件 class_loader_utility.cc83 行定义.

84 {
85 ClassFactoryVector all_class_factory_objs;
86 for (auto& class_factory : factories) {
87 all_class_factory_objs.emplace_back(class_factory.second);
88 }
89
90 return all_class_factory_objs;
91}

◆ GetAllClassFactoryObjectsOfLibrary()

ClassFactoryVector apollo::cyber::class_loader::utility::GetAllClassFactoryObjectsOfLibrary ( const std::string &  library_path)

在文件 class_loader_utility.cc107 行定义.

108 {
109 ClassFactoryVector all_class_factory_objs = GetAllClassFactoryObjects();
110 ClassFactoryVector library_class_factory_objs;
111 for (auto& class_factory_obj : all_class_factory_objs) {
112 if (class_factory_obj->GetRelativeLibraryPath() == library_path) {
113 library_class_factory_objs.emplace_back(class_factory_obj);
114 }
115 }
116 return library_class_factory_objs;
117}

◆ GetClassFactoryMapByBaseClass()

ClassClassFactoryMap & apollo::cyber::class_loader::utility::GetClassFactoryMapByBaseClass ( const std::string &  typeid_base_class_name)

在文件 class_loader_utility.cc44 行定义.

45 {
47 std::string base_class_name = typeid_base_class_name;
48 if (factoryMapMap.find(base_class_name) == factoryMapMap.end()) {
49 factoryMapMap[base_class_name] = ClassClassFactoryMap();
50 }
51
52 return factoryMapMap[base_class_name];
53}

◆ GetClassFactoryMapMap()

BaseToClassFactoryMapMap & apollo::cyber::class_loader::utility::GetClassFactoryMapMap ( )

在文件 class_loader_utility.cc34 行定义.

34 {
35 static BaseToClassFactoryMapMap instance;
36 return instance;
37}

◆ GetClassFactoryMapMapMutex()

std::recursive_mutex & apollo::cyber::class_loader::utility::GetClassFactoryMapMapMutex ( )

在文件 class_loader_utility.cc24 行定义.

24 {
25 static std::recursive_mutex m;
26 return m;
27}

◆ GetCurActiveClassLoader()

ClassLoader * apollo::cyber::class_loader::utility::GetCurActiveClassLoader ( )

在文件 class_loader_utility.cc74 行定义.

74 {
76}

◆ GetCurActiveClassLoaderReference()

ClassLoader *& apollo::cyber::class_loader::utility::GetCurActiveClassLoaderReference ( )

在文件 class_loader_utility.cc69 行定义.

69 {
70 static ClassLoader* loader = nullptr;
71 return loader;
72}
for library load,createclass object

◆ GetCurLoadingLibraryName()

std::string apollo::cyber::class_loader::utility::GetCurLoadingLibraryName ( )

在文件 class_loader_utility.cc60 行定义.

◆ GetCurLoadingLibraryNameReference()

std::string & apollo::cyber::class_loader::utility::GetCurLoadingLibraryNameReference ( )

在文件 class_loader_utility.cc55 行定义.

55 {
56 static std::string library_name;
57 return library_name;
58}

◆ GetLibPathSharedLibMutex()

std::recursive_mutex & apollo::cyber::class_loader::utility::GetLibPathSharedLibMutex ( )

在文件 class_loader_utility.cc29 行定义.

29 {
30 static std::recursive_mutex m;
31 return m;
32}

◆ GetLibPathSharedLibVector()

LibPathSharedLibVector & apollo::cyber::class_loader::utility::GetLibPathSharedLibVector ( )

在文件 class_loader_utility.cc39 行定义.

39 {
40 static LibPathSharedLibVector instance;
41 return instance;
42}

◆ GetValidClassNames()

template<typename Base >
std::vector< std::string > apollo::cyber::class_loader::utility::GetValidClassNames ( ClassLoader loader)

在文件 class_loader_utility.h115 行定义.

115 {
116 std::lock_guard<std::recursive_mutex> lck(GetClassFactoryMapMapMutex());
117
118 ClassClassFactoryMap& factoryMap =
119 GetClassFactoryMapByBaseClass(typeid(Base).name());
120 std::vector<std::string> classes;
121 for (auto& class_factory : factoryMap) {
122 AbstractClassFactoryBase* factory = class_factory.second;
123 if (factory && factory->IsOwnedBy(loader)) {
124 classes.emplace_back(class_factory.first);
125 }
126 }
127
128 return classes;
129}

◆ IsLibraryLoaded()

bool apollo::cyber::class_loader::utility::IsLibraryLoaded ( const std::string &  library_path,
ClassLoader class_loader 
)

在文件 class_loader_utility.cc172 行定义.

173 {
174 bool is_lib_loaded_by_anyone = IsLibraryLoadedByAnybody(library_path);
175 ClassFactoryVector lib_class_factory_objs =
177 auto num_lib_class_factory_objs = lib_class_factory_objs.size();
178 if (is_lib_loaded_by_anyone && num_lib_class_factory_objs == 0) {
179 return true;
180 }
181
182 ClassFactoryVector lib_loader_class_factory_objs;
183 for (auto& class_factory_obj : lib_class_factory_objs) {
184 if (class_factory_obj->IsOwnedBy(class_loader)) {
185 lib_loader_class_factory_objs.emplace_back(class_factory_obj);
186 }
187 }
188
189 auto num_lib_loader_class_factory_objs = lib_loader_class_factory_objs.size();
190 return (is_lib_loaded_by_anyone &&
191 (num_lib_loader_class_factory_objs <= num_lib_class_factory_objs));
192}
bool IsLibraryLoadedByAnybody(const std::string &library_path)
ClassFactoryVector GetAllClassFactoryObjectsOfLibrary(const std::string &library_path)

◆ IsLibraryLoadedByAnybody()

bool apollo::cyber::class_loader::utility::IsLibraryLoadedByAnybody ( const std::string &  library_path)

在文件 class_loader_utility.cc164 行定义.

164 {
165 std::lock_guard<std::recursive_mutex> lck(GetLibPathSharedLibMutex());
166
168 LibPathSharedLibVector::iterator itr = FindLoadedLibrary(library_path);
169 return itr != opened_libraries.end();
170}
std::recursive_mutex & GetLibPathSharedLibMutex()
LibPathSharedLibVector::iterator FindLoadedLibrary(const std::string &library_path)

◆ LoadLibrary()

bool apollo::cyber::class_loader::utility::LoadLibrary ( const std::string &  library_path,
ClassLoader loader 
)

在文件 class_loader_utility.cc194 行定义.

194 {
195 if (IsLibraryLoadedByAnybody(library_path)) {
196 AINFO << "lib has been loaded by others,only attach to class factory obj."
197 << library_path;
198 ClassFactoryVector lib_class_factory_objs =
200 for (auto& class_factory_obj : lib_class_factory_objs) {
201 class_factory_obj->AddOwnedClassLoader(loader);
202 }
203 return true;
204 }
205
206 SharedLibraryPtr shared_library = nullptr;
207 static std::recursive_mutex loader_mutex;
208 {
209 std::lock_guard<std::recursive_mutex> lck(loader_mutex);
210
211 try {
212 SetCurActiveClassLoader(loader);
213 SetCurLoadingLibraryName(library_path);
214 shared_library = SharedLibraryPtr(new SharedLibrary(library_path));
215 } catch (const LibraryLoadException& e) {
216 SetCurLoadingLibraryName("");
217 SetCurActiveClassLoader(nullptr);
218 AERROR << "LibraryLoadException: " << e.what();
219 } catch (const LibraryAlreadyLoadedException& e) {
220 SetCurLoadingLibraryName("");
221 SetCurActiveClassLoader(nullptr);
222 AERROR << "LibraryAlreadyLoadedException: " << e.what();
223 } catch (const SymbolNotFoundException& e) {
226 AERROR << "SymbolNotFoundException: " << e.what();
227 }
228
231 }
232
233 if (shared_library == nullptr) {
234 AERROR << "shared library failed: " << library_path;
235 return false;
236 }
237
238 auto num_lib_objs = GetAllClassFactoryObjectsOfLibrary(library_path).size();
239 if (num_lib_objs == 0) {
240 AWARN << "Class factory objs counts is 0, maybe registerclass failed.";
241 }
242
243 std::lock_guard<std::recursive_mutex> lck(GetLibPathSharedLibMutex());
245 opened_libraries.emplace_back(
246 std::pair<std::string, SharedLibraryPtr>(library_path, shared_library));
247 return true;
248}
#define AERROR
Definition log.h:44
#define AINFO
Definition log.h:42
#define AWARN
Definition log.h:43
void SetCurActiveClassLoader(ClassLoader *loader)
void SetCurLoadingLibraryName(const std::string &library_name)

◆ RegisterClass()

template<typename Derived , typename Base >
void apollo::cyber::class_loader::utility::RegisterClass ( const std::string &  class_name,
const std::string &  base_class_name 
)

在文件 class_loader_utility.h77 行定义.

78 {
79 AINFO << "registerclass:" << class_name << "," << base_class_name << ","
81
82 utility::AbstractClassFactory<Base>* new_class_factory_obj =
83 new utility::ClassFactory<Derived, Base>(class_name, base_class_name);
84 new_class_factory_obj->AddOwnedClassLoader(GetCurActiveClassLoader());
85 new_class_factory_obj->SetRelativeLibraryPath(GetCurLoadingLibraryName());
86
88 ClassClassFactoryMap& factory_map =
89 GetClassFactoryMapByBaseClass(typeid(Base).name());
90 factory_map[class_name] = new_class_factory_obj;
92}
void SetRelativeLibraryPath(const std::string &library_path)

◆ SetCurActiveClassLoader()

void apollo::cyber::class_loader::utility::SetCurActiveClassLoader ( ClassLoader loader)

在文件 class_loader_utility.cc78 行定义.

78 {
80 loader_ref = loader;
81}

◆ SetCurLoadingLibraryName()

void apollo::cyber::class_loader::utility::SetCurLoadingLibraryName ( const std::string &  library_name)

在文件 class_loader_utility.cc64 行定义.

64 {
65 std::string& library_name_ref = GetCurLoadingLibraryNameReference();
66 library_name_ref = library_name;
67}

◆ UnloadLibrary()

void apollo::cyber::class_loader::utility::UnloadLibrary ( const std::string &  library_path,
ClassLoader loader 
)

在文件 class_loader_utility.cc250 行定义.

250 {
251 {
252 std::lock_guard<std::recursive_mutex> lck(GetLibPathSharedLibMutex());
254 LibPathSharedLibVector::iterator itr = FindLoadedLibrary(library_path);
255 if (itr == opened_libraries.end()) {
256 AERROR << "Attempt to UnloadLibrary lib, but can't find lib: "
257 << library_path;
258 return;
259 }
260
261 std::string library_path = itr->first;
262 try {
263 DestroyClassFactoryObjectsOfLibrary(library_path, loader);
264
265 if (GetAllClassFactoryObjectsOfLibrary(library_path).empty()) {
266 itr->second->Unload();
267 itr = opened_libraries.erase(itr);
268 } else {
269 AWARN << "ClassFactory objects still remain in memory, meaning other"
270 "class loaders are still using library:"
271 << library_path;
272 }
273 } catch (const std::runtime_error& e) {
274 AERROR << "Library unload error: " << e.what();
275 }
276 }
277}