adam.hpp

Go to the documentation of this file.

/*
    Copyright 2013 Adobe
    Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
*/
/**************************************************************************************************/
 
#ifndef ADOBE_ADAM_HPP
#define ADOBE_ADAM_HPP
 
#include <adobe/config.hpp>
 
#include <functional>
#include <optional>
#include <vector>
 
#include <boost/signals2/signal.hpp>
 
#include <adobe/any_regular_fwd.hpp>
#include <adobe/array.hpp>
#include <adobe/dictionary_fwd.hpp>
#include <adobe/istream.hpp>
#include <adobe/name.hpp>
#include <adobe/virtual_machine.hpp>
 
/*
 
    REVISIT (sparent) : It would be best to untangle the sheet from
    the virtual machine. The way to do this is to allow for function
    objects to be passed instead of line positions and expression
    arrays. The function object could bind to the line_position_t and
    the array.... This would allow for easier programmatic driving.
 
*/
 
/**************************************************************************************************/
 
namespace adobe {

 
/**************************************************************************************************/

class sheet_t : boost::noncopyable {
public:
    struct relation_t;
 
    using monitor_invariant_t = std::function<void(bool)>;
    using monitor_value_t = std::function<void(const any_regular_t&)>;
    using monitor_contributing_t = std::function<void(const dictionary_t&)>;
    using monitor_enabled_t = std::function<void(bool)>;

 
    typedef boost::signals2::connection connection_t;
 
#if !defined(ADOBE_NO_DOCUMENTATION)
    sheet_t();
    ~sheet_t();
#endif

    any_regular_t inspect(const array_t& expression);

    void set(name_t cell, const any_regular_t& value); // input cell.

    void touch(const name_t* first, const name_t* last); // range of input cells.

 
    // REVISIT (sparent) : get() is likely a bad name giving the pairing with set.
    any_regular_t get(name_t cell);

    const any_regular_t& operator[](name_t cell) const;

    void add_input(name_t name, const line_position_t& position, const array_t& initializer);

 
    void add_output(name_t name, const line_position_t& position, const array_t& expression);
 

    void add_constant(name_t name, const line_position_t& position, const array_t& initializer);
 

    void add_constant(name_t name, any_regular_t value);

    void add_logic(name_t name, const line_position_t& position, const array_t& expression);

    void add_invariant(name_t name, const line_position_t& position, const array_t& expression);

    void add_interface(name_t name, bool linked, const line_position_t& position1,
                       const array_t& initializer, const line_position_t& position2,
                       const array_t& expression);

    void add_interface(name_t name, any_regular_t initial);

    void add_relation(const line_position_t& position, const array_t& conditional,
                      const relation_t* first, const relation_t* last);
 

    connection_t monitor_value(name_t name, const monitor_value_t& proc);

    connection_t monitor_contributing(name_t cell, const dictionary_t& mark,
                                      const monitor_contributing_t& proc);
    // output only

    connection_t monitor_enabled(name_t cell, const name_t* first, const name_t* last,
                                 const monitor_enabled_t& proc); // input only
 
#if 0
    connection_t monitor_invariant_contributing(name_t input, const monitor_invariant_t&);
#endif

    connection_t monitor_invariant_dependent(name_t output, const monitor_invariant_t& proc);
 

    bool has_input(name_t name) const;

    bool has_output(name_t name) const;

 
    std::size_t count_interface(name_t name) const { return has_input(name) && has_output(name); }
 

    void update();

    void reinitialize();
 

    void set(const dictionary_t& dictionary);
 
#if 0
    dictionary_t current_mark() const;
#endif
 

    dictionary_t contributing(const dictionary_t& mark) const;

 
    dictionary_t contributing() const;

    dictionary_t contributing_to_cell(name_t) const;
 
    /*
        REVISIT (fbrereto) : From a note from sparent 2007/04/13:
 
        "Make the adam VM public - eventually I'm going to pull it out all
        together (The property model library won't directly depend on it -
        only function object - which can be implemented with the VM)."
 
        This solution is a bit hackish, but is a viable intermediary solution;
        because sheet_t and its underlying implementation are noncopyable, the
        machine can be stored here and held by reference by the implementation,
        and everything is fine. Nevertheless, this is an interim solution given
        Sean's plans for the VM's relationship to sheet_t in the future.
    */
    virtual_machine_t machine_m;
 
private:
    class implementation_t;
    implementation_t* object_m;
};
 
/**************************************************************************************************/

 
struct set_monitor_t {
    set_monitor_t(sheet_t& sheet, name_t cell_name) : cell_name_m(cell_name), sheet_m(sheet) {}
 
    void operator()(const any_regular_t& x) { sheet_m.get().set(cell_name_m, x); }
 
private:
    name_t cell_name_m;
    boost::reference_wrapper<sheet_t> sheet_m;
};
 
/**************************************************************************************************/
 
/*
    REVISIT (sparent) : line_position_t and array_t need to go in favor of a function object.
*/

struct sheet_t::relation_t {
    relation_t() {}
    relation_t(std::vector<name_t> n, line_position_t p, array_t e)
        : name_set_m(std::begin(n), std::end(n)), position_m(p), expression_m(std::move(e)) {}
 
    friend void swap(relation_t& x, relation_t& y) {
        swap(x.name_set_m, y.name_set_m);
        swap(x.position_m, y.position_m);
        swap(x.expression_m, y.expression_m);
    }
 
    relation_t(relation_t&& x) noexcept
        : name_set_m(x.name_set_m), position_m(x.position_m),
          expression_m(std::move(x.expression_m)) {}
 
    relation_t(const relation_t&) = default;
 
    relation_t& operator=(relation_t x) {
        swap(*this, x);
        return *this;
    }
 
 
    std::vector<name_t> name_set_m;
    line_position_t position_m;
    array_t expression_m;
};
 
/**************************************************************************************************/
 
} // namespace adobe
 
/**************************************************************************************************/
 
#endif
 
/**************************************************************************************************/