MetadataMap.h

/*
 * #%L
 * OME-BIOFORMATS C++ library for image IO.
 * Copyright © 2006 - 2016 Open Microscopy Environment:
 *   - Massachusetts Institute of Technology
 *   - National Institutes of Health
 *   - University of Dundee
 *   - Board of Regents of the University of Wisconsin-Madison
 *   - Glencoe Software, Inc.
 * %%
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 * The views and conclusions contained in the software and documentation are
 * those of the authors and should not be interpreted as representing official
 * policies, either expressed or implied, of any organization.
 * #L%
 */

#ifndef OME_BIOFORMATS_METADATAMAP_H
#define OME_BIOFORMATS_METADATAMAP_H

#include <algorithm>
#include <cmath>
#include <iomanip>
#include <map>
#include <ostream>
#include <sstream>
#include <string>
#include <vector>

#include <ome/compat/cstdint.h>
#include <ome/common/variant.h>

namespace ome
{
  namespace bioformats
  {

    class MetadataMap
    {
    private:
      /*
       * The following series of typedefs may appear a little
       * complicated, and perhaps unnecessary, but they do have a
       * purpose.  They exist to work around pre-C++11 compiler
       * limitations (lack of variadic templates), primarily a limit
       * to the maximum number of types which may be used with
       * boost::variant.  To exceed this limit (minimum guaranteed is
       * 10), boost::mpl sequences are used to define the variant
       * types.  These also have length limits, so the type list is
       * built up by defining separate type sequences, then
       * concatenating them, and transforming them to provide list
       * variants.  Note that none of this is code per se; it's all
       * compile-time template expansion which evaluates to a list of
       * permitted types.
       */

      typedef boost::mpl::vector<std::string,
                                 bool> non_numeric_types;

      typedef boost::mpl::vector<uint8_t,
                                 uint16_t,
                                 uint32_t,
                                 uint64_t,
                                 int8_t,
                                 int16_t,
                                 int32_t,
                                 int64_t> integer_types;

      typedef boost::mpl::vector<float,
                                 double,
                                 long double> float_types;

      typedef boost::mpl::joint_view<integer_types,
                                     float_types>::type numeric_types_view;

      typedef boost::mpl::joint_view<non_numeric_types,
                                     numeric_types_view>::type basic_types_view;

      template<typename T>
      struct make_vector
      {
        typedef std::vector<T> type;
      };

      typedef boost::mpl::transform_view<basic_types_view, make_vector<boost::mpl::_1> >::type list_types_view;

      typedef boost::mpl::joint_view<basic_types_view, list_types_view> all_types_view;

      typedef boost::mpl::insert_range<boost::mpl::vector0<>, boost::mpl::end<boost::mpl::vector0<> >::type, all_types_view>::type discriminated_types;

    public:
      typedef std::string key_type;

      typedef boost::make_variant_over<discriminated_types>::type value_type;

      typedef std::map<key_type, value_type> map_type;

      typedef map_type::size_type size_type;

      typedef map_type::iterator iterator;

      typedef map_type::const_iterator const_iterator;

      typedef map_type::reverse_iterator reverse_iterator;

      typedef map_type::const_reverse_iterator const_reverse_iterator;

    private:
      map_type discriminating_map;

    public:
      MetadataMap()
      {}

      ~MetadataMap()
      {}

      void
      set(const key_type&   key,
          const value_type& value)
      {
        iterator i = find(key);
        if (i != end())
          erase(i);
        map_type::value_type newvalue(key, value);
        insert(newvalue);
      }

      template <typename T>
      void
      set(const key_type& key,
          const T&        value)
      {
        value_type v = value;
        set(key, v);
      }

      template <typename T>
      void
      append(const key_type& key,
             const T&        value)
      {
        typedef typename std::vector<T> list_type;

        try
          {
            list_type& list(get<list_type>(key));
            list.push_back(value);
          }
        catch (const boost::bad_get&)
          {
            list_type new_list;
            new_list.push_back(value);
            set(key, new_list);
          }
      }

      bool
      get(const key_type& key,
          value_type&     value) const
      {
        const_iterator i = find(key);
        if (i == end())
          return false;

        value = i->second;
        return true;
      }

      template <typename T>
      bool
      get(const key_type& key,
          T&              value) const
      {
        try
          {
            value = get<T>(key);
            return true;
          }
        catch (const boost::bad_get&)
          {
            return false;
          }
      }

      template <typename T>
      T&
      get(const key_type& key)
      {
        return boost::get<T>(get<value_type>(key));
      }

      template <typename T>
      const T&
      get(const key_type& key) const
      {
        return boost::get<T>(get<value_type>(key));
      }

      iterator
      find(const key_type& key)
      {
        return discriminating_map.find(key);
      }

      const_iterator
      find(const key_type& key) const
      {
        return discriminating_map.find(key);
      }

      std::pair<iterator, bool>
      insert(map_type::value_type& value)
      {
        return discriminating_map.insert(value);
      }

      void
      erase(const key_type& key)
      {
        discriminating_map.erase(key);
      }

      void
      erase(iterator pos)
      {
        discriminating_map.erase(pos);
      }

    private:
      struct getkey
      {
        template <typename T>
        typename T::first_type operator()(T pair) const
        {
          return pair.first;
        }
      };

    public:
      std::vector<key_type>
      keys() const
      {
        std::vector<key_type> ret;
        std::transform(begin(), end(), std::back_inserter(ret), getkey());
        std::sort(ret.begin(), ret.end());

        return ret;
      }

      void
      merge(const MetadataMap& map,
            const std::string& prefix)
      {
        for (const_iterator i = map.begin();
             i != map.end();
             ++i)
          {
            map_type::value_type v(prefix + i->first, i->second);
            insert(v);
          }
      }

      MetadataMap
      flatten() const;

      map_type&
      map()
      {
        return discriminating_map;
      }

      const map_type&
      map() const
      {
        return discriminating_map;
      }

      iterator
      begin()
      {
        return discriminating_map.begin();
      }

      const_iterator
      begin() const
      {
        return discriminating_map.begin();
      }

      iterator
      end()
      {
        return discriminating_map.end();
      }

      const_iterator
      end() const
      {
        return discriminating_map.end();
      }

      reverse_iterator
      rbegin()
      {
        return discriminating_map.rbegin();
      }

      const_reverse_iterator
      rbegin() const
      {
        return discriminating_map.rbegin();
      }

      reverse_iterator
      rend()
      {
        return discriminating_map.rend();
      }

      const_reverse_iterator
      rend() const
      {
        return discriminating_map.rend();
      }

      value_type&
      operator[] (const key_type& key)
      {
        return discriminating_map[key];
      }

      bool
      operator == (const MetadataMap& rhs) const
      {
        return discriminating_map == rhs.discriminating_map;
      }

      bool
      operator != (const MetadataMap& rhs) const
      {
        return discriminating_map != rhs.discriminating_map;
      }

      bool
      operator < (const MetadataMap& rhs) const
      {
        return discriminating_map < rhs.discriminating_map;
      }

      bool
      operator <= (const MetadataMap& rhs) const
      {
        return discriminating_map <= rhs.discriminating_map;
      }

      bool
      operator > (const MetadataMap& rhs) const
      {
        return discriminating_map > rhs.discriminating_map;
      }

      bool
      operator >= (const MetadataMap& rhs) const
      {
        return discriminating_map >= rhs.discriminating_map;
      }

      size_type
      size() const
      {
        return discriminating_map.size();
      }

      bool
      empty() const
      {
        return discriminating_map.empty();
      }

      void
      clear()
      {
        return discriminating_map.clear();
      }
    };

    namespace detail
    {

      struct MetadataMapValueTypeOStreamVisitor : public boost::static_visitor<>
      {
        std::ostream& os;

        MetadataMapValueTypeOStreamVisitor(std::ostream& os):
          os(os)
        {}

        template <typename T>
        void
        operator() (const std::vector<T> & c) const
        {
          for (typename std::vector<T>::const_iterator i = c.begin();
               i != c.end();
               ++i)
            {
              os << *i;
              if (i + 1 != c.end())
                os << ", ";
            }
        }

        template <typename T>
        void
        operator() (const T& v) const
        {
          os << v;
        }
      };

      struct MetadataMapOStreamVisitor : public boost::static_visitor<>
      {
        std::ostream& os;
        const MetadataMap::key_type& key;

        MetadataMapOStreamVisitor(std::ostream&                os,
                                  const MetadataMap::key_type& key):
          os(os),
          key(key)
        {}

        template <typename T>
        void
        operator() (const std::vector<T> & c) const
        {
          typename std::vector<T>::size_type idx = 1;
          // Determine the optimal padding based on the maximum digit count.
          int sf = static_cast<int>(std::log10(static_cast<float>(c.size()))) + 1;
          for (typename std::vector<T>::const_iterator i = c.begin();
               i != c.end();
               ++i, ++idx)
            {
              os << key << " #" << std::setw(sf) << std::setfill('0') << std::right << idx << " = " << *i << '\n';
            }
        }

        template <typename T>
        void
        operator() (const T& v) const
        {
          os << key << " = " << v << '\n';
        }
      };

      struct MetadataMapFlattenVisitor : public boost::static_visitor<>
      {
        MetadataMap& map;
        const MetadataMap::key_type& key;

        MetadataMapFlattenVisitor(MetadataMap&                 map,
                                  const MetadataMap::key_type& key):
          map(map),
          key(key)
        {}

        template <typename T>
        void
        operator() (const std::vector<T> & c) const
        {
          typename std::vector<T>::size_type idx = 1;
          // Determine the optimal padding based on the maximum digit count.
          int sf = static_cast<int>(std::log10(static_cast<float>(c.size()))) + 1;
          for (typename std::vector<T>::const_iterator i = c.begin();
               i != c.end();
               ++i, ++idx)
            {
              std::ostringstream os;
              os << key << " #" << std::setw(sf) << std::setfill('0') << std::right << idx;
              map.set(os.str(), *i);
            }
        }

        template <typename T>
        void
        operator() (const T& v) const
        {
          map.set(key, v);
        }
      };

    }

    template<>
    inline MetadataMap::value_type&
    MetadataMap::get<MetadataMap::value_type>(const key_type& key)
    {
      map_type::iterator i = discriminating_map.find(key);
      if (i == discriminating_map.end())
        throw boost::bad_get();

      return i->second;
    }

    template<>
    inline const MetadataMap::value_type&
    MetadataMap::get<MetadataMap::value_type>(const key_type& key) const
    {
      map_type::const_iterator i = discriminating_map.find(key);
      if (i == discriminating_map.end())
        throw boost::bad_get();

      return i->second;
    }

    inline
    MetadataMap
    MetadataMap::flatten() const
    {
      MetadataMap newmap;
      for (MetadataMap::const_iterator i = discriminating_map.begin();
           i != discriminating_map.end();
           ++i)
        {
          boost::apply_visitor(detail::MetadataMapFlattenVisitor(newmap, i->first), i->second);
        }
      return newmap;
    }

  }
}

namespace std
{

    template<class charT, class traits>
    inline basic_ostream<charT,traits>&
    operator<< (basic_ostream<charT,traits>& os,
                const ::ome::bioformats::MetadataMap::value_type& vt)
    {
      boost::apply_visitor(::ome::bioformats::detail::MetadataMapValueTypeOStreamVisitor(os), vt);
      return os;
    }

    template<class charT, class traits>
    inline basic_ostream<charT,traits>&
    operator<< (basic_ostream<charT,traits>& os,
                const ::ome::bioformats::MetadataMap& map)
    {
      for (::ome::bioformats::MetadataMap::const_iterator i = map.begin();
           i != map.end();
           ++i)
        {
          boost::apply_visitor(::ome::bioformats::detail::MetadataMapOStreamVisitor(os, i->first), i->second);
        }
      return os;
    }

}

#endif // OME_BIOFORMATS_METADATAMAP_H

/*
 * Local Variables:
 * mode:C++
 * End:
 */