functions.h

Go to the documentation of this file.

#ifndef FUNCTIONS_GROUP
#define FUNCTIONS_GROUP
 
/*****************************************************************************\
*                                                                             *
*  Name   : functions                                                         *
*  Author : Chris Koeritz                                                     *
*                                                                             *
*******************************************************************************
* Copyright (c) 1991-$now By Author.  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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/
 
#include "definitions.h"
 
namespace basis {
 
template <class type> type maximum(type a, type b)
        { return (a > b)? a : b; }
template <class type> type minimum(type a, type b)
        { return (a < b)? a : b; }
 
template <class type> type absolute_value(type a)
        { return (a >= 0)? a : -a; }
 
 
template <class type> bool positive(const type &a) { return a > 0; }
template <class type> bool non_positive(const type a) { return a <= 0; }
template <class type> bool negative(const type &a) { return a < 0; }
template <class type> bool non_negative(const type &a) { return a >= 0; }
 
 
// the following comparisons are borrowed from the STL.  they provide the full set of comparison
// operators for any object that implements the equalizable and orderable base classes.
template <class T1, class T2>
bool operator != (const T1 &x, const T2 &y) { return !(x == y); }
 
template <class T1, class T2>
bool operator > (const T1 &x, const T2 &y) { return y < x; }
 
template <class T1, class T2>
bool operator <= (const T1 &x, const T2 &y) { return !(y < x); }
 
template <class T1, class T2>
bool operator >= (const T1 &x, const T2 &y) { return !(x < y); }
 
 
template <class target_type, class source_type>
target_type *cast_or_throw(source_type &to_cast, const target_type &ignored)
{
//  if (!&ignored) {}  // do nothing.
  target_type *cast = dynamic_cast<target_type *>(&to_cast);
  if (!cast) throw "error: casting problem, unknown RTTI cast.";
  return cast;
}
 
template <class target_type, class source_type>
const target_type *cast_or_throw(const source_type &to_cast, const target_type &ignored)
{
// if (!&ignored) {}  // do nothing.
  const target_type *cast = dynamic_cast<const target_type *>(&to_cast);
  if (!cast) throw "error: casting problem, unknown RTTI cast.";
  return cast;
}
 
 
template <class type> bool range_check(const type &c, const type &low,
    const type &high) { return (c >= low) && (c <= high); }
 
template <class type> type square(const type &a) { return a * a; }
 
template <class type> void flip_increasing(type &a, type &b)
      { if (b < a) { type tmp = a; a = b; b = tmp; } }
 
template <class type> void flip_decreasing(type &a, type &b)
      { if (b > a) { type tmp = a; a = b; b = tmp; } }
 
template <class type> void swap_values(type &a, type &b)
      { type tmp = a; a = b; b = tmp; }
 
template <class type> type sign(type a)
      { if (a < 0) return -1; else if (a > 0) return 1; else return 0; }
 
 
// helpful coding / debugging macros:
 
 
template<class contents>
void WHACK(contents * &ptr) { if (ptr) { delete ptr; ptr = NULL_POINTER; } }
 
 
template <class type> type &bogonic() {
   static type local_bogon;
   return local_bogon;
}
 
 
template <class type>
type number_of_packets(type message_size, type packet_size)
{ return message_size / packet_size + ((message_size % packet_size) != 0); }
 
template <class type>
type last_packet_size(type message_size, type packet_size)
{ return message_size % packet_size? message_size % packet_size : packet_size; }
  /*< The companion call to number_of_packets; it returns the size of the last
  packet in the sequence of packets, taking into account the special case
  where the message_size divides evenly. */
 
 
} //namespace.
 
#endif