global.h

/**************************************************************************
 * Copyright (c) 2002-2011 T. M. Murali                                   *
 *                                                                        *
 * This file is part of Biorithm.                                         *
 *                                                                        *
 * Biorithm 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 3 of the License, or      *
 * (at your option) any later version.                                    *
 *                                                                        *
 * Biorithm 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 Biorithm.  If not, see <http://www.gnu.org/licenses/>.      *
 *                                                                        *
 **************************************************************************/

// Purpose: projective clustering of gene expression data

#ifndef _GLOBAL_H
#define _GLOBAL_H

#include <iostream>
#include <fstream>
// include map since many other headers need it.
#include <map>
using namespace std;

#include "mystring.h"
#include "info.h"

typedef double MyNT;

//
// miscellaneous heplful functions and definitions.
//

// modelled on LEDA's forall in LEDA/iteration.h but adapted for STL
// containers.
#define MY_LOOP_VAR(y)  loop_var

#define MY_LOOP_ITERATOR_TYPE(p) (typename T::iterator)p

template<class T, class var_type>
inline void MY_LoopInf(const T& S, var_type& x, void* p) 
{
  if (MY_LOOP_ITERATOR_TYPE(p) != S.end())
    x = *(MY_LOOP_ITERATOR_TYPE(p));
}

template<class T>
inline bool MY_LoopSucc(const T& S, void*& p) 
{
  if (MY_LOOP_ITERATOR_TYPE(p) != S.end())
    {
      // you moron! increment p *before* assignment.
      p = ++(MY_LOOP_ITERATOR_TYPE(p));
      return true;
    }
  else return false;
}

#define MY_forall(x,S)\
for(void* MY_LOOP_VAR(__LINE__) = S.begin();\
MY_LoopInf(S,x,MY_LOOP_VAR(__LINE__)), MY_LoopSucc(S,MY_LOOP_VAR(__LINE__)); )


// print vectors. use the definition in graph-global.h. commenting
// this out may screw up compilation of xMotif.

// template < class item >
// ostream& operator<<(ostream& ostr, const vector< item >& v)
// {
//   for (unsigned int i = 0; i < v.size(); i++)
//     ostr << v[i] << " ";
// //  ostr << endl;
//   return(ostr);
// }

// print pair
template < class T1, class T2 > ostream& operator<<(ostream& ostr, const pair< T1, T2 >& p)
{
  ostr << "(" << p.first << ", " << p.second << ")";
  return(ostr);
}

// check if a file has been opened properly
inline bool fileCheck(ifstream& istr, const string& name)
{
  if (!istr)
    {
      cerr << "ERROR! Cannot open file \"" << name << "\".\n";
      return(false);
    }
  return(true);
}

inline bool fileCheck(ofstream& ostr, const string& name)
{
  if (!ostr)
    {
      cerr << "ERROR! Cannot open file \"" << name << "\".\n";
      return(false);
    }
  return(true);
}


#endif // _GLOBAL_H