ports.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012 Mark McCurry
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

 
#ifndef RTOSC_PORTS
#define RTOSC_PORTS
 
#include <vector>
#include <functional>
#include <initializer_list>
#include <rtosc/rtosc.h>
#include <rtosc/rtosc-version.h>
#include <cstring>
#include <cctype>
#include <cstdlib>
#include <cstdio>
#include <string>
 
namespace rtosc {
 
//First define all types
typedef const char *msg_t;
 
struct Port;
struct Ports;

struct RtData
{
    RtData(void);

    char *loc;
    size_t loc_size;
    void *obj;        
    int  matches;     
    const Port *port; 
    const char *message;
 
    int idx[16];
    void push_index(int ind);
    void pop_index(void);
 
    virtual void replyArray(const char *path, const char *args,
            rtosc_arg_t *vals);
    virtual void reply(const char *path, const char *args, ...);
    virtual void reply(const char *msg);
    virtual void chain(const char *path, const char *args, ...);
    virtual void chain(const char *msg);
    virtual void chainArray(const char *path, const char *args,
            rtosc_arg_t *vals);
    virtual void broadcast(const char *path, const char *args, ...);
    virtual void broadcast(const char *msg);
    virtual void broadcastArray(const char *path, const char *args,
            rtosc_arg_t *vals);
 
    virtual void forward(const char *rational=NULL);
};
 

struct Port {
    const char  *name;    
    const char  *metadata;
    const Ports *ports;   
    std::function<void(msg_t, RtData&)> cb;
 
    class MetaIterator
    {
        public:
            MetaIterator(const char *str);
 
            //A bit odd to return yourself, but it seems to work for this
            //context
            const MetaIterator& operator*(void) const {return *this;}
            const MetaIterator* operator->(void) const {return this;}
            bool operator==(MetaIterator a) {return title == a.title;}
            bool operator!=(MetaIterator a) {return title != a.title;}
            MetaIterator& operator++(void);
            operator bool() const;
 
            const char *title;
            const char *value;
    };
 
    class MetaContainer
    {
        public:
            MetaContainer(const char *str_);
 
            MetaIterator begin(void) const;
            MetaIterator end(void) const;
 
            MetaIterator find(const char *str) const;
            size_t length(void) const;
            const char *operator[](const char *str) const;
 
            const char *str_ptr;
    };
 
    MetaContainer meta(void) const
    {
        if(metadata && *metadata == ':')
            return MetaContainer(metadata+1);
        else
            return MetaContainer(metadata);
    }
 
};

struct Ports
{
    std::vector<Port> ports;
    std::function<void(msg_t, RtData&)> default_handler;
 
    typedef std::vector<Port>::const_iterator itr_t;

    itr_t begin() const {return ports.begin();}

    itr_t end() const {return ports.end();}

    size_t size() const {return ports.size();}

    const Port &operator[](unsigned i) const {return ports[i];}
 
    Ports(std::initializer_list<Port> l);
    ~Ports(void);
 
    Ports(const Ports&) = delete;

    void dispatch(const char *m, RtData &d, bool base_dispatch=false) const;

    const Port *operator[](const char *name) const;
 

    const Port *apropos(const char *path) const;

    static char *collapsePath(char *p);
 
    protected:
    void refreshMagic(void);
    private:
    //Performance hacks
    class Port_Matcher *impl;
    unsigned elms;
};
 
struct ClonePort
{
    const char *name;
    std::function<void(msg_t, RtData&)> cb;
};
 
struct ClonePorts:public Ports
{
    ClonePorts(const Ports &p,
               std::initializer_list<ClonePort> c);
};
 
struct MergePorts:public Ports
{
    MergePorts(std::initializer_list<const Ports*> c);
};

const char* get_default_value(const char* port_name, const Ports& ports,
                              void* runtime, const Port* port_hint = NULL,
                              int32_t idx = -1, int recursive = 1);

int get_default_value(const char* port_name, const char *port_args,
                      const Ports& ports,
                      void* runtime, const Port* port_hint,
                      int32_t idx,
                      size_t n, rtosc_arg_val_t* res,
                      char *strbuf, size_t strbufsize);
 

std::string get_changed_values(const Ports& ports, void* runtime);

class savefile_dispatcher_t
{
    const Ports* ports;
    void* runtime;
    char loc[1024];
 
protected:
    enum proceed {
        abort = -2, 
        discard = -1 
    };
 
    enum dependency_t {
        no_dependencies,  
        has_dependencies, 
        not_specified     
    };
 
    rtosc_version rtosc_filever, 
                  rtosc_curver, 
                  app_filever, 
                  app_curver; 

    void operator()(const char* msg);
 
    static int default_response(size_t nargs, bool first_round,
                                dependency_t dependency);
 
private:
    virtual int on_dispatch(size_t portname_max, char* portname,
                            size_t maxargs, size_t nargs,
                            rtosc_arg_val_t* args,
                            bool round2, dependency_t dependency);
 
    friend int dispatch_printed_messages(const char* messages,
                                         const Ports& ports, void* runtime,
                                         savefile_dispatcher_t *dispatcher);
 
    friend int load_from_file(const char* file_content,
                              const Ports& ports, void* runtime,
                              const char* appname,
                              rtosc_version appver,
                              savefile_dispatcher_t* dispatcher);
};

int dispatch_printed_messages(const char* messages,
                              const Ports& ports, void* runtime,
                              savefile_dispatcher_t *dispatcher = NULL);

std::string save_to_file(const Ports& ports, void* runtime,
                         const char* appname, rtosc_version appver);

int load_from_file(const char* file_content,
                   const Ports& ports, void* runtime,
                   const char* appname,
                   rtosc_version appver,
                   savefile_dispatcher_t* dispatcher = NULL);

int canonicalize_arg_vals(rtosc_arg_val_t* av, size_t n,
                          const char* port_args, Port::MetaContainer meta);

void map_arg_vals(rtosc_arg_val_t* av, size_t n,
                  Port::MetaContainer meta);
 
/*********************
 * Port walking code *
 *********************/
//typedef std::function<void(const Port*,const char*)> port_walker_t;
typedef void(*port_walker_t)(const Port*,const char*,const char*,
                             const Ports&,void*,void*);

void walk_ports(const Ports *base,
                char          *name_buffer,
                size_t         buffer_size,
                void          *data,
                port_walker_t  walker,
                void *runtime = NULL);

int enum_key(Port::MetaContainer meta, const char* value);
 
/*********************
 * Port Dumping code *
 *********************/
 
struct OscDocFormatter
{
    const Ports *p;
    std::string prog_name;
    std::string uri;
    std::string doc_origin;
    std::string author_first;
    std::string author_last;
    //TODO extend this some more
};
 
std::ostream &operator<<(std::ostream &o, OscDocFormatter &formatter);
};
#endif