cc.h

/* MLPACK 0.2
 *
 * Copyright (c) 2008, 2009 Alexander Gray,
 *                          Garry Boyer,
 *                          Ryan Riegel,
 *                          Nikolaos Vasiloglou,
 *                          Dongryeol Lee,
 *                          Chip Mappus, 
 *                          Nishant Mehta,
 *                          Hua Ouyang,
 *                          Parikshit Ram,
 *                          Long Tran,
 *                          Wee Chin Wong
 *
 * Copyright (c) 2008, 2009 Georgia Institute of Technology
 *
 * 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 2 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., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */
#ifndef BASE_CC_H
#define BASE_CC_H

#include "fastlib/base/common.h"

#include <algorithm>
#include <limits>

using std::min;
using std::max;

extern const double DBL_NAN;
extern const float FLT_NAN;
extern const double DBL_INF;
extern const float FLT_INF;

#define FORBID_ACCIDENTAL_COPIES(C) \
   private: \
    C (const C &src); \
    const C &operator=(const C &src);

#define ASSIGN_VIA_COPY_CONSTRUCTION(C) \
    const C &operator=(const C &src) { \
      if (likely(this != &src)) { \
        this->~C(); \
        new(this) C(src); \
      } \
      return *this; \
    }

#define ASSIGN_VIA_RECURSION_SAFE_COPY_CONSTRUCTION(C) \
    const C &operator=(const C &src) { \
      if (likely(this != &src)) { \
        char buf[sizeof(C)]; \
        memcpy(buf, this, sizeof(C)); \
        new(this) C(src); \
        reinterpret_cast<C *>(buf)->~C(); \
      } \
      return *this; \
    }

#define EXPAND_LESS_THAN(C) \
    friend bool operator>(C const &b, C const &a) {return a < b;} \
    friend bool operator<=(C const &b, C const &a) {return !(a < b);} \
    friend bool operator>=(C const &a, C const &b) {return !(a < b);}

#define EXPAND_GREATER_THAN(C) \
    friend bool operator<(C const &b, C const &a) {return a > b;} \
    friend bool operator>=(C const &b, C const &a) {return !(a > b);} \
    friend bool operator<=(C const &a, C const &b) {return !(a > b);}

#define EXPAND_EQUALS(C) \
    friend bool operator!=(C const &a, C const &b) {return !(a == b);}

#define EXPAND_HETERO_LESS_THAN(C, T) \
    friend bool operator>(T const &b, C const &a) {return a < b;} \
    friend bool operator<=(T const &b, C const &a) {return !(a < b);} \
    friend bool operator>=(C const &a, T const &b) {return !(a < b);}

#define EXPAND_HETERO_GREATER_THAN(C, T) \
    friend bool operator<(T const &b, C const &a) {return a > b;} \
    friend bool operator>=(T const &b, C const &a) {return !(a > b);} \
    friend bool operator<=(C const &a, T const &b) {return !(a > b);}

#define EXPAND_HETERO_EQUALS(C, T) \
    friend bool operator==(T const &b, C const &a) {return a == b;} \
    friend bool operator!=(C const &a, T const &b) {return !(a == b);} \
    friend bool operator!=(T const &b, C const &a) {return !(a == b);}

#define FOR_ALL_PRIMITIVES_DO(macro) \
    macro(char, "%c") \
    macro(short, "%d") \
    macro(int, "%d") \
    macro(long, "%ld") \
    macro(long long, "%lld") \
    macro(unsigned char, "%u") \
    macro(unsigned short, "%u") \
    macro(unsigned int, "%u") \
    macro(unsigned long, "%lu") \
    macro(unsigned long long, "%llu") \
    macro(float, "%g") \
    macro(double, "%g") \
    macro(long double, "%Lg")

class Empty {};

#endif /* BASE_CC_H */