Database.h

Go to the documentation of this file.

#ifndef included_AMP_Database
#define included_AMP_Database
 
#include "AMP/AMP_TPLs.h"
#include "AMP/utils/Array.h"
#include "AMP/utils/TypeTraits.h"
#include "AMP/utils/Units.h"
#include "AMP/utils/typeid.h"
 
#include "StackTrace/source_location.h"
 
#include <cstddef>
#include <iostream>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
 
 
// Forward declare SAMRAI's database
namespace SAMRAI::tbox {
class Database;
class DatabaseBox;
} // namespace SAMRAI::tbox
 
 
// AMP namespace
namespace AMP {
 
 
// Forward declares
class MathExpr;
 
 
class KeyData
{
public:
    using source_location = StackTrace::source_location;
    virtual ~KeyData() {}
    virtual typeID getClassType() const = 0;
    virtual std::unique_ptr<KeyData> clone() const = 0;
    virtual void print( std::ostream &os,
                        std::string_view indent = "",
                        bool sort               = true,
                        bool printType          = false ) const = 0;
    virtual bool is_floating_point() const = 0;
    virtual bool is_integral() const = 0;
    // Check if the entry can be stored as the given type
    template<class TYPE>
    bool isType() const;
    // Get the fundamental type (e.g. double, int, float, ...)
    virtual typeID getDataType() const = 0;
    virtual ArraySize arraySize() const = 0;
    virtual Array<double> convertToDouble() const = 0;
    virtual Array<int64_t> convertToInt64() const = 0;
    virtual bool operator==( const KeyData &rhs ) const = 0;
    inline bool operator!=( const KeyData &rhs ) const { return !operator==( rhs ); }
    const Units &unit() const { return d_unit; }
    double convertUnits( const Units &, std::string_view = "" ) const;
    virtual size_t packSize() const = 0;
    virtual size_t pack( std::byte * ) const = 0;
    virtual size_t unpack( const std::byte * ) = 0;
    virtual void writeHDF5( int64_t fid, const std::string &name ) const = 0;
    virtual void readHDF5( int64_t fid, const std::string &name ) = 0;
    template<class TYPE>
    TYPE getScalar( const Units &unit     = {},
                    std::string_view name = "",
                    source_location src   = source_location::current() ) const;
    template<class TYPE>
    Array<TYPE> getArray( const Units &unit     = {},
                          std::string_view name = "",
                          source_location src   = source_location::current() ) const;
 
protected:
    KeyData() {}
    KeyData( const Units &unit ) : d_unit( unit ) {}
    KeyData( KeyData && )      = delete;
    KeyData( const KeyData & ) = delete;
 
    KeyData &operator=( KeyData && ) = delete;
    KeyData &operator=( const KeyData & ) = delete;
 
protected:
    Units d_unit;
};
 
 
class Database final : public KeyData
{
public:
    enum class Check : uint8_t {
        Overwrite,     
        Keep,          
        WarnOverwrite, 
        WarnKeep,      
        Error,         
        GetDatabaseDefault
    };
 
    template<typename T>
    struct IdentityTypeStruct {
        typedef T type;
    };
    template<typename T>
    using IdentityType = typename IdentityTypeStruct<const T &>::type;
 
public:
    Database();
 
    explicit Database( std::string name );
 
    static std::shared_ptr<Database> parseInputFile( const std::string &filename );
 
    // Read a YAML database
    static std::unique_ptr<KeyData> readYAML( std::string_view filename,
                                              source_location src = source_location::current() );
 
    template<class... Args>
    static std::unique_ptr<Database> create( Args... args );
 
    template<class... Args>
    static std::unique_ptr<Database> createWithUnits( Args... args );
 
    static std::unique_ptr<Database> createFromString( std::string_view data );
 
    Database( const Database & );
 
    Database &operator=( const Database & );
 
    Database( Database &&rhs );
 
    Database &operator=( Database &&rhs );
 
    virtual ~Database() = default;
 
    void readDatabase( const std::string &filename,
                       source_location src = source_location::current() );
 
    typeID getClassType() const override { return getTypeID<Database>(); }
 
    inline Check getDefaultAddKeyBehavior() const { return d_check; }
 
 
    void setDefaultAddKeyBehavior( Check check, bool setChildren );
 
    std::unique_ptr<KeyData> clone() const override;
 
    void copy( const Database &rhs );
 
    std::unique_ptr<Database> cloneDatabase() const;
 
    inline const std::string &getName() const { return d_name; }
 
    inline void setName( std::string name ) { d_name = std::move( name ); }
 
    bool keyExists( std::string_view key ) const;
 
 
    void deleteData( std::string_view key );
 
 
    std::vector<std::string> getAllKeys( bool sort = true ) const;
 
 
    inline size_t empty() const { return d_data.size() == 0; }
 
 
    inline size_t size() const { return d_data.size(); }
 
 
    bool operator==( const Database &rhs ) const;
 
 
    bool operator==( const KeyData &rhs ) const override;
 
 
    inline bool operator!=( const Database &rhs ) const { return !operator==( rhs ); }
 
 
    inline std::string getString( std::string_view key,
                                  source_location src = source_location::current() ) const
    {
        return getScalar<std::string>( key, {}, src );
    }
 
 
    template<class TYPE>
    TYPE getScalar( std::string_view key,
                    const Units &unit   = Units(),
                    source_location src = source_location::current() ) const;
 
 
    template<class TYPE>
    TYPE getWithDefault( std::string_view key,
                         IdentityType<const TYPE &> value,
                         const Units &unit   = Units(),
                         source_location src = source_location::current() ) const;
 
 
    template<class TYPE>
    Array<TYPE> getArray( std::string_view key,
                          const Units &unit   = Units(),
                          source_location src = source_location::current() ) const;
 
 
    template<class TYPE>
    std::vector<TYPE> getVector( std::string_view key,
                                 const Units &unit   = Units(),
                                 source_location src = source_location::current() ) const;
 
 
    template<class TYPE>
    void putScalar( std::string_view key,
                    TYPE value,
                    Units unit          = Units(),
                    Check check         = Check::GetDatabaseDefault,
                    source_location src = source_location::current() );
 
 
    template<class TYPE>
    void putArray( std::string_view key,
                   Array<TYPE> data,
                   Units unit          = Units(),
                   Check check         = Check::GetDatabaseDefault,
                   source_location src = source_location::current() );
 
 
    template<class TYPE>
    void putVector( std::string_view key,
                    const std::vector<TYPE> &data,
                    Units unit          = Units(),
                    Check check         = Check::GetDatabaseDefault,
                    source_location src = source_location::current() );
 
 
    KeyData *getData( std::string_view key );
 
    const KeyData *getData( std::string_view key ) const;
 
 
    void putData( std::string_view key,
                  std::unique_ptr<KeyData> data,
                  Check check         = Check::GetDatabaseDefault,
                  source_location src = source_location::current() );
 
 
    bool isDatabase( std::string_view key, source_location src = source_location::current() ) const;
 
 
    bool isString( std::string_view key, source_location src = source_location::current() ) const;
 
    bool isEquation( std::string_view key, source_location src = source_location::current() ) const;
 
 
    std::unique_ptr<MathExpr> getEquation( std::string_view key,
                                           const Units &unit   = Units(),
                                           source_location src = source_location::current() ) const;
 
 
    template<class TYPE>
    bool isType( std::string_view key, source_location src = source_location::current() ) const;
 
    typeID getDataType( std::string_view key ) const;
 
    std::shared_ptr<Database> getDatabase( std::string_view key,
                                           source_location src = source_location::current() );
 
    std::shared_ptr<const Database>
    getDatabase( std::string_view key, source_location src = source_location::current() ) const;
 
 
    const Database &operator()( std::string_view key,
                                source_location src = source_location::current() ) const;
 
 
    inline void putDatabase( std::string_view key, std::unique_ptr<Database> db )
    {
        putData( key, std::move( db ) );
    }
 
 
    inline std::shared_ptr<Database> createAddDatabase( std::string_view key )
    {
        putDatabase( key, std::make_unique<Database>( std::string( key ) ) );
        return getDatabase( key );
    }
 
 
    inline std::shared_ptr<Database> putDatabase( std::string_view key )
    {
        putData( key, std::make_unique<Database>( std::string( key.data(), key.size() ) ) );
        return getDatabase( key );
    }
 
 
    void erase( std::string_view key, bool check = true );
 
 
    void clear();
 
 
    void print( std::ostream &os,
                std::string_view indent = "",
                bool sort               = true,
                bool printType          = false ) const override;
 
 
    typeID getDataType() const override { return AMP::getTypeID<Database>(); }
 
 
    std::string
    print( std::string_view indent = "", bool sort = true, bool printType = false ) const;
 
 
    std::vector<std::string> getUnused( bool recursive = true ) const;
 
 
public: // Pack/unpack data
    size_t packSize() const override;
    size_t pack( std::byte * ) const override;
    size_t unpack( const std::byte * ) override;
    void writeHDF5( int64_t fid, const std::string &name ) const override;
    void readHDF5( int64_t fid, const std::string &name ) override;
 
#ifdef AMP_USE_SAMRAI
public: // SAMRAI interfaces
    Database( SAMRAI::tbox::Database & );
 
    std::shared_ptr<SAMRAI::tbox::Database> cloneToSAMRAI() const;
 
    static std::shared_ptr<Database> readThroughSAMRAI( const std::string &filename );
 
#endif
 
 
protected: // Internal data and functions
    Check d_check;
    std::string d_name;
    std::vector<uint32_t> d_hash;
    std::vector<std::string> d_keys;
    std::vector<std::shared_ptr<KeyData>> d_data;
    mutable std::vector<bool> d_used;
 
    // Function to add arguments to the database
    template<class TYPE, class... Args>
    void addArgs( std::string_view key, TYPE value, Args... args );
 
    // Function to add arguments to the database
    template<class TYPE, class... Args>
    void addArgsWithUnits( std::string_view key, TYPE value, const Units &unit, Args... args );
 
    // Hash a string
    static inline uint32_t hashString( std::string_view s )
    {
        return std::hash<std::string_view>{}( s );
    }
 
    // Find an entry
    inline int find( uint32_t hash, bool use ) const
    {
        for ( size_t i = 0; i < d_hash.size(); i++ ) {
            if ( hash == d_hash[i] ) {
                if ( use && !d_used[i] )
                    d_used[i] = true;
                return i;
            }
        }
        return -1;
    }
 
    // Functions inherited from KeyData that really aren't valid
    Array<double> convertToDouble() const override;
    Array<int64_t> convertToInt64() const override;
    ArraySize arraySize() const override { return ArraySize( 1 ); }
    bool is_floating_point() const override;
    bool is_integral() const override;
};
 
 
class DatabaseBox final
{
public:
    DatabaseBox();
 
    DatabaseBox( int dim, const int *lower, const int *upper );
 
    explicit DatabaseBox( std::string_view str );
 
#ifdef AMP_USE_SAMRAI
    DatabaseBox( const SAMRAI::tbox::DatabaseBox & );
 
    SAMRAI::tbox::DatabaseBox cloneToSAMRAI() const;
#endif
 
    uint8_t &dim();
 
    uint8_t dim() const;
 
    bool empty() const;
 
    int &lower( uint8_t i );
 
    int lower( uint8_t i ) const;
 
    int &upper( uint8_t i );
 
    int upper( uint8_t i ) const;
 
    bool operator==( const DatabaseBox &box ) const;
 
private:
    uint8_t d_dim;
    std::array<int, 5> d_lower, d_upper;
};
 
 
/********************************************************************
 * Register KeyData with the factory                                 *
 ********************************************************************/
void registerKeyData( const std::string &name, std::function<std::unique_ptr<KeyData>()> fun );
 
 
/********************************************************************
 * Overload ostream operator                                         *
 ********************************************************************/
std::ostream &operator<<( std::ostream &out, const DatabaseBox & );
 
 
/********************************************************************
 * Create database from arguments                                    *
 ********************************************************************/
template<class TYPE, class... Args>
inline void Database::addArgs( std::string_view key, TYPE value, Args... args )
{
    if constexpr ( is_vector_v<TYPE> ) {
        putVector( key, value );
    } else if constexpr ( is_Array_v<TYPE> ) {
        putArray( key, value );
    } else if constexpr ( std::is_same_v<TYPE, std::string> ||
                          std::is_same_v<TYPE, std::string_view> ) {
        putScalar( key, value );
    } else if constexpr ( has_size_v<TYPE> || is_initializer_list_v<TYPE> ) {
        typedef decltype( *value.begin() ) TYPE2;
        typedef typename AMP::remove_cvref_t<TYPE2> TYPE3;
        std::vector<TYPE3> data( value.begin(), value.end() );
        putVector( key, std::move( data ) );
    } else {
        putScalar( key, value );
    }
    if constexpr ( sizeof...( args ) > 0 )
        addArgs( args... );
}
template<class TYPE, class... Args>
inline void
Database::addArgsWithUnits( std::string_view key, TYPE value, const Units &unit, Args... args )
{
    if constexpr ( is_vector_v<TYPE> ) {
        putVector( key, value, unit );
    } else if constexpr ( is_Array_v<TYPE> ) {
        putArray( key, value );
    } else if constexpr ( std::is_same_v<TYPE, std::string> ||
                          std::is_same_v<TYPE, std::string_view> ) {
        putScalar( key, value, unit );
    } else if constexpr ( has_size_v<TYPE> || is_initializer_list_v<TYPE> ) {
        typedef decltype( *value.begin() ) TYPE2;
        typedef typename AMP::remove_cvref_t<TYPE2> TYPE3;
        std::vector<TYPE3> data( value.begin(), value.end() );
        putVector( key, std::move( data ), unit );
    } else {
        putScalar( key, value, unit );
    }
    if constexpr ( sizeof...( args ) > 0 )
        addArgsWithUnits( args... );
}
template<class... Args>
inline std::unique_ptr<Database> Database::create( Args... args )
{
    constexpr size_t n = sizeof...( args );
    static_assert( n % 2 == 0 );
    auto db = std::make_unique<Database>();
    if ( n == 0 )
        return db;
    db->addArgs( args... );
    return db;
}
template<class... Args>
inline std::unique_ptr<Database> Database::createWithUnits( Args... args )
{
    constexpr size_t n = sizeof...( args );
    static_assert( n % 3 == 0 );
    auto db = std::make_unique<Database>();
    if ( n == 0 )
        return db;
    db->addArgsWithUnits( args... );
    return db;
}
 
 
} // namespace AMP
 
 
#endif