/*

  Teem: Tools to process and visualize scientific data and images             .

  Copyright (C) 2013, 2012, 2011, 2010, 2009  University of Chicago

  Copyright (C) 2008, 2007, 2006, 2005  Gordon Kindlmann

  Copyright (C) 2004, 2003, 2002, 2001, 2000, 1999, 1998  University of Utah

  This library is free software; you can redistribute it and/or

  modify it under the terms of the GNU Lesser General Public License

  (LGPL) as published by the Free Software Foundation; either

  version 2.1 of the License, or (at your option) any later version.

  The terms of redistributing and/or modifying this software also

  include exceptions to the LGPL that facilitate static linking.

  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

  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License

  along with this library; if not, write to Free Software Foundation, Inc.,

  51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

*/

#include "gage.h"

#include "privateGage.h"

/*

******** gageVolumeCheck()

**

** checks whether a given volume is valid for the given kind

** and the given parameter settings in the context

**

** Note that ctx is simply passed to _gageShapeSet(), with no NULL-ity

** test- which is fine- it just means that the check is not specific

** to the parameters that can be set in the gageContext.

*/

int

gageVolumeCheck(const gageContext *ctx, const Nrrd *nin,

                const gageKind *kind) {

  static const char me[]="gageVolumeCheck";

  }

/*

******** gagePerVolumeNew()

**

** creates a new pervolume of a known kind, but nothing besides the

** answer array is allocated

**

** uses biff primarily because of the error checking in gageVolumeCheck()

*/

gagePerVolume *

gagePerVolumeNew(gageContext *ctx, const Nrrd *nin, const gageKind *kind) {

  static const char me[]="gagePerVolumeNew";

  gagePerVolume *pvl;

  int ii;

  airArray *mop;

  }

  /* Craziness: since circa 2003, the test below was to call gageVolumeCheck,

     which is now just a wrapper around _gageShapeSet(), and which never

     actually does the important checks of gageKindVolumeCheck (which in turn

     eventually calls gageVolumeCheck). This means that basic errors were not

     being caught, like having the wrong number of samples along axis 0 for

     non-scalar kinds. These various functions need to be simplified soon */

  }

  }

  }

  }

  }

  }

    }

  } else {

  }

/*

** _gagePerVolumeCopy()

**

** copies a pervolume for use in a copied context, and probably

** should only be called by gageContextCopy()

*/

gagePerVolume *

_gagePerVolumeCopy(gagePerVolume *pvl, unsigned int fd) {

  static const char me[]="gagePerVolumeCopy";

  gagePerVolume *nvl;

  int ii;

  airArray *mop;

  }

  /* we should probably restrict ourselves to gage API calls, but given the

     constant state of gage construction, this seems much simpler.

     Pointers to per-pervolume-allocated arrays are fixed below */

             "(fd=%u, valLen=%u, totAnsLen=%u, itemMax=%u)", me,

  }

  }

    }

    /* HEY: pvlDataNix takes 2 arguments; so we can't mop nvl->data,

       so its a good thing that we created nvl->data last */

  } else {

  }

/*

******** gagePerVolumeNix()

**

** frees all dynamically allocated memory assocated with a pervolume

**

** does not use biff

*/

gagePerVolume *

gagePerVolumeNix(gagePerVolume *pvl) {

}

/*

******** gageAnswerPointer()

**

** way of getting a pointer to a specific answer in a pervolume's ans array

**

** Returns NULL if the item is invalid, but there is no other error checking.

** In particular, this does not let you know if the item is actually part

** of the current query.

**

*/

const double *

gageAnswerPointer(const gageContext *ctx, const gagePerVolume *pvl, int item) {

  const double *ret;

  AIR_UNUSED(ctx);

    ret = NULL;

  }

}

/* non-const version of the above */

double *

_gageAnswerPointer(const gageContext *ctx, gagePerVolume *pvl, int item) {

  double *ret;

  AIR_UNUSED(ctx);

    ret = NULL;

  }

}

unsigned int

gageAnswerLength(const gageContext *ctx, const gagePerVolume *pvl, int item) {

  unsigned int ret;

  AIR_UNUSED(ctx);

    ret = 0;

  }

}

int

gageQueryReset(gageContext *ctx, gagePerVolume *pvl) {

  static const char me[]="gageQueryReset";

  AIR_UNUSED(ctx);

  }

}

/*

******** gageQuerySet()

**

** sets a query in a pervolume.  Does recursive expansion of query

** to cover all prerequisite measures.

**

** Sets: pvl->query

**

** the gageContext is not actually used here, but I'm cautiously

** including it in case its used in the future.

*/

int

gageQuerySet(gageContext *ctx, gagePerVolume *pvl, gageQuery query) {

  static const char me[]="gageQuerySet";

  gageQuery lastQuery;

  int pi, ii;

  AIR_UNUSED(ctx);

  }

  }

  /* recursive expansion of prerequisites */

  do {

        }

      }

  }

  /* doing this kind of error checking here is not really

     the way gage should work-- it should be done at the

     time of gageUpdate()-- but the novelty of pvl->data

     encourages putting new smarts at superficial levels

     instead of deeper levels */

      }

    }

  }

int

gageQueryAdd(gageContext *ctx, gagePerVolume *pvl, gageQuery query) {

  static const char me[]="gageQueryAdd";

  }

  }

}

int

gageQueryItemOn(gageContext *ctx, gagePerVolume *pvl, int item) {

  static const char me[]="gageQueryItemOn";

  }

  }

  }