LCOV - code coverage report
Current view: top level - shell/source/unix/sysshell - recently_used_file_handler.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 198 0.0 %
Date: 2014-04-14 Functions: 0 44 0.0 %
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 <sal/config.h>
      21             : 
      22             : #include "boost/noncopyable.hpp"
      23             : #include "osl/process.h"
      24             : #include "rtl/ustring.hxx"
      25             : #include "rtl/string.hxx"
      26             : #include "rtl/strbuf.hxx"
      27             : 
      28             : #include "osl/thread.h"
      29             : #include "recently_used_file.hxx"
      30             : 
      31             : #include "internal/xml_parser.hxx"
      32             : #include "internal/i_xml_parser_event_handler.hxx"
      33             : 
      34             : #include <map>
      35             : #include <vector>
      36             : #include <algorithm>
      37             : #include <functional>
      38             : #include <string.h>
      39             : 
      40             : namespace /* private */ {
      41             :     typedef std::vector<string_t> string_container_t;
      42             : 
      43             :     #define TAG_RECENT_FILES "RecentFiles"
      44             :     #define TAG_RECENT_ITEM  "RecentItem"
      45             :     #define TAG_URI          "URI"
      46             :     #define TAG_MIME_TYPE    "Mime-Type"
      47             :     #define TAG_TIMESTAMP    "Timestamp"
      48             :     #define TAG_PRIVATE      "Private"
      49             :     #define TAG_GROUPS       "Groups"
      50             :     #define TAG_GROUP        "Group"
      51             : 
      52             : 
      53             :     // compare two string_t's case insensitive, may also be done
      54             :     // by specifying special traits for the string type but in this
      55             :     // case it's easier to do it this way
      56             :     struct str_icase_cmp :
      57             :         public std::binary_function<string_t, string_t, bool>
      58             :     {
      59           0 :         bool operator() (const string_t& s1, const string_t& s2) const
      60           0 :         { return (0 == strcasecmp(s1.c_str(), s2.c_str())); }
      61             :     };
      62             : 
      63             : 
      64           0 :     struct recently_used_item
      65             :     {
      66           0 :         recently_used_item()
      67             :             : timestamp_(-1)
      68           0 :             , is_private_(false)
      69           0 :         {}
      70             : 
      71           0 :         recently_used_item(
      72             :             const string_t& uri,
      73             :             const string_t& mime_type,
      74             :             const string_container_t& groups,
      75             :             bool is_private = false) :
      76             :             uri_(uri),
      77             :             mime_type_(mime_type),
      78             :             is_private_(is_private),
      79           0 :             groups_(groups)
      80             :         {
      81           0 :             timestamp_ = time(NULL);
      82           0 :         }
      83             : 
      84           0 :         void set_uri(const string_t& character)
      85           0 :         { uri_ = character; }
      86             : 
      87           0 :         void set_mime_type(const string_t& character)
      88           0 :         { mime_type_ = character; }
      89             : 
      90           0 :         void set_timestamp(const string_t& character)
      91             :         {
      92             :             time_t t;
      93           0 :             if (sscanf(character.c_str(), "%ld", &t) != 1)
      94           0 :                 timestamp_ = -1;
      95             :             else
      96           0 :                 timestamp_ = t;
      97           0 :         }
      98             : 
      99           0 :         void set_is_private(SAL_UNUSED_PARAMETER const string_t& /*character*/)
     100           0 :         { is_private_ = true; }
     101             : 
     102           0 :         void set_groups(const string_t& character)
     103           0 :         { groups_.push_back(character); }
     104             : 
     105           0 :         void set_nothing(SAL_UNUSED_PARAMETER const string_t& /*character*/)
     106           0 :         {}
     107             : 
     108           0 :         bool has_groups() const
     109             :         {
     110           0 :             return !groups_.empty();
     111             :         }
     112             : 
     113           0 :         bool has_group(const string_t& name) const
     114             :         {
     115           0 :             string_container_t::const_iterator iter_end = groups_.end();
     116           0 :             return (has_groups() &&
     117           0 :                     iter_end != std::find_if(
     118             :                         groups_.begin(), iter_end,
     119           0 :                         std::bind2nd(str_icase_cmp(), name)));
     120             :         }
     121             : 
     122           0 :         void write_xml(const recently_used_file& file) const
     123             :         {
     124           0 :             write_xml_start_tag(TAG_RECENT_ITEM, file, true);
     125           0 :             write_xml_tag(TAG_URI, uri_, file);
     126           0 :             write_xml_tag(TAG_MIME_TYPE, mime_type_, file);
     127             : 
     128           0 :             OString ts = OString::number(timestamp_);
     129           0 :             write_xml_tag(TAG_TIMESTAMP, ts.getStr(), file);
     130             : 
     131           0 :             if (is_private_)
     132           0 :                 write_xml_tag(TAG_PRIVATE, file);
     133             : 
     134           0 :             if (has_groups())
     135             :             {
     136           0 :                 write_xml_start_tag(TAG_GROUPS, file, true);
     137             : 
     138           0 :                 string_container_t::const_iterator iter = groups_.begin();
     139           0 :                 string_container_t::const_iterator iter_end = groups_.end();
     140             : 
     141           0 :                 for ( ; iter != iter_end; ++iter)
     142           0 :                     write_xml_tag(TAG_GROUP, (*iter), file);
     143             : 
     144           0 :                 write_xml_end_tag(TAG_GROUPS, file);
     145             :             }
     146           0 :             write_xml_end_tag(TAG_RECENT_ITEM, file);
     147           0 :         }
     148             : 
     149           0 :         static OString escape_content(const string_t &text)
     150             :         {
     151           0 :             OStringBuffer aBuf;
     152           0 :             for (sal_uInt32 i = 0; i < text.length(); i++)
     153             :             {
     154           0 :                 switch (text[i])
     155             :                 {
     156           0 :                     case '&':  aBuf.append("&amp;");  break;
     157           0 :                     case '<':  aBuf.append("&lt;");   break;
     158           0 :                     case '>':  aBuf.append("&gt;");   break;
     159           0 :                     case '\'': aBuf.append("&apos;"); break;
     160           0 :                     case '"':  aBuf.append("&quot;"); break;
     161           0 :                     default:   aBuf.append(text[i]);  break;
     162             :                 }
     163             :             }
     164           0 :             return aBuf.makeStringAndClear();
     165             :         }
     166             : 
     167           0 :         void write_xml_tag(const string_t& name, const string_t& value, const recently_used_file& file) const
     168             :         {
     169           0 :             write_xml_start_tag(name, file);
     170           0 :             OString escaped = escape_content (value);
     171           0 :             file.write(escaped.getStr(), escaped.getLength());
     172           0 :             write_xml_end_tag(name, file);
     173           0 :         }
     174             : 
     175           0 :         void write_xml_tag(const string_t& name, const recently_used_file& file) const
     176             :         {
     177           0 :             file.write("<", 1);
     178           0 :             file.write(name.c_str(), name.length());
     179           0 :             file.write("/>\n", 3);
     180           0 :         }
     181             : 
     182           0 :         void write_xml_start_tag(const string_t& name, const recently_used_file& file, bool linefeed = false) const
     183             :         {
     184           0 :             file.write("<", 1);
     185           0 :             file.write(name.c_str(), name.length());
     186           0 :             if (linefeed)
     187           0 :                 file.write(">\n", 2);
     188             :             else
     189           0 :                 file.write(">", 1);
     190           0 :         }
     191             : 
     192           0 :         void write_xml_end_tag(const string_t& name, const recently_used_file& file) const
     193             :         {
     194           0 :             file.write("</", 2);
     195           0 :             file.write(name.c_str(), name.length());
     196           0 :             file.write(">\n", 2);
     197           0 :         }
     198             : 
     199             :         string_t uri_;
     200             :         string_t mime_type_;
     201             :         time_t timestamp_;
     202             :         bool is_private_;
     203             :         string_container_t groups_;
     204             :     };
     205             : 
     206             :     typedef std::vector<recently_used_item*> recently_used_item_list_t;
     207             :     typedef void (recently_used_item::* SET_COMMAND)(const string_t&);
     208             : 
     209             :     // thrown if we encounter xml tags that we do not know
     210             :     class unknown_xml_format_exception {};
     211             : 
     212           0 :     class recently_used_file_filter:
     213             :         public i_xml_parser_event_handler, private boost::noncopyable
     214             :     {
     215             :     public:
     216           0 :         recently_used_file_filter(recently_used_item_list_t& item_list) :
     217             :             item_(NULL),
     218           0 :             item_list_(item_list)
     219             :         {
     220           0 :             named_command_map_[TAG_RECENT_FILES] = &recently_used_item::set_nothing;
     221           0 :             named_command_map_[TAG_RECENT_ITEM]  = &recently_used_item::set_nothing;
     222           0 :             named_command_map_[TAG_URI]          = &recently_used_item::set_uri;
     223           0 :             named_command_map_[TAG_MIME_TYPE]    = &recently_used_item::set_mime_type;
     224           0 :             named_command_map_[TAG_TIMESTAMP]    = &recently_used_item::set_timestamp;
     225           0 :             named_command_map_[TAG_PRIVATE]      = &recently_used_item::set_is_private;
     226           0 :             named_command_map_[TAG_GROUPS]       = &recently_used_item::set_nothing;
     227           0 :             named_command_map_[TAG_GROUP]        = &recently_used_item::set_groups;
     228           0 :         }
     229             : 
     230           0 :         virtual void start_element(
     231             :             const string_t& /*raw_name*/,
     232             :             const string_t& local_name,
     233             :             const xml_tag_attribute_container_t& /*attributes*/) SAL_OVERRIDE
     234             :         {
     235           0 :             if ((local_name == TAG_RECENT_ITEM) && (NULL == item_))
     236           0 :                 item_ = new recently_used_item;
     237           0 :         }
     238             : 
     239           0 :         virtual void end_element(const string_t& /*raw_name*/, const string_t& local_name) SAL_OVERRIDE
     240             :         {
     241             :             // check for end tags w/o start tag
     242           0 :             if( local_name != TAG_RECENT_FILES && NULL == item_ )
     243           0 :                 return; // will result in an XML parser error anyway
     244             : 
     245           0 :             if (named_command_map_.find(local_name) != named_command_map_.end())
     246           0 :                 (item_->*named_command_map_[local_name])(current_element_);
     247             :             else
     248             :             {
     249           0 :                 delete item_;
     250           0 :                 throw unknown_xml_format_exception();
     251             :             }
     252             : 
     253           0 :             if (local_name == TAG_RECENT_ITEM)
     254             :             {
     255           0 :                 item_list_.push_back(item_);
     256           0 :                 item_ = NULL;
     257             :             }
     258           0 :             current_element_.clear();
     259             :         }
     260             : 
     261           0 :         virtual void characters(const string_t& character) SAL_OVERRIDE
     262             :         {
     263           0 :             if (character != "\n")
     264           0 :                 current_element_ += character;
     265           0 :         }
     266             : 
     267           0 :         virtual void start_document() SAL_OVERRIDE {}
     268           0 :         virtual void end_document() SAL_OVERRIDE   {}
     269             : 
     270           0 :         virtual void ignore_whitespace(const string_t& /*whitespaces*/) SAL_OVERRIDE
     271           0 :         {}
     272             : 
     273           0 :         virtual void processing_instruction(
     274             :             const string_t& /*target*/, const string_t& /*data*/) SAL_OVERRIDE
     275           0 :         {}
     276             : 
     277           0 :         virtual void comment(const string_t& /*comment*/) SAL_OVERRIDE
     278           0 :         {}
     279             :     private:
     280             :         recently_used_item* item_;
     281             :         std::map<string_t, SET_COMMAND> named_command_map_;
     282             :         string_t current_element_;
     283             :         recently_used_item_list_t& item_list_;
     284             :     };
     285             : 
     286             : 
     287           0 :     void read_recently_used_items(
     288             :         recently_used_file& file,
     289             :         recently_used_item_list_t& item_list)
     290             :     {
     291           0 :         xml_parser xparser;
     292           0 :         recently_used_file_filter ruff(item_list);
     293             : 
     294           0 :         xparser.set_document_handler(&ruff);
     295             : 
     296             :         char buff[16384];
     297           0 :         while (!file.eof())
     298             :         {
     299           0 :             if (size_t length = file.read(buff, sizeof(buff)))
     300           0 :                 xparser.parse(buff, length, file.eof());
     301           0 :         }
     302           0 :     }
     303             : 
     304             : 
     305             :     // The file ~/.recently_used shall not contain more than 500
     306             :     // entries (see www.freedesktop.org)
     307             :     const int MAX_RECENTLY_USED_ITEMS = 500;
     308             : 
     309             :     class recent_item_writer
     310             :     {
     311             :     public:
     312           0 :         recent_item_writer(
     313             :             recently_used_file& file,
     314             :             int max_items_to_write = MAX_RECENTLY_USED_ITEMS) :
     315             :             file_(file),
     316             :             max_items_to_write_(max_items_to_write),
     317           0 :             items_written_(0)
     318           0 :         {}
     319             : 
     320           0 :         void operator() (const recently_used_item* item)
     321             :         {
     322           0 :             if (items_written_++ < max_items_to_write_)
     323           0 :                 item->write_xml(file_);
     324           0 :         }
     325             :     private:
     326             :         recently_used_file& file_;
     327             :         int max_items_to_write_;
     328             :         int items_written_;
     329             :     };
     330             : 
     331             : 
     332             :     const char* XML_HEADER = "<?xml version=\"1.0\"?>\n<RecentFiles>\n";
     333             :     const char* XML_FOOTER = "</RecentFiles>";
     334             : 
     335             : 
     336             :     // assumes that the list is ordered decreasing
     337           0 :     void write_recently_used_items(
     338             :         recently_used_file& file,
     339             :         recently_used_item_list_t& item_list)
     340             :     {
     341           0 :         if (!item_list.empty())
     342             :         {
     343           0 :             file.truncate();
     344           0 :             file.reset();
     345             : 
     346           0 :             file.write(XML_HEADER, strlen(XML_HEADER));
     347             : 
     348             :             std::for_each(
     349             :                 item_list.begin(),
     350             :                 item_list.end(),
     351           0 :                 recent_item_writer(file));
     352             : 
     353           0 :             file.write(XML_FOOTER, strlen(XML_FOOTER));
     354             :         }
     355           0 :     }
     356             : 
     357             : 
     358             :     struct delete_recently_used_item
     359             :     {
     360           0 :         void operator() (const recently_used_item* item) const
     361           0 :         { delete item; }
     362             :     };
     363             : 
     364             : 
     365           0 :     void recently_used_item_list_clear(recently_used_item_list_t& item_list)
     366             :     {
     367             :         std::for_each(
     368             :             item_list.begin(),
     369             :             item_list.end(),
     370           0 :             delete_recently_used_item());
     371           0 :         item_list.clear();
     372           0 :     }
     373             : 
     374             : 
     375           0 :     class find_item_predicate
     376             :     {
     377             :     public:
     378           0 :         find_item_predicate(const string_t& uri) :
     379           0 :             uri_(uri)
     380           0 :         {}
     381             : 
     382           0 :         bool operator() (const recently_used_item* item) const
     383           0 :             { return (item->uri_ == uri_); }
     384             :     private:
     385             :         string_t uri_;
     386             :     };
     387             : 
     388             : 
     389             :     struct greater_recently_used_item
     390             :     {
     391           0 :         bool operator ()(const recently_used_item* lhs, const recently_used_item* rhs) const
     392           0 :         { return (lhs->timestamp_ > rhs->timestamp_); }
     393             :     };
     394             : 
     395             : 
     396             :     const char* GROUP_OOO         = "openoffice.org";
     397             :     const char* GROUP_STAR_OFFICE = "staroffice";
     398             :     const char* GROUP_STAR_SUITE  = "starsuite";
     399             : 
     400             : 
     401           0 :     void recently_used_item_list_add(
     402             :         recently_used_item_list_t& item_list, const OUString& file_url, const OUString& mime_type)
     403             :     {
     404           0 :         OString f = OUStringToOString(file_url, RTL_TEXTENCODING_UTF8);
     405             : 
     406             :         recently_used_item_list_t::iterator iter =
     407             :             std::find_if(
     408             :                 item_list.begin(),
     409             :                 item_list.end(),
     410           0 :                 find_item_predicate(f.getStr()));
     411             : 
     412           0 :         if (iter != item_list.end())
     413             :         {
     414           0 :             (*iter)->timestamp_ = time(NULL);
     415             : 
     416           0 :             if (!(*iter)->has_group(GROUP_OOO))
     417           0 :                 (*iter)->groups_.push_back(GROUP_OOO);
     418           0 :             if (!(*iter)->has_group(GROUP_STAR_OFFICE))
     419           0 :                 (*iter)->groups_.push_back(GROUP_STAR_OFFICE);
     420           0 :             if (!(*iter)->has_group(GROUP_STAR_SUITE))
     421           0 :                 (*iter)->groups_.push_back(GROUP_STAR_SUITE);
     422             :         }
     423             :         else
     424             :         {
     425           0 :             string_container_t groups;
     426           0 :             groups.push_back(GROUP_OOO);
     427           0 :             groups.push_back(GROUP_STAR_OFFICE);
     428           0 :             groups.push_back(GROUP_STAR_SUITE);
     429             : 
     430           0 :             string_t uri(f.getStr());
     431           0 :             string_t mimetype(OUStringToOString(mime_type, osl_getThreadTextEncoding()).getStr());
     432             : 
     433           0 :             if (mimetype.length() == 0)
     434           0 :                 mimetype = "application/octet-stream";
     435             : 
     436           0 :             item_list.push_back(new recently_used_item(uri, mimetype, groups));
     437             :         }
     438             : 
     439             :         // sort decreasing after the timestamp
     440             :         // so that the newest items appear first
     441             :         std::sort(
     442             :             item_list.begin(),
     443             :             item_list.end(),
     444           0 :             greater_recently_used_item());
     445           0 :     }
     446             : 
     447             : 
     448             :     struct cleanup_guard
     449             :     {
     450           0 :         cleanup_guard(recently_used_item_list_t& item_list) :
     451           0 :             item_list_(item_list)
     452           0 :         {}
     453           0 :         ~cleanup_guard()
     454           0 :         { recently_used_item_list_clear(item_list_); }
     455             : 
     456             :         recently_used_item_list_t& item_list_;
     457             :     };
     458             : 
     459             : } // namespace private
     460             : 
     461             : /*
     462             :    example (see http::www.freedesktop.org):
     463             :     <?xml version="1.0"?>
     464             :                 <RecentFiles>
     465             :                      <RecentItem>
     466             :                         <URI>file:///home/federico/gedit.txt</URI>
     467             :                         <Mime-Type>text/plain</Mime-Type>
     468             :                         <Timestamp>1046485966</Timestamp>
     469             :                         <Groups>
     470             :                             <Group>gedit</Group>
     471             :                         </Groups>
     472             :                     </RecentItem>
     473             :                     <RecentItem>
     474             :                         <URI>file:///home/federico/gedit-2.2.0.tar.bz2</URI>
     475             :                         <Mime-Type>application/x-bzip</Mime-Type>
     476             :                         <Timestamp>1046209851</Timestamp>
     477             :                         <Private/>
     478             :                         <Groups>
     479             :                         </Groups>
     480             :                     </RecentItem>
     481             :                 </RecentFiles>
     482             : */
     483             : 
     484             : extern "C" SAL_DLLPUBLIC_EXPORT
     485           0 : void add_to_recently_used_file_list(const OUString& file_url,
     486             :         const OUString& mime_type)
     487             : {
     488             :     try
     489             :     {
     490           0 :         recently_used_file ruf;
     491           0 :         recently_used_item_list_t item_list;
     492           0 :         cleanup_guard guard(item_list);
     493             : 
     494           0 :         read_recently_used_items(ruf, item_list);
     495           0 :         recently_used_item_list_add(item_list, file_url, mime_type);
     496           0 :         write_recently_used_items(ruf, item_list);
     497             :     }
     498           0 :     catch(const char* ex)
     499             :     {
     500             :         OSL_FAIL(ex);
     501             :     }
     502           0 :     catch(const xml_parser_exception&)
     503             :     {
     504             :         OSL_FAIL("XML parser error");
     505             :     }
     506           0 :     catch(const unknown_xml_format_exception&)
     507             :     {
     508             :         OSL_FAIL("XML format unknown");
     509             :     }
     510           0 : }
     511             : 
     512             : 
     513             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10