xmlWrapper.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_DATAREPOSITORY_XMLWRAPPER_HPP_
#define GEOS_DATAREPOSITORY_XMLWRAPPER_HPP_
 
// Source includes
#include "common/DataTypes.hpp"
#include "DefaultValue.hpp"
#include "common/GEOS_RAJA_Interface.hpp"
#include "LvArray/src/output.hpp"
#include "LvArray/src/input.hpp"
#include "common/format/StringUtilities.hpp"
#include "codingUtilities/RTTypes.hpp"
 
// TPL includes
#include <pugixml.hpp>
 
// System includes
#include <algorithm>
#include <sstream>
 
namespace geos
{
 
 
namespace xmlWrapper
{
 
using xmlResult = pugi::xml_parse_result;
 
using xmlNode = pugi::xml_node;
 
using xmlAttribute = pugi::xml_attribute;
 
using xmlNodeType = pugi::xml_node_type;
 
class xmlDocument;
 
struct xmlAttributePos
{
  string filePath;
  size_t const line;
  size_t const offsetInLine;
  size_t const offset;
 
  xmlAttributePos( string const & filePath, size_t line, size_t offsetInLine, size_t offset );
  bool isFound() const;
  string toString() const;
};
 
struct xmlNodePos : xmlAttributePos
{
  xmlDocument const & document;
 
  xmlNodePos( xmlDocument const & document, string const & filePath, size_t line, size_t offsetInLine, size_t offset );
  bool isFound() const;
  xmlAttributePos getAttributeLine( string const & attName ) const;
};
 
class xmlDocument
{
public:
  static constexpr size_t npos = string::npos;
 
  xmlDocument();
  xmlDocument( const xmlDocument & ) = delete;
  xmlDocument( xmlDocument && ) = default;
 
  xmlNode getFirstChild() const;
  xmlNode getChild( string const & name ) const;
  string const & getOriginalBuffer() const;
  string const * getOriginalBuffer( string const & filePath ) const;
  map< string, string > const & getOriginalBuffers() const;
  string const & getFilePath() const;
  xmlNodePos getNodePosition( xmlWrapper::xmlNode const & node ) const;
 
  xmlResult loadString( string_view content, bool loadNodeFileInfo = false );
 
  xmlResult loadFile( string const & path, bool loadNodeFileInfo = false );
 
  xmlNode appendChild( string const & name );
  xmlNode appendChild( xmlNodeType type = xmlNodeType::node_element );
 
  bool saveFile( string const & path ) const;
 
  void addIncludedXML( xmlNode & targetNode, int level = 0 );
 
  bool hasNodeFileInfo() const;
 
private:
  pugi::xml_document pugiDocument;
 
  map< string, string > m_originalBuffers;
  string m_rootFilePath;
};
 
constexpr char const filePathString[] = "__filePath__";
 
constexpr char const charOffsetString[] = "__charOffset__";
 
constexpr char const includedListTag[] = "Included";
 
constexpr char const includedFileTag[] = "File";
 
string buildMultipleInputXML( string_array const & inputFileList,
                              string const & outputDir = {} );
 
bool isFileMetadataAttribute( string const & name );
 
 
void validateString( string const & value, Regex const & regex );
 
void processInputException( std::exception const & ex, string const & targetAttributeName,
                            xmlWrapper::xmlNode const & targetNode,
                            xmlWrapper::xmlNodePos const & nodePos );
 
template< typename T >
std::enable_if_t< traits::CanStreamInto< std::istringstream, T > >
stringToInputVariable( T & target, string const & value, Regex const & regex )
{
  validateString( value, regex );
 
  std::istringstream ss( value );
  ss >> target;
  GEOS_THROW_IF( ss.fail() || !ss.eof(),
                 "Error detected while parsing string \"" << value <<
                 "\" to type " << LvArray::system::demangleType< T >(),
                 InputError );
}
 
template< typename T, int SIZE >
void
stringToInputVariable( Tensor< T, SIZE > & target, string const & value, Regex const & regex );
 
template< typename T, int NDIM, typename PERMUTATION >
std::enable_if_t< traits::CanStreamInto< std::istringstream, T > >
stringToInputVariable( Array< T, NDIM, PERMUTATION > & array, string const & value, Regex const & regex )
{
  validateString( value, regex );
 
  LvArray::input::stringToArray( array, string( stringutilities::trimSpaces( value ) ) );
}
 
void stringToInputVariable( stdVector< std::string > & array, string const & value, Regex const & regex );
 
 
namespace internal
{
 
IS_VALID_EXPRESSION( canParseVariable, T, stringToInputVariable( std::declval< T & >(), string(), Regex() ) );
 
template< typename T >
static void equate( T & lhs, T const & rhs )
{ lhs = rhs; }
 
template< typename T, int NDIM, typename PERM >
static void equate( Array< T, NDIM, PERM > const & lhs, T const & rhs )
{ lhs.template setValues< serialPolicy >( rhs ); }
 
template< typename T >
static void equate( stdVector< T > & lhs, T const & rhs )
{
  for( auto & val : lhs )
  {
    val = rhs;
  }
}
 
}   // namespace internal
 
 
template< typename T, typename U >
std::enable_if_t< !internal::canParseVariable< T >, bool >
readAttributeAsType( T &, string const & name, Regex const &, xmlNode const &, U const & )
{
  GEOS_THROW( "Cannot parse key with name ("<<name<<") with the given type " << LvArray::system::demangleType< T >(), InputError );
}
 
template< typename T, typename T_DEF = T >
std::enable_if_t< internal::canParseVariable< T >, bool >
readAttributeAsType( T & rval,
                     string const & name,
                     Regex const & regex,
                     xmlNode const & targetNode,
                     T_DEF const & defVal )
{
  xmlAttribute const xmlatt = targetNode.attribute( name.c_str() );
  if( !xmlatt.empty() )
  {
    // parse the string/attribute into a value
    stringToInputVariable( rval, xmlatt.value(), regex );
    return true;
  }
  else
  {
    // set the value to the default value
    internal::equate( rval, defVal );
    return false;
  }
}
 
template< typename T >
std::enable_if_t< internal::canParseVariable< T >, bool >
readAttributeAsType( T & rval,
                     string const & name,
                     Regex const & regex,
                     xmlNode const & targetNode,
                     bool const required )
{
  xmlAttribute const xmlatt = targetNode.attribute( name.c_str() );
 
  bool const success = !(xmlatt.empty() && required);
 
  if( success )
  {
    // parse the string/attribute into a value
    stringToInputVariable( rval, xmlatt.value(), regex );
  }
  return success;
}
 
template< typename T >
std::enable_if_t< !dataRepository::DefaultValue< T >::has_default_value, bool >
readAttributeAsType( T & rval,
                     string const & name,
                     Regex const & regex,
                     xmlNode const & targetNode,
                     dataRepository::DefaultValue< T > const & )
{
  return readAttributeAsType( rval, name, regex, targetNode, false );
}
 
template< typename T >
typename std::enable_if_t< dataRepository::DefaultValue< T >::has_default_value, bool >
readAttributeAsType( T & rval,
                     string const & name,
                     Regex const & regex,
                     xmlNode const & targetNode,
                     dataRepository::DefaultValue< T > const & defVal )
{
  return readAttributeAsType( rval, name, regex, targetNode, defVal.value );
}
 
 
}
 
} /* namespace geos */
 
#endif /*GEOS_DATAREPOSITORY_XMLWRAPPER_HPP_ */