adam.hpp

Go to the documentation of this file.

/*
    Copyright 2005-2008 Adobe Systems Incorporated
    Distributed under the MIT License (see accompanying file LICENSE_1_0_0.txt
    or a copy at http://stlab.adobe.com/licenses.html)
*/

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

#ifndef ADOBE_ADAM_HPP
#define ADOBE_ADAM_HPP

#include <adobe/config.hpp>

#include <functional>

#include <boost/utility.hpp>
#include <boost/function.hpp>

#ifdef __MWERKS__
    #pragma warn_unusedarg off
    #pragma warn_unusedvar off
#endif

#include <boost/signals.hpp>

#ifdef __MWERKS__
    #pragma warn_unusedarg reset
    #pragma warn_unusedvar reset
#endif

#include <adobe/any_regular_fwd.hpp>
#include <adobe/array.hpp>
#include <adobe/dictionary_fwd.hpp>
#include <adobe/istream.hpp>
#include <adobe/move.hpp>
#include <adobe/name_fwd.hpp>
#include <adobe/vector.hpp>
#include <adobe/virtual_machine.hpp>

/*

    REVISIT (sparent) : It would be best to detangle the sheet from
    the virtual machine. The way to do this is to allow for funciton
    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 programatic driving -
    however, one would have to construct condition objects which
    tracked dependencies and the sheet would require a get() method to
    retrieve the value of a cell.

*/

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

namespace adobe {

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

class sheet_t : boost::noncopyable
{
 public:
    struct relation_t;
    
    typedef boost::function<void (bool)>                 monitor_invariant_t;
    typedef boost::function<void (const any_regular_t&)> monitor_value_t;
    typedef boost::function<void (const dictionary_t&)>  monitor_contributing_t;
    typedef boost::function<void (bool)>                 monitor_enabled_t;
                                                           
    typedef boost::signals::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.
    
    any_regular_t get(name_t cell);
    
    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 : std::unary_function<any_regular_t, void>
{
    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(vector<name_t> n, line_position_t p, array_t e) :
        name_set_m(n),
        position_m(p),
        expression_m(adobe::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(move_from<relation_t> x) :
        name_set_m(x.source.name_set_m),
        position_m(x.source.position_m),
        expression_m(adobe::move(x.source.expression_m))
    { }
    
    relation_t& operator=(relation_t x) 
    { swap(*this, x); return *this; }


    vector<name_t>   name_set_m;
    line_position_t  position_m;
    array_t          expression_m;
};

/*************************************************************************************************/
    
} // namespace adobe

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

#endif

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