atom.hpp

/*
    atom.hpp - support file for writing LV2 plugins in C++
    Copyright (C) 2012 Michael Fisher <mfisher31@gmail.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 01222-1307  USA
*/

#ifndef LVTK_ATOM_HPP
#define LVTK_ATOM_HPP

#include <string>

#include <lv2/lv2plug.in/ns/ext/atom/atom.h>
#include <lv2/lv2plug.in/ns/ext/atom/forge.h>
#include <lv2/lv2plug.in/ns/ext/atom/util.h>

namespace lvtk {

   typedef LV2_Atom_Event         AtomEvent;
   typedef LV2_Atom_Property_Body PropertyBody;
   typedef LV2_Atom_Forge_Frame   ForgeFrame;
   typedef LV2_Atom_Forge_Ref     ForgeRef;
   typedef LV2_Atom_Object_Query  ObjectQuery;


   struct AtomObject
   {
      AtomObject (const void* atom) : p_obj ((LV2_Atom_Object*) atom) { }

      AtomObject (ForgeRef ref) : p_obj ((LV2_Atom_Object*) ref) { }

      AtomObject (const AtomObject& other) : p_obj (other.p_obj) { }

      inline uint32_t
      otype() const
      {
          return p_obj->body.otype;
      }

      inline uint32_t
      id() const
      {
          return p_obj->body.id;
      }

      inline uint32_t
      total_size() const
      {
          return lv2_atom_total_size ((LV2_Atom*) p_obj);
      }

      inline void
      query (ObjectQuery& query)
      {
          lv2_atom_object_query (p_obj, &query);
      }

      inline LV2_Atom_Object* cobj() const     { return p_obj; }

      inline operator LV2_Atom_Object*()       { return p_obj; }

      inline AtomObject&
      operator= (const AtomObject& other)
      {
         p_obj = other.p_obj;
         return *this;
      }

      class iterator
      {
      public:

          iterator (LV2_Atom_Object* o, LV2_Atom_Property_Body* i)
              : index (i), obj (o) { }

          const PropertyBody& operator*()  const { assert (index); return *index; }
          const PropertyBody* operator->() const { assert (index); return index; }

          iterator& operator++()
          {
              index = lv2_atom_object_next (index);
              if (lv2_atom_object_is_end (&obj->body, obj->atom.size, index))
                  index = 0;
              return *this;
          }

          iterator operator++(int)
          {
              iterator ret (obj, index);
              ++(*this);
              return ret;
          }

          bool operator== (const iterator& other) const { return index == other.index; }
          bool operator!= (const iterator& other) const { return index != other.index; }

      private:

          friend class AtomObject;
          LV2_Atom_Property_Body* index;
          LV2_Atom_Object*        obj;

      };

      iterator begin() const { return iterator (p_obj, lv2_atom_object_begin (&p_obj->body)); }
      iterator end()   const { return iterator (p_obj, 0); }

   private:

      LV2_Atom_Object* p_obj;

   };


   struct Atom
   {
      Atom () : p_atom (0) { }

      Atom (const void* atom) : p_atom ((LV2_Atom*) atom)  { }

      Atom (ForgeRef ref) : p_atom ((LV2_Atom*) ref) { }

      Atom (AtomEvent* ev) : p_atom (&ev->body) { }

      inline static uint32_t
      pad_size (uint32_t size)
      {
          return lv2_atom_pad_size (size);
      }

      inline bool
      is_null()
      {
          return lv2_atom_is_null (p_atom);
      }

      inline void*
      body() const
      {
          return LV2_ATOM_BODY (p_atom);
      }

      inline bool
      as_bool() const
      {
          return ((LV2_Atom_Bool*)p_atom)->body > 0;
      }

      inline float
      as_float() const
      {
          return ((LV2_Atom_Float*)p_atom)->body;
      }

      const AtomObject
      as_object() const {
          return AtomObject ((LV2_Atom_Object* ) p_atom);
      }

      inline const char*
      as_string() const
      {
          return (const char*) LV2_ATOM_BODY (p_atom);
      }

      inline int32_t
      as_int() const
      {
          return ((LV2_Atom_Int*)p_atom)->body;
      }

      inline int64_t
      as_long() const
      {
          return ((LV2_Atom_Long*)p_atom)->body;
      }

      inline uint32_t
      as_urid() const
      {
          return ((LV2_Atom_URID*)p_atom)->body;
      }
      inline uint32_t
      type() const
      {
          return p_atom->type;
      }

      inline uint32_t
      total_size() const
      {
          return lv2_atom_total_size (p_atom);
      }

      inline uint32_t
      size() const
      {
          return p_atom->size;
      }

      inline const LV2_Atom*
      cobj() const
      {
          return p_atom;
      }

      inline operator const LV2_Atom*() { return cobj(); }

      inline Atom&
      operator= (const Atom& other)
      {
         p_atom = other.p_atom;
         return *this;
      }

      inline bool
      operator== (Atom& other)
      {
          return lv2_atom_equals (cobj(), other.cobj());
      }

   private:

      const LV2_Atom* p_atom;
      friend class AtomObject;

   };


   struct AtomSequence
   {
       typedef AtomEvent* pointer;
       typedef AtomEvent& reference;
       typedef const AtomEvent* const_pointer;
       typedef const AtomEvent& const_reference;

       AtomSequence (const void* seq) : p_seq ((LV2_Atom_Sequence*) seq) { }

       AtomSequence (LV2_Atom_Sequence* seq) : p_seq (seq) { }

       AtomSequence (ForgeRef ref) : p_seq ((LV2_Atom_Sequence*) ref) { }

       inline uint32_t
       pad() const
       {
           return p_seq->body.pad;
       }

       inline uint32_t
       size() const
       {
           return p_seq->atom.size;
       }

       inline uint32_t
       unit() const
       {
           return p_seq->body.unit;
       }

       inline LV2_Atom_Sequence*
       cobj()
       {
           return p_seq;
       }

       inline operator bool() const { return p_seq != 0; }

       inline operator LV2_Atom_Sequence*() const { return p_seq; }

       inline operator uint8_t*() const { return (uint8_t*) p_seq; }

       inline void
       append (const AtomEvent& ev)
       {
           if (AtomEvent* pos = lv2_atom_sequence_end (&p_seq->body, p_seq->atom.size))
           {
               memcpy (pos, &ev, sizeof (AtomEvent));
               memcpy (pos + 1, LV2_ATOM_BODY_CONST (&ev.body), ev.body.size);
               ((LV2_Atom*) p_seq)->size += sizeof (LV2_Atom_Event) + lv2_atom_pad_size (ev.body.size);
           }
       }

       inline void
       insert (const AtomEvent& ev)
       {
           const uint32_t evsize = sizeof (LV2_Atom_Event) + lv2_atom_pad_size (ev.body.size);
           AtomEvent* pos = lv2_atom_sequence_end (&p_seq->body, p_seq->atom.size);
           LV2_ATOM_SEQUENCE_FOREACH (p_seq, iter)
           {
               if (iter->time.frames > ev.time.frames)
               {
                   memmove ((uint8_t*)iter + evsize, iter,
                            (uint8_t*)pos - (uint8_t*)iter);
                   pos = iter;
                   break;
               }
           }

           if (pos)
           {
               memcpy (pos, &ev, sizeof (AtomEvent));
               memcpy (pos + 1, LV2_ATOM_BODY_CONST (&ev.body), ev.body.size);
               ((LV2_Atom*) p_seq)->size += evsize;
           }
       }

       class iterator
       {
       public:

           iterator (LV2_Atom_Sequence *seq, AtomEvent* ev) : p_event (ev), p_seq (seq) { }
           AtomEvent&  operator*()  { return *p_event; }
           const AtomEvent* operator->() const { return p_event; }

           iterator& operator++()
           {
               p_event = lv2_atom_sequence_next (p_event);
               return *this;
           }

           iterator operator++(int)
           {
               iterator res (p_seq, p_event);
               ++(*this);
               return res;
           }

           inline bool operator== (const iterator& other) const { return p_event == other.p_event; }
           inline bool operator!= (const iterator& other) const { return p_event != other.p_event; }

       private:

           friend class AtomSequence;
           LV2_Atom_Event* p_event;
           LV2_Atom_Sequence* p_seq;
       };

       inline iterator begin() const { return iterator (p_seq, lv2_atom_sequence_begin (&p_seq->body)); }

       inline iterator end()   const { return iterator (p_seq, lv2_atom_sequence_end (&p_seq->body, p_seq->atom.size)); }

   private:

       LV2_Atom_Sequence* p_seq;

   };


   class AtomForge : public LV2_Atom_Forge
   {
   public:

      AtomForge() { }

      AtomForge (LV2_URID_Map* map)
      {
         init (map);
      }

      inline void
      init (LV2_URID_Map* map)
      {
         lv2_atom_forge_init (this, map);
      }

      inline LV2_Atom_Forge*
      cobj()
      {
         return (LV2_Atom_Forge*) this;
      }

      inline ForgeRef
      sequence_head (ForgeFrame& frame, uint32_t unit)
      {
          return lv2_atom_forge_sequence_head (this, &frame, unit);
      }

      inline operator LV2_Atom_Forge* () { return cobj(); }

      inline void
      set_buffer (uint8_t* buf, uint32_t size)
      {
         lv2_atom_forge_set_buffer (this, buf, size);
      }

      inline ForgeRef
      beat_time (double beats)
      {
          return lv2_atom_forge_beat_time (this, beats);
      }

      inline ForgeRef
      frame_time (int64_t frames)
      {
          return lv2_atom_forge_frame_time (this, frames);
      }

      inline ForgeRef
      property_head (uint32_t key, uint32_t context)
      {
         return lv2_atom_forge_property_head (this, key, context);
      }

      inline void
      pop (ForgeFrame& frame)
      {
         lv2_atom_forge_pop (this, &frame);
      }

      inline ForgeRef
      write_atom (uint32_t size, uint32_t type)
      {
          return lv2_atom_forge_atom (this, size, type);
      }

      inline ForgeRef
      write_path (const std::string& path)
      {
          return lv2_atom_forge_path (this, path.c_str(), path.size());
      }

      inline ForgeRef
      write_resource (ForgeFrame& frame, uint32_t id, uint32_t otype)
      {
          return lv2_atom_forge_resource (this, &frame, id, otype);
      }

      inline ForgeRef
      write_blank (ForgeFrame& frame, uint32_t id, uint32_t otype)
      {
          return lv2_atom_forge_blank (this, &frame, id, otype);
      }

      inline ForgeRef
      write_bool (const bool val)
      {
          return lv2_atom_forge_bool (this, val);
      }

      inline ForgeRef
      write_int (const int val)
      {
          return lv2_atom_forge_int (this, val);
      }

      inline ForgeRef
      write_float (const float val)
      {
          return lv2_atom_forge_float (this, val);
      }

      inline ForgeRef
      write_long (const int64_t val)
      {
          return lv2_atom_forge_long (this, val);
      }

      inline ForgeRef
      write_string (const char* str)
      {
          return lv2_atom_forge_string (this, str, strlen (str));
      }

      inline ForgeRef
      write_uri (const char* uri)
      {
          return lv2_atom_forge_uri (this, uri, strlen (uri));
      }

      inline ForgeRef
      write_raw (const void* data, uint32_t size)
      {
          return lv2_atom_forge_raw (this, data, size);
      }

      inline ForgeRef
      write_urid (LV2_URID id)
      {
          return lv2_atom_forge_urid (this, id);
      }
   };


   class AtomVector
   {
   public:

       inline AtomVector (ForgeRef ref) : vec ((LV2_Atom_Vector*) ref) { }
       ~AtomVector() { }

       inline size_t size() const { return vec->atom.size / vec->body.child_size; }
       inline uint32_t child_size() const { return vec->body.child_size; }
       inline uint32_t child_type() const { return vec->body.child_type; }

       inline operator LV2_Atom_Vector* () const { return vec; }

       class iterator
       {
       public:

           iterator& operator++()
           {
               offset += vec->body.child_size;

               if (vec && offset >= vec->atom.size)
                   offset = vec->atom.size;

               return *this;
           }

           iterator operator++(int)
           {
               iterator it (vec, offset);
               ++(*this);
               return it;
           }

           inline bool operator== (const iterator& other) const { return vec == other.vec && offset == other.offset; }
           inline bool operator!= (const iterator& other) const { return vec != other.vec && offset != other.offset; }

           inline iterator& operator= (const iterator& other)
           {
               this->vec = other.vec;
               this->offset = other.offset;
               return *this;
           }

       private:
           friend class AtomVector;
           iterator (LV2_Atom_Vector *v, uint32_t os = 0) : vec (v), offset (os) { }
           LV2_Atom_Vector* vec;
           uint32_t offset;
       };

       iterator begin() const { return iterator (vec); }

       iterator end()   const { return iterator (vec, vec->atom.size); }

   private:
       LV2_Atom_Vector* vec;

   };

}  /* namespace lvtk */

#endif  /* LVTK_ATOM_HPP */