Line data Source code
1 : /****************************************************************************** 2 : * 3 : * Project: GDAL 4 : * Purpose: GDALAlgorithm class 5 : * Author: Even Rouault <even dot rouault at spatialys.com> 6 : * 7 : ****************************************************************************** 8 : * Copyright (c) 2024, Even Rouault <even dot rouault at spatialys.com> 9 : * 10 : * SPDX-License-Identifier: MIT 11 : ****************************************************************************/ 12 : 13 : #include "gdalalgorithm.h" 14 : #include "gdalalg_main.h" 15 : #ifdef GDAL_ENABLE_ALGORITHMS 16 : #include "gdalalg_raster.h" 17 : #include "gdalalg_vector.h" 18 : #include "gdalalg_dataset.h" 19 : #include "gdalalg_mdim.h" 20 : #include "gdalalg_convert.h" 21 : #include "gdalalg_info.h" 22 : #include "gdalalg_pipeline.h" 23 : #include "gdalalg_vsi.h" 24 : #include "gdalalg_crs.h" 25 : #endif 26 : 27 : #include "cpl_vsi.h" 28 : 29 : #include "gdal_priv.h" 30 : 31 : #include <cassert> 32 : 33 : /************************************************************************/ 34 : /* GDALAlgorithmRegistry::~GDALAlgorithmRegistry() */ 35 : /************************************************************************/ 36 : 37 : GDALAlgorithmRegistry::~GDALAlgorithmRegistry() = default; 38 : 39 : /************************************************************************/ 40 : /* GDALAlgorithmRegistry::Register() */ 41 : /************************************************************************/ 42 : 43 220381 : bool GDALAlgorithmRegistry::Register(const GDALAlgorithmRegistry::AlgInfo &info) 44 : { 45 220381 : if (cpl::contains(m_mapNameToInfo, info.m_name)) 46 : { 47 1 : CPLError(CE_Failure, CPLE_AppDefined, 48 : "GDAL algorithm '%s' already registered!", 49 : info.m_name.c_str()); 50 1 : return false; 51 : } 52 262758 : for (const std::string &alias : info.m_aliases) 53 : { 54 84759 : if (cpl::contains(m_mapAliasToInfo, alias) || 55 42379 : cpl::contains(m_mapHiddenAliasToInfo, alias)) 56 : { 57 2 : CPLError(CE_Failure, CPLE_AppDefined, 58 : "An algorithm with alias '%s' is already registered!", 59 : alias.c_str()); 60 2 : return false; 61 : } 62 : } 63 220378 : m_mapNameToInfo[info.m_name] = info; 64 220378 : bool hidden = false; 65 262755 : for (const std::string &alias : info.m_aliases) 66 : { 67 42377 : if (alias == HIDDEN_ALIAS_SEPARATOR) 68 16002 : hidden = true; 69 26375 : else if (hidden) 70 21607 : m_mapAliasToInfo[alias] = info; 71 : else 72 4768 : m_mapHiddenAliasToInfo[alias] = info; 73 : } 74 220378 : return true; 75 : } 76 : 77 : /************************************************************************/ 78 : /* GDALAlgorithmRegistry::InstantiateTopLevel() */ 79 : /************************************************************************/ 80 : 81 : std::unique_ptr<GDALAlgorithm> 82 20147 : GDALAlgorithmRegistry::InstantiateTopLevel(const std::string &name) const 83 : { 84 20147 : auto iter = m_mapNameToInfo.find(name); 85 20147 : if (iter == m_mapNameToInfo.end()) 86 : { 87 1708 : iter = m_mapAliasToInfo.find(name); 88 1708 : if (iter == m_mapAliasToInfo.end()) 89 : { 90 1702 : iter = m_mapHiddenAliasToInfo.find(name); 91 1702 : if (iter == m_mapHiddenAliasToInfo.end()) 92 : { 93 1699 : return nullptr; 94 : } 95 : } 96 : } 97 36896 : auto alg = iter->second.m_creationFunc(); 98 18448 : alg->m_aliases = iter->second.m_aliases; 99 18448 : return alg; 100 : } 101 : 102 : /************************************************************************/ 103 : /* GDALAlgorithmRegistry::Instantiate() */ 104 : /************************************************************************/ 105 : 106 : std::unique_ptr<GDALAlgorithm> 107 4935 : GDALAlgorithmRegistry::Instantiate(const std::vector<std::string> &path) const 108 : { 109 4935 : if (path.empty()) 110 1 : return nullptr; 111 9868 : auto alg = Instantiate(path[0]); 112 4951 : for (size_t i = 1; i < path.size() && alg; ++i) 113 : { 114 17 : alg = alg->InstantiateSubAlgorithm(path[i]); 115 : } 116 4934 : return alg; 117 : } 118 : 119 : /************************************************************************/ 120 : /* GDALAlgorithmRegistry::GetNames() */ 121 : /************************************************************************/ 122 : 123 3174 : std::vector<std::string> GDALAlgorithmRegistry::GetNames() const 124 : { 125 3174 : std::vector<std::string> res; 126 17912 : for (const auto &iter : m_mapNameToInfo) 127 : { 128 14738 : res.push_back(iter.first); 129 : } 130 3174 : return res; 131 : } 132 : 133 : /************************************************************************/ 134 : /* GDALAlgorithmRegistry::Instantiate() */ 135 : /************************************************************************/ 136 : 137 : std::unique_ptr<GDALAlgorithm> 138 20637 : GDALAlgorithmRegistry::Instantiate(const std::string &name) const 139 : { 140 20637 : return InstantiateTopLevel(name); 141 : } 142 : 143 : std::unique_ptr<GDALAlgorithm> 144 4933 : GDALAlgorithmRegistry::InstantiateInternal(std::vector<std::string> &path) 145 : { 146 4933 : return Instantiate(path); 147 : } 148 : 149 : /************************************************************************/ 150 : /* GDALGlobalAlgorithmRegistry::GDALGlobalAlgorithmRegistry() */ 151 : /************************************************************************/ 152 : 153 1610 : GDALGlobalAlgorithmRegistry::GDALGlobalAlgorithmRegistry() 154 : { 155 : #ifdef GDAL_ENABLE_ALGORITHMS 156 1610 : Register<GDALRasterAlgorithm>(); 157 1610 : Register<GDALVectorAlgorithm>(); 158 1610 : Register<GDALDatasetAlgorithm>(); 159 1610 : Register<GDALMdimAlgorithm>(); 160 1610 : Register<GDALConvertAlgorithm>(); 161 1610 : Register<GDALInfoAlgorithm>(); 162 1610 : Register<GDALPipelineAlgorithm>(); 163 1610 : Register<GDALVSIAlgorithm>(); 164 1610 : Register<GDALCRSAlgorithm>(); 165 : #endif 166 1610 : } 167 : 168 : GDALGlobalAlgorithmRegistry::~GDALGlobalAlgorithmRegistry() = default; 169 : 170 : /************************************************************************/ 171 : /* GDALGlobalAlgorithmRegistry::GetSingleton() */ 172 : /************************************************************************/ 173 : 174 : /* static */ GDALGlobalAlgorithmRegistry & 175 43534 : GDALGlobalAlgorithmRegistry::GetSingleton() 176 : { 177 43534 : static GDALGlobalAlgorithmRegistry singleton; 178 43534 : return singleton; 179 : } 180 : 181 : /************************************************************************/ 182 : /* GDALGlobalAlgorithmRegistry::InstantiateTopLevel() */ 183 : /************************************************************************/ 184 : 185 : std::unique_ptr<GDALAlgorithm> 186 3862 : GDALGlobalAlgorithmRegistry::InstantiateTopLevel(const std::string &name) const 187 : { 188 3862 : if (name == GDALGlobalAlgorithmRegistry::ROOT_ALG_NAME) 189 490 : return std::make_unique<GDALMainAlgorithm>(); 190 6744 : auto alg = GDALAlgorithmRegistry::InstantiateTopLevel(name); 191 3372 : if (!alg) 192 : { 193 260 : alg = InstantiateDeclaredSubAlgorithm( 194 195 : {GDALGlobalAlgorithmRegistry::ROOT_ALG_NAME, name}); 195 : } 196 3372 : if (alg) 197 : { 198 10098 : alg->SetCallPath({GDALGlobalAlgorithmRegistry::ROOT_ALG_NAME, name}); 199 : } 200 3372 : return alg; 201 : } 202 : 203 : /************************************************************************/ 204 : /* GDALGlobalAlgorithmRegistry::DeclareAlgorithm() */ 205 : /************************************************************************/ 206 : 207 35925 : void GDALGlobalAlgorithmRegistry::DeclareAlgorithm( 208 : const std::vector<std::string> &path, InstantiateFunc instantiateFunc) 209 : { 210 35925 : Node *curNode = &m_root; 211 126098 : for (size_t i = 0; i < path.size(); ++i) 212 : { 213 90173 : const std::string &name = path[i]; 214 90173 : auto iter = curNode->children.find(name); 215 90173 : if (iter == curNode->children.end()) 216 : { 217 33602 : Node newNode; 218 33602 : if (i + 1 == path.size()) 219 : { 220 33601 : newNode.instantiateFunc = instantiateFunc; 221 : } 222 : else 223 : { 224 : newNode.instantiateFunc = 225 4 : [name]() -> std::unique_ptr<GDALAlgorithm> 226 : { 227 4 : return std::make_unique<GDALContainerAlgorithm>( 228 8 : name, std::string("Command for ").append(name)); 229 1 : }; 230 : } 231 33602 : curNode = 232 67204 : &(curNode->children.insert(std::pair(name, std::move(newNode))) 233 33602 : .first->second); 234 : } 235 : else 236 : { 237 56571 : curNode = &(iter->second); 238 : } 239 : } 240 35925 : } 241 : 242 : /************************************************************************/ 243 : /* GDALGlobalAlgorithmRegistry::GetNodeFromPath() */ 244 : /************************************************************************/ 245 : 246 : const GDALGlobalAlgorithmRegistry::Node * 247 54776 : GDALGlobalAlgorithmRegistry::GetNodeFromPath( 248 : const std::vector<std::string> &path) const 249 : { 250 54776 : if (!path.empty()) 251 : { 252 53590 : const Node *curNode = &m_root; 253 53590 : bool first = true; 254 114638 : for (const std::string &name : path) 255 : { 256 87937 : if (first && name == GDALGlobalAlgorithmRegistry::ROOT_ALG_NAME) 257 : { 258 10829 : first = false; 259 10829 : continue; 260 : } 261 77108 : first = false; 262 77108 : auto iter = curNode->children.find(name); 263 77108 : if (iter == curNode->children.end()) 264 26889 : return nullptr; 265 50219 : curNode = &(iter->second); 266 : } 267 26701 : return curNode; 268 : } 269 1186 : return nullptr; 270 : } 271 : 272 : /************************************************************************/ 273 : /* GDALGlobalAlgorithmRegistry::GetDeclaredSubAlgorithmNames() */ 274 : /************************************************************************/ 275 : 276 : std::vector<std::string> 277 13575 : GDALGlobalAlgorithmRegistry::GetDeclaredSubAlgorithmNames( 278 : const std::vector<std::string> &path) const 279 : { 280 13575 : const GDALGlobalAlgorithmRegistry::Node *node = GetNodeFromPath(path); 281 13575 : std::vector<std::string> ret; 282 13575 : if (node) 283 : { 284 4419 : for (const auto &[name, subnode] : node->children) 285 : { 286 : // If there is an instantiation function, run it, to avoid 287 : // reporting algorithms that might be in drivers built as 288 : // deferred loaded plugins, but not available at runtime. 289 2731 : if (!subnode.instantiateFunc || subnode.instantiateFunc()) 290 : { 291 2731 : ret.push_back(name); 292 : } 293 : } 294 : } 295 13575 : return ret; 296 : } 297 : 298 : /************************************************************************/ 299 : /* GDALGlobalAlgorithmRegistry::HasDeclaredSubAlgorithm() */ 300 : /************************************************************************/ 301 : 302 39846 : bool GDALGlobalAlgorithmRegistry::HasDeclaredSubAlgorithm( 303 : const std::vector<std::string> &path) const 304 : { 305 39846 : return GetNodeFromPath(path) != nullptr; 306 : } 307 : 308 : /************************************************************************/ 309 : /* GDALGlobalAlgorithmRegistry::InstantiateDeclaredSubAlgorithm() */ 310 : /************************************************************************/ 311 : 312 : std::unique_ptr<GDALAlgorithm> 313 1355 : GDALGlobalAlgorithmRegistry::InstantiateDeclaredSubAlgorithm( 314 : const std::vector<std::string> &path) const 315 : { 316 1355 : const GDALGlobalAlgorithmRegistry::Node *node = GetNodeFromPath(path); 317 1355 : if (node && node->instantiateFunc) 318 : { 319 2334 : auto alg = node->instantiateFunc(); 320 1167 : if (alg) 321 : { 322 2334 : auto callPath = path; 323 1167 : if (path[0] != GDALGlobalAlgorithmRegistry::ROOT_ALG_NAME) 324 0 : callPath.insert(callPath.begin(), 325 0 : GDALGlobalAlgorithmRegistry::ROOT_ALG_NAME); 326 1167 : alg->SetCallPath(callPath); 327 : } 328 1167 : return alg; 329 : } 330 188 : return nullptr; 331 : } 332 : 333 : /************************************************************************/ 334 : /* struct GDALAlgorithmRegistryHS */ 335 : /************************************************************************/ 336 : 337 : struct GDALAlgorithmRegistryHS 338 : { 339 : GDALAlgorithmRegistry *ptr = nullptr; 340 : }; 341 : 342 : /************************************************************************/ 343 : /* GDALGetGlobalAlgorithmRegistry() */ 344 : /************************************************************************/ 345 : 346 : /** Gets a handle to the GDALGetGlobalAlgorithmRegistry which references 347 : * all available top-level GDAL algorithms ("raster", "vector", etc.) 348 : * 349 : * The handle must be released with GDALAlgorithmRegistryRelease() (but 350 : * this does not destroy the GDALAlgorithmRegistryRelease singleton). 351 : * 352 : * @since 3.11 353 : */ 354 3385 : GDALAlgorithmRegistryH GDALGetGlobalAlgorithmRegistry() 355 : { 356 6770 : auto ret = std::make_unique<GDALAlgorithmRegistryHS>(); 357 3385 : ret->ptr = &(GDALGlobalAlgorithmRegistry::GetSingleton()); 358 6770 : return ret.release(); 359 : } 360 : 361 : /************************************************************************/ 362 : /* GDALAlgorithmRegistryRelease() */ 363 : /************************************************************************/ 364 : 365 : /** Release a handle to an algorithm registry, but this does not destroy the 366 : * registry itself. 367 : * 368 : * @since 3.11 369 : */ 370 3385 : void GDALAlgorithmRegistryRelease(GDALAlgorithmRegistryH hReg) 371 : { 372 3385 : delete hReg; 373 3385 : } 374 : 375 : /************************************************************************/ 376 : /* GDALAlgorithmRegistryGetAlgNames() */ 377 : /************************************************************************/ 378 : 379 : /** Return the names of the algorithms registered in the registry passed as 380 : * parameter. 381 : * 382 : * @param hReg Handle to a registry. Must NOT be null. 383 : * @return a NULL terminated list of names, which must be destroyed with 384 : * CSLDestroy() 385 : * 386 : * @since 3.11 387 : */ 388 2 : char **GDALAlgorithmRegistryGetAlgNames(GDALAlgorithmRegistryH hReg) 389 : { 390 2 : VALIDATE_POINTER1(hReg, __func__, nullptr); 391 2 : return CPLStringList(hReg->ptr->GetNames()).StealList(); 392 : } 393 : 394 : /************************************************************************/ 395 : /* GDALAlgorithmRegistryInstantiateAlg() */ 396 : /************************************************************************/ 397 : 398 : /** Instantiate an algorithm available in a registry from its name. 399 : * 400 : * @param hReg Handle to a registry. Must NOT be null. 401 : * @param pszAlgName Algorithm name. Must NOT be null. 402 : * @return an handle to the algorithm (to be freed with GDALAlgorithmRelease), 403 : * or NULL if the algorithm does not exist or another error occurred. 404 : * 405 : * @since 3.11 406 : */ 407 3390 : GDALAlgorithmH GDALAlgorithmRegistryInstantiateAlg(GDALAlgorithmRegistryH hReg, 408 : const char *pszAlgName) 409 : { 410 3390 : VALIDATE_POINTER1(hReg, __func__, nullptr); 411 3390 : VALIDATE_POINTER1(pszAlgName, __func__, nullptr); 412 6780 : auto alg = hReg->ptr->Instantiate(pszAlgName); 413 6780 : return alg ? std::make_unique<GDALAlgorithmHS>(std::move(alg)).release() 414 6780 : : nullptr; 415 : } 416 : 417 : /************************************************************************/ 418 : /* GDALAlgorithmRegistryInstantiateAlgFromPath() */ 419 : /************************************************************************/ 420 : 421 : /** Instantiate an algorithm available in a registry from its path. 422 : * 423 : * @param hReg Handle to a registry. Must NOT be null. 424 : * @param papszAlgPath Algorithm path. Must NOT be null. 425 : * @return an handle to the algorithm (to be freed with GDALAlgorithmRelease), 426 : * or NULL if the algorithm does not exist or another error occurred. 427 : * 428 : * @since 3.12 429 : */ 430 : GDALAlgorithmH 431 1 : GDALAlgorithmRegistryInstantiateAlgFromPath(GDALAlgorithmRegistryH hReg, 432 : const char *const *papszAlgPath) 433 : { 434 1 : VALIDATE_POINTER1(hReg, __func__, nullptr); 435 1 : VALIDATE_POINTER1(papszAlgPath, __func__, nullptr); 436 1 : auto alg = hReg->ptr->Instantiate( 437 2 : static_cast<std::vector<std::string>>(CPLStringList(papszAlgPath))); 438 2 : return alg ? std::make_unique<GDALAlgorithmHS>(std::move(alg)).release() 439 2 : : nullptr; 440 : }