Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  OpenGIS Simple Features Reference Implementation
       4             :  * Purpose:  Implements OGRMutexedDataSource class
       5             :  * Author:   Even Rouault, even dot rouault at spatialys.com
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 2013, Even Rouault <even dot rouault at spatialys.com>
       9             :  *
      10             :  * SPDX-License-Identifier: MIT
      11             :  ****************************************************************************/
      12             : 
      13             : #ifndef DOXYGEN_SKIP
      14             : 
      15             : #include "ogrmutexeddatasource.h"
      16             : #include "cpl_multiproc.h"
      17             : 
      18          87 : OGRMutexedDataSource::OGRMutexedDataSource(GDALDataset *poBaseDataSource,
      19             :                                            int bTakeOwnership,
      20             :                                            CPLMutex *hMutexIn,
      21          87 :                                            int bWrapLayersInMutexedLayer)
      22             :     : m_poBaseDataSource(poBaseDataSource), m_bHasOwnership(bTakeOwnership),
      23             :       m_hGlobalMutex(hMutexIn),
      24          87 :       m_bWrapLayersInMutexedLayer(bWrapLayersInMutexedLayer)
      25             : {
      26          87 :     SetDescription(poBaseDataSource->GetDescription());
      27          87 :     poDriver = poBaseDataSource->GetDriver();
      28          87 : }
      29             : 
      30         174 : OGRMutexedDataSource::~OGRMutexedDataSource()
      31             : {
      32             :     std::map<OGRLayer *, OGRMutexedLayer *>::iterator oIter =
      33          87 :         m_oMapLayers.begin();
      34         352 :     for (; oIter != m_oMapLayers.end(); ++oIter)
      35         265 :         delete oIter->second;
      36             : 
      37          87 :     if (m_bHasOwnership)
      38          87 :         delete m_poBaseDataSource;
      39         174 : }
      40             : 
      41          32 : int OGRMutexedDataSource::GetLayerCount()
      42             : {
      43          64 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
      44          64 :     return m_poBaseDataSource->GetLayerCount();
      45             : }
      46             : 
      47         425 : OGRLayer *OGRMutexedDataSource::WrapLayerIfNecessary(OGRLayer *poLayer)
      48             : {
      49         425 :     if (poLayer && m_bWrapLayersInMutexedLayer)
      50             :     {
      51         404 :         OGRLayer *poWrappedLayer = m_oMapLayers[poLayer];
      52         404 :         if (poWrappedLayer)
      53          13 :             poLayer = poWrappedLayer;
      54             :         else
      55             :         {
      56             :             OGRMutexedLayer *poMutexedLayer =
      57         391 :                 new OGRMutexedLayer(poLayer, FALSE, m_hGlobalMutex);
      58         391 :             m_oMapLayers[poLayer] = poMutexedLayer;
      59         391 :             m_oReverseMapLayers[poMutexedLayer] = poLayer;
      60         391 :             poLayer = poMutexedLayer;
      61             :         }
      62             :     }
      63         425 :     return poLayer;
      64             : }
      65             : 
      66          99 : OGRLayer *OGRMutexedDataSource::GetLayer(int iIndex)
      67             : {
      68         198 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
      69         198 :     return WrapLayerIfNecessary(m_poBaseDataSource->GetLayer(iIndex));
      70             : }
      71             : 
      72          44 : OGRLayer *OGRMutexedDataSource::GetLayerByName(const char *pszName)
      73             : {
      74          88 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
      75          88 :     return WrapLayerIfNecessary(m_poBaseDataSource->GetLayerByName(pszName));
      76             : }
      77             : 
      78           2 : OGRErr OGRMutexedDataSource::DeleteLayer(int iIndex)
      79             : {
      80           2 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
      81             :     OGRLayer *poLayer =
      82           2 :         m_bWrapLayersInMutexedLayer ? GetLayer(iIndex) : nullptr;
      83           2 :     OGRErr eErr = m_poBaseDataSource->DeleteLayer(iIndex);
      84           2 :     if (eErr == OGRERR_NONE && poLayer)
      85             :     {
      86             :         std::map<OGRLayer *, OGRMutexedLayer *>::iterator oIter =
      87           2 :             m_oMapLayers.find(poLayer);
      88           2 :         if (oIter != m_oMapLayers.end())
      89             :         {
      90           0 :             delete oIter->second;
      91           0 :             m_oReverseMapLayers.erase(oIter->second);
      92           0 :             m_oMapLayers.erase(oIter);
      93             :         }
      94             :     }
      95           4 :     return eErr;
      96             : }
      97             : 
      98           2 : bool OGRMutexedDataSource::IsLayerPrivate(int iLayer) const
      99             : {
     100           4 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     101           4 :     return m_poBaseDataSource->IsLayerPrivate(iLayer);
     102             : }
     103             : 
     104         126 : int OGRMutexedDataSource::TestCapability(const char *pszCap)
     105             : {
     106         252 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     107         252 :     return m_poBaseDataSource->TestCapability(pszCap);
     108             : }
     109             : 
     110             : OGRLayer *
     111         150 : OGRMutexedDataSource::ICreateLayer(const char *pszName,
     112             :                                    const OGRGeomFieldDefn *poGeomFieldDefn,
     113             :                                    CSLConstList papszOptions)
     114             : {
     115         300 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     116         150 :     return WrapLayerIfNecessary(m_poBaseDataSource->CreateLayer(
     117         300 :         pszName, poGeomFieldDefn, papszOptions));
     118             : }
     119             : 
     120           0 : OGRLayer *OGRMutexedDataSource::CopyLayer(OGRLayer *poSrcLayer,
     121             :                                           const char *pszNewName,
     122             :                                           char **papszOptions)
     123             : {
     124           0 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     125           0 :     return WrapLayerIfNecessary(
     126           0 :         m_poBaseDataSource->CopyLayer(poSrcLayer, pszNewName, papszOptions));
     127             : }
     128             : 
     129           2 : OGRStyleTable *OGRMutexedDataSource::GetStyleTable()
     130             : {
     131           4 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     132           4 :     return m_poBaseDataSource->GetStyleTable();
     133             : }
     134             : 
     135           0 : void OGRMutexedDataSource::SetStyleTableDirectly(OGRStyleTable *poStyleTable)
     136             : {
     137           0 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     138           0 :     m_poBaseDataSource->SetStyleTableDirectly(poStyleTable);
     139           0 : }
     140             : 
     141           7 : void OGRMutexedDataSource::SetStyleTable(OGRStyleTable *poStyleTable)
     142             : {
     143          14 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     144           7 :     m_poBaseDataSource->SetStyleTable(poStyleTable);
     145           7 : }
     146             : 
     147         132 : OGRLayer *OGRMutexedDataSource::ExecuteSQL(const char *pszStatement,
     148             :                                            OGRGeometry *poSpatialFilter,
     149             :                                            const char *pszDialect)
     150             : {
     151         264 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     152         132 :     return WrapLayerIfNecessary(m_poBaseDataSource->ExecuteSQL(
     153         396 :         pszStatement, poSpatialFilter, pszDialect));
     154             : }
     155             : 
     156         126 : void OGRMutexedDataSource::ReleaseResultSet(OGRLayer *poResultsSet)
     157             : {
     158         252 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     159         126 :     if (poResultsSet && m_bWrapLayersInMutexedLayer)
     160             :     {
     161             :         std::map<OGRMutexedLayer *, OGRLayer *>::iterator oIter =
     162             :             m_oReverseMapLayers.find(
     163         126 :                 cpl::down_cast<OGRMutexedLayer *>(poResultsSet));
     164         126 :         CPLAssert(oIter != m_oReverseMapLayers.end());
     165         126 :         delete poResultsSet;
     166         126 :         poResultsSet = oIter->second;
     167         126 :         m_oMapLayers.erase(poResultsSet);
     168         126 :         m_oReverseMapLayers.erase(oIter);
     169             :     }
     170             : 
     171         126 :     m_poBaseDataSource->ReleaseResultSet(poResultsSet);
     172         126 : }
     173             : 
     174           7 : CPLErr OGRMutexedDataSource::FlushCache(bool bAtClosing)
     175             : {
     176          14 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     177          14 :     return m_poBaseDataSource->FlushCache(bAtClosing);
     178             : }
     179             : 
     180           0 : OGRErr OGRMutexedDataSource::StartTransaction(int bForce)
     181             : {
     182           0 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     183           0 :     return m_poBaseDataSource->StartTransaction(bForce);
     184             : }
     185             : 
     186           0 : OGRErr OGRMutexedDataSource::CommitTransaction()
     187             : {
     188           0 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     189           0 :     return m_poBaseDataSource->CommitTransaction();
     190             : }
     191             : 
     192           0 : OGRErr OGRMutexedDataSource::RollbackTransaction()
     193             : {
     194           0 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     195           0 :     return m_poBaseDataSource->RollbackTransaction();
     196             : }
     197             : 
     198           2 : char **OGRMutexedDataSource::GetMetadata(const char *pszDomain)
     199             : {
     200           4 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     201           4 :     return m_poBaseDataSource->GetMetadata(pszDomain);
     202             : }
     203             : 
     204           0 : CPLErr OGRMutexedDataSource::SetMetadata(char **papszMetadata,
     205             :                                          const char *pszDomain)
     206             : {
     207           0 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     208           0 :     return m_poBaseDataSource->SetMetadata(papszMetadata, pszDomain);
     209             : }
     210             : 
     211         302 : const char *OGRMutexedDataSource::GetMetadataItem(const char *pszName,
     212             :                                                   const char *pszDomain)
     213             : {
     214         604 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     215         604 :     return m_poBaseDataSource->GetMetadataItem(pszName, pszDomain);
     216             : }
     217             : 
     218           0 : CPLErr OGRMutexedDataSource::SetMetadataItem(const char *pszName,
     219             :                                              const char *pszValue,
     220             :                                              const char *pszDomain)
     221             : {
     222           0 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     223           0 :     return m_poBaseDataSource->SetMetadataItem(pszName, pszValue, pszDomain);
     224             : }
     225             : 
     226             : std::vector<std::string>
     227           2 : OGRMutexedDataSource::GetFieldDomainNames(CSLConstList papszOptions) const
     228             : {
     229           4 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     230           4 :     return m_poBaseDataSource->GetFieldDomainNames(papszOptions);
     231             : }
     232             : 
     233             : const OGRFieldDomain *
     234          17 : OGRMutexedDataSource::GetFieldDomain(const std::string &name) const
     235             : {
     236          34 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     237          34 :     return m_poBaseDataSource->GetFieldDomain(name);
     238             : }
     239             : 
     240           4 : bool OGRMutexedDataSource::AddFieldDomain(
     241             :     std::unique_ptr<OGRFieldDomain> &&domain, std::string &failureReason)
     242             : {
     243           8 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     244           8 :     return m_poBaseDataSource->AddFieldDomain(std::move(domain), failureReason);
     245             : }
     246             : 
     247           2 : bool OGRMutexedDataSource::DeleteFieldDomain(const std::string &name,
     248             :                                              std::string &failureReason)
     249             : {
     250           4 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     251           4 :     return m_poBaseDataSource->DeleteFieldDomain(name, failureReason);
     252             : }
     253             : 
     254           1 : bool OGRMutexedDataSource::UpdateFieldDomain(
     255             :     std::unique_ptr<OGRFieldDomain> &&domain, std::string &failureReason)
     256             : {
     257           2 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     258           1 :     return m_poBaseDataSource->UpdateFieldDomain(std::move(domain),
     259           2 :                                                  failureReason);
     260             : }
     261             : 
     262             : std::vector<std::string>
     263           2 : OGRMutexedDataSource::GetRelationshipNames(CSLConstList papszOptions) const
     264             : {
     265           4 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     266           4 :     return m_poBaseDataSource->GetRelationshipNames(papszOptions);
     267             : }
     268             : 
     269             : const GDALRelationship *
     270           8 : OGRMutexedDataSource::GetRelationship(const std::string &name) const
     271             : {
     272          16 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     273          16 :     return m_poBaseDataSource->GetRelationship(name);
     274             : }
     275             : 
     276           1 : std::shared_ptr<GDALGroup> OGRMutexedDataSource::GetRootGroup() const
     277             : {
     278           2 :     CPLMutexHolderOptionalLockD(m_hGlobalMutex);
     279           2 :     return m_poBaseDataSource->GetRootGroup();
     280             : }
     281             : 
     282             : #endif /* #ifndef DOXYGEN_SKIP */