base.h

#ifndef FLAME_BASE_H
#define FLAME_BASE_H

#include <stdlib.h>

#include <ostream>
#include <string>
#include <map>
#include <vector>
#include <utility>

#include <boost/noncopyable.hpp>
#include <boost/any.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/call_traits.hpp>

#include "config.h"
#include "util.h"

#define FLAME_API_VERSION 0

struct ElementVoid;

struct StateBase : public boost::noncopyable
{
    virtual ~StateBase();

    size_t next_elem;

    double pos;        

    virtual void assign(const StateBase& other) =0;

    virtual void show(std::ostream&, int level =0) const {}

    struct ArrayInfo {
        enum {maxdims=3};
        ArrayInfo() :name(0), type(Double), ptr(NULL), ndim(0) {}
        const char *name;
        enum Type {
            Double, Sizet
        } type;
        void *ptr;
        unsigned ndim;
        size_t dim[maxdims];
        size_t stride[maxdims];

        bool inbounds(size_t* d) const {
            bool ret = true;
            switch(ndim) {
            case 3: ret &= d[2]<dim[2];
            case 2: ret &= d[1]<dim[1];
            case 1: ret &= d[0]<dim[0];
            }
            return ret;
        }

        void *raw(size_t* d) {
            char *ret = (char*)ptr;
            switch(ndim) {
            case 3: ret += d[2]*stride[2];
            case 2: ret += d[1]*stride[1];
            case 1: ret += d[0]*stride[0];
            }
            return ret;
        }

        template<typename E>
        inline E* get(size_t *d) {
            return (E*)raw(d);
        }
    };

    virtual bool getArray(unsigned index, ArrayInfo& Info);

    virtual StateBase* clone() const =0;

    void *pyptr;
protected:
    StateBase(const Config& c);
    struct clone_tag{};
    StateBase(const StateBase& c, clone_tag);
};

inline
std::ostream& operator<<(std::ostream& strm, const StateBase& s)
{
    s.show(strm, 0);
    return strm;
}

struct Observer : public boost::noncopyable
{
    virtual ~Observer() {}
    virtual void view(const ElementVoid* elem, const StateBase* state) =0;
};

struct ElementVoid : public boost::noncopyable
{
    ElementVoid(const Config& conf);
    virtual ~ElementVoid();

    virtual const char* type_name() const =0;

    virtual void advance(StateBase& s) =0;

    inline const Config& conf() const {return p_conf;}

    const std::string name; 
    const size_t index; 

    double length; 

    Observer *observer() const { return p_observe; }
    void set_observer(Observer *o) { p_observe = o; }

    virtual void show(std::ostream&, int level) const;

    virtual void assign(const ElementVoid* other ) =0;
private:
    Observer *p_observe;
    Config p_conf;
    friend class Machine;
};

struct Machine : public boost::noncopyable
{
    Machine(const Config& c);
    ~Machine();

    void propagate(StateBase* S,
                   size_t start=0,
                   size_t max=-1) const;

    StateBase* allocState(const Config& c) const;

    inline StateBase* allocState() const {
        Config defaults;
        return allocState(defaults);
    }

    inline const Config& conf() const { return p_conf; }

    void reconfigure(size_t idx, const Config& c);

    inline const std::string& simtype() const {return p_simtype;}

    inline std::ostream* trace() const {return p_trace;}
    void set_trace(std::ostream* v) {p_trace=v;}

private:
    typedef std::vector<ElementVoid*> p_elements_t;

    struct LookupKey {
        std::string name;
        size_t index;
        LookupKey(const std::string& n, size_t i) :name(n), index(i) {}
        bool operator<(const LookupKey& o) const {
            int ord = name.compare(o.name);
            if(ord<0)      return true;
            else if(ord>0) return false;
            else           return index<o.index;
        }
    };

    typedef std::map<LookupKey, ElementVoid*> p_lookup_t;
public:

    inline size_t size() const { return p_elements.size(); }

    inline ElementVoid* operator[](size_t i) { return p_elements[i]; }
    inline const ElementVoid* operator[](size_t i) const { return p_elements[i]; }

    inline ElementVoid* at(size_t i) { return p_elements.at(i); }
    inline const ElementVoid* at(size_t i) const { return p_elements.at(i); }

    typedef p_elements_t::iterator iterator;
    typedef p_elements_t::const_iterator const_iterator;

    iterator begin() { return p_elements.begin(); }
    const_iterator begin() const { return p_elements.begin(); }

    iterator end() { return p_elements.end(); }
    const_iterator end() const { return p_elements.end(); }

    ElementVoid* find(const std::string& name, size_t nth=0) {
        p_lookup_t::const_iterator low (p_lookup.lower_bound(LookupKey(name, 0))),
                                   high(p_lookup.upper_bound(LookupKey(name, (size_t)-1)));
        size_t i=0;
        for(;low!=high;++low,++i) {
            if(i==nth)
                return low->second;
        }
        return NULL;
    }

    typedef value_proxy_iterator<p_lookup_t::iterator> lookup_iterator;

    std::pair<lookup_iterator, lookup_iterator> all_range() {
        return std::make_pair(lookup_iterator(p_lookup.begin()),
                              lookup_iterator(p_lookup.end()));
    }

    std::pair<lookup_iterator, lookup_iterator> equal_range(const std::string& name) {
        p_lookup_t::iterator low (p_lookup.lower_bound(LookupKey(name, 0))),
                             high(p_lookup.upper_bound(LookupKey(name, (size_t)-1)));
        return std::make_pair(lookup_iterator(low),
                              lookup_iterator(high));
    }

    std::pair<lookup_iterator, lookup_iterator> equal_range_type(const std::string& name) {
        p_lookup_t::iterator low (p_lookup_type.lower_bound(LookupKey(name, 0))),
                             high(p_lookup_type.upper_bound(LookupKey(name, (size_t)-1)));
        return std::make_pair(lookup_iterator(low),
                              lookup_iterator(high));
    }


private:
    p_elements_t p_elements;
    p_lookup_t p_lookup; 
    p_lookup_t p_lookup_type; 
    std::string p_simtype;
    std::ostream* p_trace;
    Config p_conf;

    typedef StateBase* (*state_builder_t)(const Config& c);
    template<typename State>
    struct state_builder_impl {
        static StateBase* build(const Config& c)
        { return new State(c); }
    };
    struct element_builder_t {
        virtual ~element_builder_t() {}
        virtual ElementVoid* build(const Config& c) =0;
        virtual void rebuild(ElementVoid *o, const Config& c) =0;
    };
    template<typename Element>
    struct element_builder_impl : public element_builder_t {
        virtual ~element_builder_impl() {}
        ElementVoid* build(const Config& c)
        { return new Element(c); }
        void rebuild(ElementVoid *o, const Config& c)
        {
            std::auto_ptr<ElementVoid> N(build(c));
            Element *m = dynamic_cast<Element*>(o);
            if(!m)
                throw std::runtime_error("reconfigure() can't change element type");
            m->assign(N.get());
        }
    };

    struct state_info {
        std::string name;
        state_builder_t builder;
        typedef std::map<std::string, element_builder_t*> elements_t;
        elements_t elements;
    };

    state_info p_info;

    typedef std::map<std::string, state_info> p_state_infos_t;
    static p_state_infos_t p_state_infos;

    static void p_registerState(const char *name, state_builder_t b);

    static void p_registerElement(const std::string& sname, const char *ename, element_builder_t* b);

public:

    template<typename State>
    static void registerState(const char *name)
    {
        p_registerState(name, &state_builder_impl<State>::build);
    }

    template<typename Element>
    static void registerElement(const char *sname, const char *ename)
    {
        p_registerElement(sname, ename, new element_builder_impl<Element>);
    }

    static void registeryCleanup();

    friend std::ostream& operator<<(std::ostream&, const Machine& m);

    struct LogRecord {
        const char * fname;
        unsigned short lnum; // >=64k LoC in one file is already a bug
        unsigned short level;
        std::ostringstream strm;
        LogRecord(const char *fname, unsigned short lnum, unsigned short lvl)
            :fname(fname), lnum(lnum), level(lvl) {}
        ~LogRecord();
        template<typename T>
        LogRecord& operator<<(T v)
        { strm<<v; return *this; }
    private:
        LogRecord(const LogRecord&);
        LogRecord& operator=(const LogRecord&);
    };

    struct Logger {
        virtual ~Logger() {}
        virtual void log(const LogRecord& r)=0;
    };

    static int log_detail;

    static inline bool detail(int lvl) { return log_detail<=lvl; }

    static void set_logger(const boost::shared_ptr<Logger>& p);
private:
    static boost::shared_ptr<Logger> p_logger;
};

#define FLAME_ERROR 40
#define FLAME_WARN  30
#define FLAME_INFO  20
#define FLAME_DEBUG 10
// Super verbose logging, a la the rf cavity element
#define FLAME_FINE  0

#define FLAME_LOG_ALWAYS(LVL) Machine::LogRecord(__FILE__, __LINE__, FLAME_##LVL)

#ifndef FLAME_DISABLE_LOG
#define FLAME_LOG_CHECK(LVL) UNLIKELY(Machine::detail(FLAME_##LVL))
#else
#define FLAME_LOG_CHECK(LVL) (false)
#endif

#define FLAME_LOG(LVL) if(FLAME_LOG_CHECK(LVL)) FLAME_LOG_ALWAYS(LVL)

std::ostream& operator<<(std::ostream&, const Machine& m);

void registerLinear();
void registerMoment();

#endif // FLAME_BASE_H