LCOV - code coverage report
Current view: top level - xmloff/source/forms - property_meta_data.cxx (source / functions) Hit Total Coverage
Test: commit 10e77ab3ff6f4314137acd6e2702a6e5c1ce1fae Lines: 49 86 57.0 %
Date: 2014-11-03 Functions: 8 12 66.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include "property_description.hxx"
      21             : #include "property_meta_data.hxx"
      22             : #include "forms/form_handler_factory.hxx"
      23             : #include "strings.hxx"
      24             : #include <xmloff/xmltoken.hxx>
      25             : #include <xmloff/xmlnmspe.hxx>
      26             : 
      27             : #include <tools/debug.hxx>
      28             : 
      29             : #include <boost/unordered_map.hpp>
      30             : 
      31             : namespace xmloff { namespace metadata
      32             : {
      33             : 
      34             :     using namespace ::xmloff::token;
      35             : 
      36             : #define FORM_SINGLE_PROPERTY( id, att ) \
      37             :     PropertyDescription( PROPERTY_##id, XML_NAMESPACE_FORM, att, &FormHandlerFactory::getFormPropertyHandler, PID_##id, NO_GROUP )
      38             : 
      39             :     //= property meta data
      40             :     namespace
      41             :     {
      42          14 :         const PropertyDescription* lcl_getPropertyMetaData()
      43             :         {
      44             :             static const PropertyDescription s_propertyMetaData[] =
      45             :             {
      46             :                 FORM_SINGLE_PROPERTY( DATE_MIN,        XML_MIN_VALUE        ),
      47             :                 FORM_SINGLE_PROPERTY( DATE_MAX,        XML_MAX_VALUE        ),
      48             :                 FORM_SINGLE_PROPERTY( DEFAULT_DATE,    XML_VALUE            ),
      49             :                 FORM_SINGLE_PROPERTY( DATE,            XML_CURRENT_VALUE    ),
      50             :                 FORM_SINGLE_PROPERTY( TIME_MIN,        XML_MIN_VALUE        ),
      51             :                 FORM_SINGLE_PROPERTY( TIME_MAX,        XML_MAX_VALUE        ),
      52             :                 FORM_SINGLE_PROPERTY( DEFAULT_TIME,    XML_VALUE            ),
      53             :                 FORM_SINGLE_PROPERTY( TIME,            XML_CURRENT_VALUE    ),
      54             : 
      55             :                 PropertyDescription()
      56          24 :             };
      57          14 :             return s_propertyMetaData;
      58             :         }
      59             :     }
      60             : 
      61             :     namespace
      62             :     {
      63             :         // TODO: instead of having all of the below static, it should be some per-instance data. This way, the
      64             :         // approach used here would scale much better.
      65             :         // That is, if you have multiple "meta data instances", which manage a small, but closed set of properties,
      66             :         // then looking looking through those multiple instances would probably be faster than searching within
      67             :         // one big instance, since in this case, every instance can quickly decide whether it is responsible
      68             :         // for some attribute or property, and otherwise delegate to the next instance.
      69             : 
      70             :         typedef ::boost::unordered_map< OUString, const PropertyDescription*, OUStringHash > DescriptionsByName;
      71             : 
      72           0 :         const DescriptionsByName& lcl_getPropertyDescriptions()
      73             :         {
      74             :             DBG_TESTSOLARMUTEX();
      75           0 :             static DescriptionsByName s_propertyDescriptionsByName;
      76           0 :             if ( s_propertyDescriptionsByName.empty() )
      77             :             {
      78           0 :                 const PropertyDescription* desc = lcl_getPropertyMetaData();
      79           0 :                 while ( !desc->propertyName.isEmpty() )
      80             :                 {
      81           0 :                     s_propertyDescriptionsByName[ desc->propertyName ] = desc;
      82           0 :                     ++desc;
      83             :                 }
      84             :             }
      85           0 :             return s_propertyDescriptionsByName;
      86             :         }
      87             : 
      88             :         typedef ::std::map< PropertyGroup, PropertyDescriptionList > IndexedPropertyGroups;
      89             : 
      90           0 :         const IndexedPropertyGroups& lcl_getIndexedPropertyGroups()
      91             :         {
      92             :             DBG_TESTSOLARMUTEX();
      93           0 :             static IndexedPropertyGroups s_indexedPropertyGroups;
      94           0 :             if ( s_indexedPropertyGroups.empty() )
      95             :             {
      96           0 :                 const PropertyDescription* desc = lcl_getPropertyMetaData();
      97           0 :                 while ( !desc->propertyName.isEmpty() )
      98             :                 {
      99           0 :                     if ( desc->propertyGroup != NO_GROUP )
     100           0 :                         s_indexedPropertyGroups[ desc->propertyGroup ].push_back( desc );
     101           0 :                     ++desc;
     102             :                 }
     103             :             }
     104           0 :             return s_indexedPropertyGroups;
     105             :         }
     106             : 
     107             :         typedef ::boost::unordered_map< OUString, XMLTokenEnum, OUStringHash > ReverseTokenLookup;
     108             : 
     109         338 :         const ReverseTokenLookup& getReverseTokenLookup()
     110             :         {
     111             :             DBG_TESTSOLARMUTEX();
     112         338 :             static ReverseTokenLookup s_reverseTokenLookup;
     113         338 :             if ( s_reverseTokenLookup.empty() )
     114             :             {
     115          10 :                 const PropertyDescription* desc = lcl_getPropertyMetaData();
     116         100 :                 while ( !desc->propertyName.isEmpty() )
     117             :                 {
     118          80 :                     s_reverseTokenLookup[ token::GetXMLToken( desc->attribute.attributeToken ) ] = desc->attribute.attributeToken;
     119          80 :                     ++desc;
     120             :                 }
     121             :             }
     122         338 :             return s_reverseTokenLookup;
     123             :         }
     124             : 
     125             :         struct AttributeHash : public ::std::unary_function< AttributeDescription, size_t >
     126             :         {
     127          20 :             size_t operator()( const AttributeDescription& i_attribute ) const
     128             :             {
     129          20 :                 return size_t( i_attribute.attributeToken * 100 ) + size_t( i_attribute.namespacePrefix );
     130             :             }
     131             :         };
     132             : 
     133             :         typedef ::boost::unordered_multimap< AttributeDescription, PropertyGroup, AttributeHash > AttributeGroups;
     134             : 
     135           2 :         const AttributeGroups& lcl_getAttributeGroups()
     136             :         {
     137             :             DBG_TESTSOLARMUTEX();
     138           2 :             static AttributeGroups s_attributeGroups;
     139           2 :             if ( s_attributeGroups.empty() )
     140             :             {
     141           2 :                 const PropertyDescription* desc = lcl_getPropertyMetaData();
     142          20 :                 while ( !desc->propertyName.isEmpty() )
     143             :                 {
     144          16 :                     if ( desc->propertyGroup != NO_GROUP )
     145           0 :                         s_attributeGroups.insert( AttributeGroups::value_type( desc->attribute, desc->propertyGroup ) );
     146          16 :                     ++desc;
     147             :                 }
     148             :             }
     149           2 :             return s_attributeGroups;
     150             :         }
     151             : 
     152             :         typedef ::boost::unordered_map< AttributeDescription, PropertyGroups, AttributeHash > AttributesWithoutGroup;
     153             : 
     154           2 :         const AttributesWithoutGroup& lcl_getAttributesWithoutGroups()
     155             :         {
     156             :             DBG_TESTSOLARMUTEX();
     157           2 :             static AttributesWithoutGroup s_attributesWithoutGroup;
     158           2 :             if ( s_attributesWithoutGroup.empty() )
     159             :             {
     160           2 :                 const PropertyDescription* desc = lcl_getPropertyMetaData();
     161          20 :                 while ( !desc->propertyName.isEmpty() )
     162             :                 {
     163          16 :                     if ( desc->propertyGroup == NO_GROUP )
     164             :                     {
     165          16 :                         PropertyDescriptionList singleElementList;
     166          16 :                         singleElementList.push_back( desc );
     167             : 
     168          16 :                         s_attributesWithoutGroup[ desc->attribute ].push_back( singleElementList );
     169             :                     }
     170          16 :                     ++desc;
     171             :                 }
     172             :             }
     173           2 :             return s_attributesWithoutGroup;
     174             :         }
     175             :     }
     176             : 
     177           0 :     const PropertyDescription* getPropertyDescription( const OUString& i_propertyName )
     178             :     {
     179           0 :         const DescriptionsByName& rAllDescriptions( lcl_getPropertyDescriptions() );
     180           0 :         DescriptionsByName::const_iterator pos = rAllDescriptions.find( i_propertyName );
     181           0 :         if ( pos != rAllDescriptions.end() )
     182           0 :             return pos->second;
     183           0 :         return NULL;
     184             :     }
     185             : 
     186           0 :     void getPropertyGroup( const PropertyGroup i_propertyGroup, PropertyDescriptionList& o_propertyDescriptions )
     187             :     {
     188             :         OSL_ENSURE( i_propertyGroup != NO_GROUP, "xmloff::metadata::getPropertyGroup: illegal group!" );
     189             : 
     190           0 :         const IndexedPropertyGroups& rPropertyGroups( lcl_getIndexedPropertyGroups() );
     191           0 :         const IndexedPropertyGroups::const_iterator pos = rPropertyGroups.find( i_propertyGroup );
     192           0 :         if ( pos != rPropertyGroups.end() )
     193           0 :             o_propertyDescriptions = pos->second;
     194           0 :     }
     195             : 
     196           2 :     void getPropertyGroupList( const AttributeDescription& i_attribute, PropertyGroups& o_propertyGroups )
     197             :     {
     198           2 :         const AttributeGroups& rAttributeGroups = lcl_getAttributeGroups();
     199             : 
     200             :         ::std::pair< AttributeGroups::const_iterator, AttributeGroups::const_iterator >
     201           2 :             range = rAttributeGroups.equal_range( i_attribute );
     202             : 
     203           2 :         if ( range.first == range.second )
     204             :         {
     205             :             // the attribute is not used for any non-trivial group, which means it is mapped directly to
     206             :             // a single property
     207           2 :             const AttributesWithoutGroup& attributesWithoutGroups( lcl_getAttributesWithoutGroups() );
     208           2 :             const AttributesWithoutGroup::const_iterator pos = attributesWithoutGroups.find( i_attribute );
     209           2 :             if ( pos != attributesWithoutGroups.end() )
     210           2 :                 o_propertyGroups = pos->second;
     211             :         }
     212             :         else
     213             :         {
     214           0 :             const IndexedPropertyGroups& rPropertyGroups = lcl_getIndexedPropertyGroups();
     215           0 :             for ( AttributeGroups::const_iterator group = range.first; group != range.second; ++group )
     216             :             {
     217           0 :                 const PropertyGroup propGroup = group->second;
     218           0 :                 const IndexedPropertyGroups::const_iterator groupPos = rPropertyGroups.find( propGroup );
     219           0 :                 if( groupPos == rPropertyGroups.end() )
     220             :                 {
     221             :                     SAL_WARN( "xmloff.forms", "getPropertyGroupList: inconsistency!" );
     222           0 :                     continue;
     223             :                 }
     224             : 
     225           0 :                 o_propertyGroups.push_back( groupPos->second );
     226             :             }
     227             :         }
     228           2 :     }
     229             : 
     230         338 :     AttributeDescription getAttributeDescription( const sal_uInt16 i_namespacePrefix, const OUString& i_attributeName )
     231             :     {
     232         338 :         AttributeDescription attribute;
     233         338 :         const ReverseTokenLookup& rTokenLookup( getReverseTokenLookup() );
     234         338 :         const ReverseTokenLookup::const_iterator pos = rTokenLookup.find( i_attributeName );
     235         338 :         if ( pos != rTokenLookup.end() )
     236             :         {
     237           2 :             attribute.namespacePrefix = i_namespacePrefix;
     238           2 :             attribute.attributeToken = pos->second;
     239             :         }
     240         338 :         return attribute;
     241             :     }
     242             : 
     243             : } } // namespace xmloff::metadata
     244             : 
     245             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10