libs/pbd/stateful.cc

   1 /*
   2     Copyright (C) 2000-2001 Paul Davis
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17
  18     $Id: stateful.cc 629 2006-06-21 23:01:03Z paul $
  19 */
  20
  21 #include <unistd.h>
  22
  23 #include <pbd/stateful.h>
  24 #include <pbd/filesystem.h>
  25 #include <pbd/xml++.h>
  26 #include <pbd/error.h>
  27
  28 #include "i18n.h"
  29
  30 namespace PBD {
  31
  32 Stateful::Stateful ()
  33 {
  34         _extra_xml = 0;
  35         _instant_xml = 0;
  36 }
  37
  38 Stateful::~Stateful ()
  39 {
  40         // Do not delete _extra_xml.  The use of add_child_nocopy()
  41         // means it needs to live on indefinately.
  42
  43         delete _instant_xml;
  44 }
  45
  46 void
  47 Stateful::add_extra_xml (XMLNode& node)
  48 {
  49         if (_extra_xml == 0) {
  50                 _extra_xml = new XMLNode ("extra");
  51         }
  52
  53         _extra_xml->remove_nodes (node.name());
  54         _extra_xml->add_child_nocopy (node);
  55 }
  56
  57 XMLNode *
  58 Stateful::extra_xml (const string& str)
  59 {
  60         if (_extra_xml == 0) {
  61                 return 0;
  62         }
  63
  64         const XMLNodeList& nlist = _extra_xml->children();
  65         XMLNodeConstIterator i;
  66
  67         for (i = nlist.begin(); i != nlist.end(); ++i) {
  68                 if ((*i)->name() == str) {
  69                         return (*i);
  70                 }
  71         }
  72
  73         return 0;
  74 }
  75
  76 void
  77 Stateful::add_instant_xml (XMLNode& node, const sys::path& directory_path)
  78 {
  79         sys::create_directories (directory_path); // may throw
  80
  81         if (_instant_xml == 0) {
  82                 _instant_xml = new XMLNode ("instant");
  83         }
  84
  85         _instant_xml->remove_nodes_and_delete (node.name());
  86         _instant_xml->add_child_copy (node);
  87
  88         sys::path instant_xml_path(directory_path);
  89
  90         instant_xml_path /= "instant.xml";
  91
  92         XMLTree tree;
  93         tree.set_filename(instant_xml_path.to_string());
  94
  95         /* Important: the destructor for an XMLTree deletes
  96            all of its nodes, starting at _root. We therefore
  97            cannot simply hand it our persistent _instant_xml
  98            node as its _root, because we will lose it whenever
  99            the Tree goes out of scope.
 100
 101            So instead, copy the _instant_xml node (which does
 102            a deep copy), and hand that to the tree.
 103         */
 104
 105         XMLNode* copy = new XMLNode (*_instant_xml);
 106         tree.set_root (copy);
 107
 108         if (!tree.write()) {
 109                 error << string_compose(_("Error: could not write %1"), instant_xml_path.to_string()) << endmsg;
 110         }
 111 }
 112
 113 XMLNode *
 114 Stateful::instant_xml (const string& str, const sys::path& directory_path)
 115 {
 116         if (_instant_xml == 0) {
 117
 118                 sys::path instant_xml_path(directory_path);
 119                 instant_xml_path /= "instant.xml";
 120
 121                 if (exists(instant_xml_path)) {
 122                         XMLTree tree;
 123                         if (tree.read(instant_xml_path.to_string())) {
 124                                 _instant_xml = new XMLNode(*(tree.root()));
 125                         } else {
 126                                 warning << string_compose(_("Could not understand XML file %1"), instant_xml_path.to_string()) << endmsg;
 127                                 return 0;
 128                         }
 129                 } else {
 130                         return 0;
 131                 }
 132         }
 133
 134         const XMLNodeList& nlist = _instant_xml->children();
 135         XMLNodeConstIterator i;
 136
 137         for (i = nlist.begin(); i != nlist.end(); ++i) {
 138                 if ((*i)->name() == str) {
 139                         return (*i);
 140                 }
 141         }
 142
 143         return 0;
 144 }
 145
 146 } // namespace PBD