array.hh

// Copyright (C) 2008, 2009 EPITA Research and Development Laboratory (LRDE)
//
// This file is part of Olena.
//
// Olena 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, version 2 of the License.
//
// Olena 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 Olena.  If not, see <http://www.gnu.org/licenses/>.
//
// As a special exception, you may use this file as part of a free
// software project without restriction.  Specifically, if other files
// instantiate templates or use macros or inline functions from this
// file, or you compile this file and link it with other files to produce
// an executable, this file does not by itself cause the resulting
// executable to be covered by the GNU General Public License.  This
// exception does not however invalidate any other reasons why the
// executable file might be covered by the GNU General Public License.

#ifndef MLN_FUN_I2V_ARRAY_HH
# define MLN_FUN_I2V_ARRAY_HH


# include <vector>
# include <algorithm>
# include <mln/core/concept/function.hh>
# include <mln/util/array.hh>
# include <mln/metal/equal.hh>
# include <mln/tag/init.hh>

# include <mln/fun/internal/selector.hh>

namespace mln
{

  namespace fun {
    namespace i2v {
      template <typename T> class array;
    } // end of namespace mln::fun::i2v
  } // end of namespace mln::fun



  namespace convert
  {

    namespace over_load
    {

      template <typename T>
      inline
      void
      from_to_(const util::array<T>& from, fun::i2v::array<T>& to);

      template <typename T, typename U>
      inline
      void
      from_to_(const util::array<T>& from, fun::i2v::array<U>& to);

      template <typename T>
      inline
      void
      from_to_(const std::vector<T>& from, fun::i2v::array<T>& to);

      template <typename T, typename U>
      inline
      void
      from_to_(const std::vector<T>& from, fun::i2v::array<U>& to);


    } // end of namespace mln::convert::over_load

  } // end of namespace mln::convert


  namespace fun
  {

    namespace i2v
    {

      template <typename T>
      class array
        : public fun::internal::selector_from_result_<T, array<T> >::ret
      {
      public:

        typedef T result;
        typedef typename std::vector<T>::reference mutable_result;


        array();
        array(unsigned n);
        array(unsigned n, const T& val);

        array(const util::array<T>& from);
        array(const std::vector<T>& from);


        void reserve(unsigned n);

        void resize(unsigned n);
        void resize(unsigned n, const T& val);

        void append(const T& val);

        unsigned size() const;

        result operator()(unsigned i) const;
        mutable_result operator()(unsigned i);

        void init_(unsigned n);

        const std::vector<T>& std_vector() const;

      protected:
        std::vector<T> v_;

      };


      template <typename T>
      std::ostream& operator<<(std::ostream& ostr,
                               const array<T>& a);


    } // end of namespace mln::fun::i2v

  } // end of namespace mln::fun



# ifndef MLN_INCLUDE_ONLY

  // Init.

  template <typename T1, typename T2>
  void init_(tag::function_t,
             fun::i2v::array<T1>&         f,
             const fun::i2v::array<T2>&   model)
  {
    f.init_(model.size());
  }


  // convert::from_to

  namespace convert
  {

    namespace over_load
    {

      template <typename T>
      inline
      void
      from_to_(const util::array<T>& from, fun::i2v::array<T>& to)
      {
        to = fun::i2v::array<T>(from);
      }

      template <typename T, typename U>
      inline
      void
      from_to_(const util::array<T>& from, fun::i2v::array<U>& to)
      {
        to.resize(from.nelements());
        for (unsigned i = 0; i < from.nelements(); ++i)
          to(i) = convert::to<U>(from[i]);
      }

      template <typename T>
      inline
      void
      from_to_(const std::vector<T>& from, fun::i2v::array<T>& to)
      {
        to = fun::i2v::array<T>(from);
      }

      template <typename T, typename U>
      inline
      void
      from_to_(const std::vector<T>& from, fun::i2v::array<U>& to)
      {
        to.resize(from.nelements());
        for (unsigned i = 0; i < from.size(); ++i)
          to(i) = convert::to<U>(from[i]);
      }


    } // end of namespace mln::convert::over_load

  } // end of namespace mln::convert




  namespace fun
  {

    namespace i2v
    {

      template <typename T>
      inline
      array<T>::array()
      {
      }

      template <typename T>
      inline
      array<T>::array(unsigned n)
        : v_(n)
      {
      }

      template <typename T>
      inline
      array<T>::array(unsigned n, const T& val)
        : v_(n, val)
      {
      }

      template <typename T>
      inline
      array<T>::array(const util::array<T>& from)
        : v_(from.std_vector())
      {

      }

      template <typename T>
      inline
      array<T>::array(const std::vector<T>& from)
        : v_(from)
      {

      }

      template <typename T>
      inline
      void
      array<T>::reserve(unsigned n)
      {
        v_.reserve(n);
      }

      template <typename T>
      inline
      void
      array<T>::resize(unsigned n)
      {
        v_.resize(n);
      }

      template <typename T>
      inline
      void
      array<T>::append(const T& val)
      {
        v_.push_back(val);
      }

      template <typename T>
      inline
      void
      array<T>::resize(unsigned n, const T& val)
      {
        v_.resize(n, val);
      }

      template <typename T>
      inline
      unsigned
      array<T>::size() const
      {
        return v_.size();
      }

      template <typename T>
      inline
      typename array<T>::result
      array<T>::operator()(unsigned i) const
      {
        mln_precondition(i < v_.size());
        return v_[i];
      }

      template <typename T>
      inline
      typename array<T>::mutable_result
      array<T>::operator()(unsigned i)
      {
        mln_precondition(i < v_.size());
        return v_[i];
      }

      template <typename T>
      inline
      void
      array<T>::init_(unsigned n)
      {
        v_.resize(n);
      }

      template <typename T>
      inline
      const std::vector<T>&
      array<T>::std_vector() const
      {
        return v_;
      }


      // Operator <<.

      template <typename T>
      std::ostream& operator<<(std::ostream& ostr,
                               const array<T>& a)
      {
        ostr << '(';
        const unsigned n = a.size();
        for (unsigned i = 0; i < n; ++i)
        {
          ostr << a(i);
          if (i != n - 1)
            ostr << ", ";
        }
        ostr << ')';
        return ostr;
      }


    } // end of namespace mln::fun::i2v

  } // end of namespace mln::fun


  template <typename T>
  inline
  fun::i2v::array<T> array(unsigned n, const T& t)
  {
    fun::i2v::array<T> tmp(n, t);
    return tmp;
  }

# endif // ! MLN_INCLUDE_ONLY

} // end of namespace mln


#endif // ! MLN_FUN_I2V_ARRAY_HH