dsim_variable.h

/*
 *  dsim_variable.h
 *  DSimEngine2
 *
 *  Created by David Wilson on 4/16/09.
 *  Copyright 2009 Princeton Satellite Systems. All rights reserved.
 *
 */

#ifndef __DSIM_VARIABLE__
#define __DSIM_VARIABLE__

#include <MatrixLib/MatrixLib.h>
#include "dsim_value.h"
#include "dsim_exceptions.h"
#include <map>

class dsim_variable_record;

class dsim_variable
{
    public:
        dsim_variable();
        dsim_variable(const dsim_variable &base);
        dsim_variable &operator=(const dsim_variable &base);
        
        ~dsim_variable();
        
        enum dsim_variable_usage {  dsim_invalid_value=0, 
                                    dsim_parameter_value=1, 
                                    dsim_input_value=2, 
                                    dsim_output_value=3, 
                                    dsim_state_value=4, 
                                    dsim_integrated_value=5 
                                 };
        
        inline bool valid() const { return _record?true:false; }
        dsim_variable::dsim_variable_usage usage() const;
        
        // Value access
        int type() const;
        dsim_value value() const;
        dsim_value base_value() const;
        dsim_value cointegrated_value() const;
        void *raw_value() const;
        bool extract_raw_value(void *destination) const;
        const char *units() const;
        const char *description() const;
        int nominal_rows() const;
        int nominal_columns() const;
        void set_nominal_dimensions(int rows,int columns);
        
        bool cointegrated() const { return _cointegrated; }
        void set_cointegrated(bool flag) { _cointegrated = flag; }
        
        int value_as_int() const;
        void set_value_as_int(int val);
        double value_as_double() const;
        void set_value_as_double(double val);
        ml_matrix value_as_matrix() const;
        void set_value_as_matrix(const ml_matrix &val);
        const char *value_as_string() const;
        void set_value_as_string(const char *val);
        
        void set_value(int type,void *new_value);
        void set_value(const dsim_value &new_value);
        
        void set_derivative(int type,void *deriv) throw(dsim_type_mismatch_exception);
        void set_derivative(const dsim_value &deriv) throw(dsim_type_mismatch_exception);
        dsim_value derivative() const;
        
        void start_integration();
        void finish_integration();
        
        void *integration_ptr();
        void set_integration_ptr(void *ptr);
        
        void write_string_representation(FILE *file);
        
        bool parse_value_from_string(const char *str);
        void unpack_value_from_data(unsigned int length,void *data);
        
        void set_attribute(const std::string &name,const std::string &value);
        bool has_attribute(const std::string &name);
        std::string get_attribute(const std::string &name);
        std::map<std::string,std::string>::iterator attribute_iterator();
        std::map<std::string,std::string>::iterator end_attribute_iterator();
        
        void mark_telemetry();
        void mark_command();
        void mark_command_and_telemetry();
        void mark_telemetry_and_command();
        bool is_telemetry() const;
        bool is_command() const;
        
        bool has_changed() const;
        void mark_unchanged();
    
    private:
        dsim_variable(dsim_variable_record *record,bool read_only);
        void *record_ptr() const;
        
        dsim_variable_record *_record;
        bool _read_only;
        bool _cointegrated;
        
    friend class dsim_variable_record;
};

#endif