xmlWrapper.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_DATAREPOSITORY_XMLWRAPPER_HPP_
#define GEOSX_DATAREPOSITORY_XMLWRAPPER_HPP_

// Source includes
#include "common/DataTypes.hpp"
#include "dataRepository/DefaultValue.hpp"
#include "rajaInterface/GEOS_RAJA_Interface.hpp"
#include "LvArray/src/output.hpp"
#include "LvArray/src/input.hpp"

// TPL includes
#include <pugixml.hpp>

// System includes
#include <algorithm>
#include <sstream>

namespace geosx
{


class xmlWrapper
{
public:

  using xmlDocument = pugi::xml_document;

  using xmlResult = pugi::xml_parse_result;

  using xmlNode = pugi::xml_node;

  using xmlAttribute = pugi::xml_attribute;

  using xmlTypes = pugi::xml_node_type;

  static constexpr auto filePathString = "filePath";


  xmlWrapper() = delete;

  ~xmlWrapper() = delete;

  xmlWrapper( xmlWrapper const & ) = delete;

  xmlWrapper( xmlWrapper && ) = delete;


  static void addIncludedXML( xmlNode & targetNode );


  template< typename T >
  static std::enable_if_t< traits::CanStreamInto< std::istringstream, T > >
  StringToInputVariable( T & target, string const & value )
  {
    std::istringstream ss( value );
    ss>>target;
  }

  static void StringToInputVariable( R1Tensor & target, string const & value );

  template< typename T, int NDIM, typename PERMUTATION >
  static std::enable_if_t< traits::CanStreamInto< std::istringstream, T > >
  StringToInputVariable( Array< T, NDIM, PERMUTATION > & array, string const & value )
  { LvArray::input::stringToArray( array, value ); }


  IS_VALID_EXPRESSION( canParseVariable, T, StringToInputVariable( std::declval< T & >(), std::string() ) );


  template< typename T, typename T_DEF = T >
  static std::enable_if_t< canParseVariable< T >, bool >
  ReadAttributeAsType( T & rval,
                       string const & name,
                       xmlNode const & targetNode,
                       T_DEF const & defVal )
  {
    pugi::xml_attribute xmlatt = targetNode.attribute( name.c_str() );
    if( !xmlatt.empty() )
    {
      // parse the string/attribute into a value
      StringToInputVariable( rval, xmlatt.value() );
    }
    else
    {
      // set the value to the default value
      equate( rval, defVal );
    }
    return true;
  }

  template< typename T >
  static std::enable_if_t< canParseVariable< T >, bool >
  ReadAttributeAsType( T & rval,
                       string const & name,
                       xmlNode const & targetNode,
                       bool const required )
  {
    pugi::xml_attribute 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() );
    }
    return success;
  }

  template< typename T >
  static std::enable_if_t< !dataRepository::DefaultValue< T >::has_default_value, bool >
  ReadAttributeAsType( T & rval,
                       string const & name,
                       xmlNode const & targetNode,
                       dataRepository::DefaultValue< T > const & )
  { return ReadAttributeAsType( rval, name, targetNode, false ); }

  template< typename T >
  static typename std::enable_if_t< dataRepository::DefaultValue< T >::has_default_value, bool >
  ReadAttributeAsType( T & rval,
                       string const & name,
                       xmlNode const & targetNode,
                       dataRepository::DefaultValue< T > const & defVal )
  { return ReadAttributeAsType( rval, name, targetNode, defVal.value ); }

  template< typename T, typename U >
  static std::enable_if_t< !canParseVariable< T >, bool >
  ReadAttributeAsType( T &, string const &, xmlNode const &, U const & )
  {
    GEOSX_ERROR( "Cannot parse the given type " << LvArray::system::demangleType< T >() );
    return false;
  }


private:

  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 ); }

};

} /* namespace geosx */

#endif /*GEOSX_DATAREPOSITORY_XMLWRAPPER_HPP_ */