/usr/include/dolfin/io/XMLArray.h is in libdolfin-dev 1.4.0+dfsg-4.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 | // Copyright (C) 2011 Garth N. Wells
//
// This file is part of DOLFIN.
//
// DOLFIN is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// DOLFIN is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with DOLFIN. If not, see <http://www.gnu.org/licenses/>.
//
// Modified by Anders Logg 2011
//
// First added: 2006-07-02
// Last changed: 2011-11-14
#ifndef __XMLARRAY_H
#define __XMLARRAY_H
#include <ostream>
#include <string>
#include <vector>
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>
#include "dolfin/common/Array.h"
#include "dolfin/log/log.h"
#include "pugixml.hpp"
namespace pugi
{
class xml_node;
}
namespace dolfin
{
class XMLArray
{
public:
// Read XML vector. Vector must have correct size.
template<typename T>
static void read(std::vector<T>& x, const pugi::xml_node xml_dolfin);
/// Write the XML file
template<typename T>
static void write(const std::vector<T>& x, const std::string type,
pugi::xml_node xml_node);
};
//---------------------------------------------------------------------------
template<typename T>
void XMLArray::read(std::vector<T>& x, const pugi::xml_node xml_node)
{
// Check that we have a XML Array
const pugi::xml_node array = xml_node.child("array");
if (!array)
{
dolfin_error("XMLArray.h",
"read array from XML file",
"Unable to find <array> tag in XML file");
}
// Get size and type
const std::size_t size = array.attribute("size").as_uint();
const std::string type = array.attribute("type").value();
if (type != "double")
{
dolfin_error("XMLArray.h",
"read array from XML file",
"XML I/O of Array objects only supported when the value type is 'double'");
}
// Iterate over array entries
x.resize(size);
Array<std::size_t> indices(size);
for (pugi::xml_node_iterator it = array.begin(); it != array.end(); ++it)
{
const std::size_t index = it->attribute("index").as_uint();
const double value = it->attribute("value").as_double();
dolfin_assert(index < size);
indices[index] = index;
x[index] = value;
}
}
//---------------------------------------------------------------------------
template<typename T>
void XMLArray::write(const std::vector<T>& x, const std::string type,
pugi::xml_node xml_node)
{
// Add array node
pugi::xml_node array_node = xml_node.append_child("array");
// Add attributes
const std::size_t size = x.size();
array_node.append_attribute("type") = type.c_str();
array_node.append_attribute("size") = (unsigned int) size;
// Add data
for (std::size_t i = 0; i < size; ++i)
{
pugi::xml_node element_node = array_node.append_child("element");
element_node.append_attribute("index") = (unsigned int) i;
// NOTE: Casting to a string to avoid loss of precision when
// pugixml performs double-to-char conversion
element_node.append_attribute("value")
= boost::str(boost::format("%.15e") % x[i]).c_str();
}
}
//---------------------------------------------------------------------------
}
#endif
|