cust_print.H

/* cust_print.H */
/* $Id: cust_print.H,v 1.5 2009/04/17 11:32:40 ibadm Exp $ */
#ifdef __CubeStorage_H


template<class T>
void
CubeStorage<T>::print_index (int* i) const
{
  int   dim_i;

  if(NULL == i)
    Throw(ERROR__NULL);

  for(dim_i = 0; dim_i < nDim; ++dim_i)
    {
      if(0 == dim_i)
    fputc('[', fpLog);
      else
    fputc(' ', fpLog);
      if(i[dim_i] < 0)
    fputc('X', fpLog);
      else
    fprintf(fpLog, "%d", i[dim_i]);
    }
  fputc(']', fpLog);
}


template<class T>
void
CubeStorage<T>::print_direction (FILE* fp, const char* format)
{
  fpLog = fp;

  if(NULL == format)
    szFormat = NULL;
  else
    {
      szFormat = new char[1 + strlen(format)];
      strcpy(szFormat, format);
    }
}


template<class T>
void
CubeStorage<T>::print_info () const
{
  fprintf(fpLog, "CubeStorage(this=%p)"\
      "\n\titem size = %lu bytes"\
      "\n\titem order ala %s"\
      "\n\tnumber of dimensions = %d"\
      "\n\tdimensions are = ",
      this, sizeof(T),
      eItemOrder==AlaC? "C/C++": (eItemOrder==AlaFortran
                      ? "Fortran"
                      : "???"),
      nDim);
  print_index(pDim);
#ifdef CuSt_AtomItem
  fprintf(fpLog, "\n\tprintf format = \"%s\"\n",
      szFormat? szFormat: "(nil)");
#else
  fprintf(fpLog, "\n\tnot a printable due to undefined CuSt_AtomItem\n");
#endif /* CuSt_AtomItem */
}


template<class T>
void
CubeStorage<T>::print_cell (int* i) const
{
#ifdef CuSt_AtomItem
  fprintf(fpLog, szFormat, get(i));
  fputc('\n', fpLog);
#else
  fprintf(fpLog, "print_cell(this=%p) at ", this);
  print_index(i);
  fputc('\n',  fpLog);
#endif /* CuSt_AtomItem */
}


template<class T>
void
CubeStorage<T>::print_vector (int d, int* i) const
{
#ifdef CuSt_AtomItem
  int   j;
  int   stored_id = i[d];

  for(j = 0; j < dim(d); ++j)
    {
      i[d] = j;
      fprintf(fpLog, szFormat, get(i));
    }

  fputc('\n', fpLog);
  i[d] = stored_id;
#else
  fprintf(fpLog, "print_vector(this=%p, %d) at ", this, d);
  print_index(i);
  fputc('\n',  fpLog);
#endif /* CuSt_AtomItem */
}


template<class T>
void
CubeStorage<T>::print_matrix (int dv, int dh, int* i) const
{
#ifdef CuSt_AtomItem
  int   jh, jv;
  int   stored_idh = i[dh];
  int   stored_idv = i[dv];

  for(jv = 0; jv < dim(dv); ++jv)
    {
      i[dv] = jv;
      for(jh = 0; jh < dim(dh); ++jh)
    {
      i[dh] = jh;
      fprintf(fpLog, szFormat, get(i));
    }
      fputc('\n', fpLog);
    }

  i[dh] = stored_idh;
  i[dv] = stored_idv;
#else
  fprintf(fpLog, "print_matrix(this=%p, dv=%d, dh=%d) at ", this, dv, dh);
  print_index(i);
  fputc('\n',  fpLog);
#endif /* CuSt_AtomItem */
}


#if 0

template<class T>
void
CubeStorage<T>::print_contents () const
{
  int   dim_i, dim_j, *i = new int[nDim];
  Logic good = TRUE;

  for(dim_i = 0; dim_i < nDim; ++dim_i)
    i[dim_i] = 0;

  print_index(i);

  while(good)
    {
      /* print item */
      fputc(' ', fpLog);
      fprintf(fpLog, szFormat, get(i));

      /* flush flag of allowed index */
      good = FALSE;

      /* increment index */
      for(dim_i = nDim - 1; dim_i >= 0; --dim_i)
    if(i[dim_i] < pDim[dim_i] - 1)
      {
        ++i[dim_i];
        good = TRUE;
        break;
      }
    else
      {
        i[dim_i] = 0;
        fputc('\n', fpLog);
        print_index(i);
      }
    }

  fputc('\n', fpLog);
  delete[] i;
}


template<class T>
void
CubeStorage<T>::print_slice (int i0, ...) const
{
  int   dim_i, *iFlag = new int[nDim];

  /* Translate int i0, ... to iFlag[nDim] */
  iFlag[0] = i0;
  va_list   val;
  va_start(val, i0);
  for(dim_i = 1; dim_i < nDim; ++i)
    iFlag[dim_i] = va_arg(val, int);
  va_end(val);

  int   dim_j, dim_i, i = new int[nDim];
  Logic good = TRUE;

  for(dim_i = 0; dim_i < nDim; ++dim_i)
    if(iFlag[dim_i] < 0)
      i[dim_i] = 0;
    else
      i[dim_i] = iFlag[dim_i];

  while(good)
    {
      /* print item */
      print_index(i);
      fputc(' ', fpLog);
      fprintf(fpLog, szFormat, get(i));

      /* flush flag of allowed index */
      good = FALSE;

      /* increment index */
      for(dim_i = nDim - 1; dim_i >= 0; --dim_i)
    if(i[dim_i] < pDim[dim_i] - 1)
      {
        ++i[dim_i];
        good = TRUE;
        break;
      }
    else
      {
        i[dim_i] = 0;
        fputc('\n', fpLog);
      }
    }

  delete[] i;
  delete[] iFlag;
}
#endif


#endif /* cust_print.H */