CachedElement.h

Go to the documentation of this file.

/*
 * CachedElement.h
 *
 *  Created on: 21 Dec 2013
 *      Author: jowr
 */
 
#ifndef CACHEDELEMENT_H_
#define CACHEDELEMENT_H_
 
#include <algorithm>
#include <array>
#include "CoolPropTools.h"
#include "DataStructures.h"
#include "CPnumerics.h"
 
namespace CoolProp {
 
class CachedElement
{
    
private:
    bool is_cached = false;
    double value;
    
public:
    CachedElement() {
        this->clear();
    };
    
    void _do_cache(double value) {
        this->value = value;
        this->is_cached = true;
    }
    
    void operator=(const double& value) {
        _do_cache(value);
    };
    
    operator bool() {
        return is_cached;
    };
    
    operator double() {
        if (is_cached) {
            return static_cast<double>(value);
        } else {
            throw std::exception();
        }
    }
#ifndef COOLPROPDBL_MAPS_TO_DOUBLE
    operator CoolPropDbl() {
        if (is_cached) {
            return value;
        } else {
            throw std::exception();
        }
    }
#endif
    void clear() {
        is_cached = false;
        this->value = _HUGE;
    };
    double& pt() {
        return this->value;
    }
};
 
template<typename NumType>
class CacheArrayElement
{
    
private:
    NumType& value;
    bool& is_cached;
    
public:
    
    // Constructor with value
    CacheArrayElement(NumType& val, bool& is_cached) : value(val), is_cached(is_cached) {};
    
    void _do_cache(double value) {
        this->value = value;
        this->is_cached = true;
    }
    
    void operator=(const double& value) {
        _do_cache(value);
    };
    
    operator bool() {
        return is_cached;
    };
    
    operator double() {
        if (is_cached) {
            return static_cast<double>(value);
        } else {
            throw std::exception();
        }
    }
#ifndef COOLPROPDBL_MAPS_TO_DOUBLE
    operator CoolPropDbl() {
        if (is_cached) {
            return value;
        } else {
            throw std::exception();
        }
    }
#endif
    void clear() {
        is_cached = false;
        this->value = _HUGE;
    };
    NumType& pt() {
        return this->value;
    }
};
 
 
template<int N>
class CacheArray{
 
private:
 
    std::size_t inext = 0;
    std::array<double, N> m_values = create_filled_array<double, N>(_HUGE);
    std::array<bool, N> m_cached = create_filled_array<bool, N>(false);
 
   public:
    void clear(){
        memset(m_values.data(), 0, sizeof(m_values));
        memset(m_cached.data(), false, sizeof(m_cached));
    }
    auto factory(std::size_t i){
        return CacheArrayElement<double>(m_values[i], m_cached[i]);
    }
    auto next(){
        if (inext > N){
            throw ValueError("No more cache elements available");
        }
        auto el = factory(inext);
        inext++;
        return el;
    }
};
 
} /* namespace CoolProp */
#endif /* CACHEDELEMENT_H_ */