promote.h

/* -*- c++ -*- */
/*
 * Expresso, a C++ Array template class library
 * Copyright (C) 1998,2004 Oskar Enoksson (enok@lysator.liu.se)
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library 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
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA  02111-1307, USA.
 */
#ifndef EXPRESSO_PROMOTE_HDR
#define EXPRESSO_PROMOTE_HDR

#include "tmpltool.h"

namespace esso {

  enum { 
    schar, uchar, ssint, usint, 
    sint,  uint,  slint, ulint, 
    flt,   dflt,  ldflt, dummy 
  };

  template<class T>
  struct TypeToLevel {};

  template<> struct TypeToLevel<signed char> { 
  enum { Level=schar }; };
  template<> struct TypeToLevel<unsigned char> { 
  enum { Level=uchar }; };
  template<> struct TypeToLevel<signed short int> { 
  enum { Level=ssint }; };
  template<> struct TypeToLevel<unsigned short int> { 
  enum { Level=usint }; };
  template<> struct TypeToLevel<signed int> { 
  enum { Level=sint }; };
  template<> struct TypeToLevel<unsigned int> { 
  enum { Level=uint }; };
  template<> struct TypeToLevel<signed long int> { 
  enum { Level=slint }; };
  template<> struct TypeToLevel<unsigned long int> { 
  enum { Level=ulint }; };
  template<> struct TypeToLevel<float> { 
  enum { Level=flt }; };
  template<> struct TypeToLevel<double> { 
  enum { Level=dflt }; };
  template<> struct TypeToLevel<long double> { 
  enum { Level=ldflt }; };

  template<int N>
  struct LevelToType;

  template<> struct LevelToType<schar> { 
  typedef signed char Type; };
  template<> struct LevelToType<uchar> { 
  typedef unsigned char Type; };
  template<> struct LevelToType<ssint> { 
  typedef signed short int Type; };
  template<> struct LevelToType<usint> { 
  typedef unsigned short int Type; };
  template<> struct LevelToType<sint> { 
  typedef signed int Type; };
  template<> struct LevelToType<uint> { 
  typedef unsigned int Type; };
  template<> struct LevelToType<slint> { 
  typedef signed long int Type; };
  template<> struct LevelToType<ulint> { 
  typedef unsigned long int Type; };
  template<> struct LevelToType<flt> { 
  typedef float Type; };
  template<> struct LevelToType<dflt> { 
  typedef double Type; };
  template<> struct LevelToType<ldflt> { 
  typedef long double Type; };

  // Promotion rule for determining the element type
  // of the results of arithmetic array expressions.
  template<class Op, class T1, class T2>
  struct BPromote { 
  private:
    enum { Level1 = TypeToLevel<T1>::Level,
           Level2 = TypeToLevel<T2>::Level };
    enum { maxLevel = TmplTools::Max<Level1,Level2>::value };
  public:
    typedef typename LevelToType<maxLevel>::Type T;
  };

  // The following three promotion rules make it possible to use
  // any mix of Array<N,Ix<M,T> > and Array<N,T2> arrays 
  // arithmetic expressions and assignments.
  template<class Op, class T1, class T2, int N>
  struct BPromote<Op,Ix<N,T1>,Ix<N,T2> > { 
    typedef Ix<N,typename BPromote<Op,T1,T2>::T> T;
  };
  template<class Op, class T1, class T2, int N>
  struct BPromote<Op,Ix<N,T1>,T2> { 
    typedef Ix<N,typename BPromote<Op,T1,T2>::T> T;
  };
  template<class Op, class T1, class T2, int N>
  struct BPromote<Op,T1,Ix<N,T2> > { 
    typedef Ix<N,typename BPromote<Op,T1,T2>::T> T;
  };
}

#endif

---