TableData.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_COMMON_FORMAT_TABLE_TABLEDATA_HPP
#define GEOS_COMMON_FORMAT_TABLE_TABLEDATA_HPP
 
#include "common/Units.hpp"
#include "common/DataTypes.hpp"
#include "common/format/Format.hpp"
#include "TableTypes.hpp"
 
namespace geos
{
 
class TableData
{
public:
 
  TableData();
 
  TableData( TableData const & other );
 
  TableData( TableData && other );
 
  TableData & operator=( TableData const & other );
 
  TableData & operator=( TableData && other );
 
  bool operator<( TableData const & other ) const;
 
  bool operator==( TableData const & other ) const;
 
  struct CellData
  {
    CellType type;
    string value;
 
    size_t getSerializedSize() const;
 
    void serialize( stdVector< buffer_unit_type > & out ) const;
  };
 
  size_t getSerializedSize() const;
 
  using DataRows = stdVector< stdVector< CellData > >;
 
  void serialize( stdVector< buffer_unit_type > & serializedTableData ) const;
 
  template< typename ... Args >
  void addRow( Args const & ... args );
 
  void addRow( stdVector< CellData > const & row );
 
  void addSeparator();
 
  void clear();
 
  void clearErrors()
  { m_errors->clear(); }
 
  stdVector< string > const & getErrorMsgs() const;
 
  DataRows const & getCellsData() const
  { return m_rows; }
 
  DataRows & getCellsData()
  { return m_rows; }
 
  TableErrorListing const & getErrorsList() const
  { return *m_errors; }
 
  TableErrorListing & getErrorsList()
  { return *m_errors; }
 
  template< typename SortingFunc >
  void sort( SortingFunc sortingFunctor )
  {
    std::sort( m_rows.begin(), m_rows.end(), sortingFunctor );
  }
 
private:
  DataRows m_rows;
 
  std::unique_ptr< geos::TableErrorListing > m_errors;
 
};
 
 
class TableData2D
{
public:
 
  using RowType = real64;
  using ColumnType = real64;
 
  struct TableDataHolder
  {
    stdVector< string > headerNames;
    TableData tableData;
  };
 
  template< typename T >
  void addCell( RowType rowValue, ColumnType columnValue, T const & value );
 
  void collectTableValues( arrayView1d< real64 const > dim0AxisCoordinates,
                           arrayView1d< real64 const > dim1AxisCoordinates,
                           arrayView1d< real64 const > values,
                           bool columnMajorValues );
 
  TableData2D::TableDataHolder convertTable2D( arrayView1d< real64 const > coordX, arrayView1d< real64 const > coordY,
                                               string_view rowAxisDescription,
                                               string_view columnAxisDescription,
                                               arrayView1d< real64 const > const values,
                                               bool columnMajorValues,
                                               string_view valueDescription );
 
  TableDataHolder buildTableData( string_view dataDescription,
                                  string_view rowFmt = "{}", string_view columnFmt = "{}" ) const;
 
  inline void clear()
  {
    m_data.clear();
    m_columnValues.clear();
    m_errors->clear();
  }
 
private:
  stdMap< RowType, stdMap< ColumnType, string > > m_data;
 
  std::set< real64 > m_columnValues;
  std::unique_ptr< geos::TableErrorListing > m_errors = std::make_unique< geos::TableErrorListing >();
};
 
template< typename T >
constexpr bool isCellType = std::is_same_v< T, CellType >;
 
template< typename ... Args >
void TableData::addRow( Args const &... args )
{
  stdVector< CellData > cells;
  ( [&] {
    static_assert( has_formatter_v< decltype(args) > || isCellType< std::decay_t< decltype(args) > >, "Argument passed in addRow cannot be converted to string nor a CellType" );
    if constexpr (std::is_same_v< Args, CellType >) {
      cells.push_back( { args, string() } );
    }
    else if constexpr (std::is_floating_point_v< std::decay_t< decltype(args) > >) {
      if( !getErrorsList().hasErrors() && (std::isnan( args ) ||  std::isinf( args )))
      {
        m_errors->addError( "Warning : Invalid values detected (nan/inf)." );
      }
      cells.push_back( {CellType::Value, GEOS_FMT( "{}", args )} );
    }
    else
    {
      cells.push_back( {CellType::Value, GEOS_FMT( "{}", args )} );
    }
  } (), ...);
  addRow( cells );
}
 
template< typename T >
void TableData2D::addCell( real64 const rowValue, real64 const columnValue, T const & value )
{
  static_assert( has_formatter_v< decltype(value) >, "Argument passed in addCell cannot be converted to string" );
  m_columnValues.insert( columnValue );
  m_data.get_inserted( rowValue ).get_inserted( columnValue ) =  GEOS_FMT( "{}", value );
}
 
// Serialisation/ Deserialisation utils for common
namespace basicSerialization
{
 
template< typename T >
inline unsigned long sizeOfPrimitive( T )
{ return sizeof(T); }
 
inline unsigned long sizeOfString( string const & str )
{ return sizeof(string::size_type) + str.size(); }
 
template< typename T,
          std::enable_if_t< std::is_trivially_copyable_v< T >, bool > = true >
void serializePrimitive ( T const data, stdVector< buffer_unit_type > & out );
 
void serializeString ( string const & data, stdVector< buffer_unit_type > & out );
 
template< typename T,
          std::enable_if_t< std::is_trivially_copyable_v< T >, bool > = true >
void deserializePrimitive( T & data, buffer_unit_type const * & ptr, buffer_unit_type const * end );
 
void deserializeString( string & str, buffer_unit_type const * & ptr, buffer_unit_type const * end );
}
 
// Custom Comp function;
namespace tableDataSorting
{
bool positiveNumberStringComp( string_view a, string_view b );
}
 
 
template< typename T,
          std::enable_if_t< std::is_trivially_copyable_v< T >, bool > >
void basicSerialization::serializePrimitive( T const data,
                                             stdVector< buffer_unit_type > & out )
{
  buffer_unit_type const * begin = reinterpret_cast< buffer_unit_type const * >( &data );
  buffer_unit_type const * end = begin + sizeof(data);
  out.insert( out.end(), begin, end );
}
 
template< typename T,
          std::enable_if_t< std::is_trivially_copyable_v< T >, bool > >
void basicSerialization::deserializePrimitive( T & data,
                                               buffer_unit_type const * & ptr,
                                               buffer_unit_type const * end )
{
  if( ptr + sizeof(T)> end )
    throw std::runtime_error( "Buffer overflow" );
 
  data = *reinterpret_cast< T const * >(ptr);
  ptr += sizeof(T);
}
 
 
}
#endif /* GEOS_COMMON_FORMAT_TABLE_TABLEDATA_HPP */