// ----------------------------------------------------------------------
//
// ColumnT - implementation of the template class ColumnT
//
//
// Note: the constructor of a columnT use the getColumnData_t()
//       function family to correctly set ColumnAttribs.type

#include "HepTuple/Column.h"
#include "HepTuple/ColumnT.h"
#include "ColumnType.h"

#include "HepTuple/HBookNameTag.h"

#include <cstdlib>
USING( std::string )


ZM_BEGIN_NAMESPACE( zmht )	/*  namespace zmht  {  */


// *************************** //
//                             //
// Constructors and copier     //
//                             //
// *************************** //

template <class T>
ColumnT<T>::ColumnT(Block* block, ColumnAttribs attrib) :
  Column(block,attrib),
  value(T()),
  valuesArray(0)
{
    _attributes.type = getColumnData_t( T() );
}

template <class T>
ColumnT<T>::ColumnT( Block* block, const string& tag) :
  Column( block, tag, getColumnData_t(T())),
  value(T()),
  valuesArray(0)
{
}

template <class T>
ColumnT<T>::~ColumnT() {
  if (valuesArray!= NULL) {
    delete valuesArray;
  }
}

template <class T>
Column* ColumnT<T>::duplicate(Block* newBlock) {
  ColumnAttribs ca ( _attributes );
  ca.variable = 0;
  ca.function = 0;
  ca.getMethod = 0;
  ca.destination = 0;
  ca.destFunction = 0;
  ca.setMethod = 0;
  return (new ColumnT(newBlock,ca));
}

// *************************** //
//                             //
// check the type              //
//                             //
// *************************** //

//template <class T>
//bool ColumnT<T>::checkType(T) {
//  return true;
//}
//template <class T>
//ColumnData_t ColumnT<T>::Type()

// *************************** //
//                             //
// set values                  //
//                             //
// *************************** //

template <class T>
bool ColumnT<T>::setDefaultValue(T defVal) {
  return _attributes.setDefaultValue(defVal);
}

template <class T>
bool ColumnT<T>::setDesignatedVariable(T* variable) {
  _attributes.function = 0;
  _attributes.getMethod = 0;
  _attributes.variable = (void*) variable;
  return true;
}

template <class T>
bool ColumnT<T>::setDesignatedFunction(inputFunction function) {
  _attributes.variable = 0;
  _attributes.getMethod = 0;
  _attributes.function = (genericFunction)function;
  return true;
}

template <class T>
bool ColumnT<T>::setDesignatedMethod(ZMuseMethod<T>* method) {
  _attributes.variable = 0;
  _attributes.function = 0;
  _attributes.getMethod = (void*) method;
  return true;
}

template <class T>
bool ColumnT<T>::setDestinationVariable(T* variable) {
  _attributes.destFunction = 0;
  _attributes.setMethod = 0;
  _attributes.destination = (void*) variable;
  return true;
}

template <class T>
bool ColumnT<T>::setDestinationFunction(outputFunction function) {
  _attributes.destination = 0;
  _attributes.setMethod = 0;
  _attributes.destFunction = (genericFunction)function;
  return true;
}

template <class T>
bool ColumnT<T>::setDestinationMethod(ZMsetMethod<T>* method) {
  _attributes.destination = 0;
  _attributes.destFunction = 0;
  _attributes.setMethod = (void*) method;
  return true;
}

// *************************** //
//                             //
// Capture                     //
//                             //
// *************************** //

template <class T>
bool ColumnT<T>::captureDesignatedValues() {
  if ( !captureCheck() ) {
    ZMthrow(ZMxHepAlreadyDone(string("Column ")+name()+
			      " has already been captured"));
    return false;
  }
  setIsCaptured(true);
  if ( _attributes.ndim == 0 ) {
    // Case of a single variable
    if( _attributes.isIndex && (_attributes.indexHi <= _attributes.indexLo)) 
        ZMthrow(ZMxHepIllFormedItem(string("Index column ")+name()+
                                    string(" has no span"))); 

    if ( _attributes.variable != NULL ) {
      value = * ((T*) _attributes.variable);
    } else if ( _attributes.function != NULL) {
      value = (reinterpret_cast<inputFunction>(_attributes.function) ) ();
    } else if ( _attributes.getMethod != NULL ) {
      value = ((ZMuseMethod<T>*)(_attributes.getMethod))->evaluate();
    }
    // If none of the two is true then the value is
    // kept.
  } else {
    // Case where the column actually contain an array!
    int sumDim = _attributes.sumDim();
    if ( valuesArray == NULL ) {
      setToDefault();
    }
    if ( _attributes.variable != NULL ) {
      memcpy(valuesArray,_attributes.variable,sizeof(T)*sumDim);
    }
    // here should go else if statement if we provide a way
    // to set array of column through methods/functions.

  }
  return true;
}

template < class T >
static
int forceInt( T newVal ) { return -1; }

template < >
int forceInt( Int4 newVal ) { return newVal; }

template <class T>
bool ColumnT<T>::captureValue(T newVal) {
  if ( !captureCheck() ) {
    ZMthrow(ZMxHepAlreadyDone(string("Column ")+name()+
			      " has already been captured"));
    return false;
  }
  setIsCaptured(true);
  if ( _attributes.ndim == 0 ) {
    // Case of a single variable
    if( _attributes.isIndex && (_attributes.indexHi <= _attributes.indexLo)) {
      ZMthrow(ZMxHepIllFormedItem(string("Index column ")+name()+
                                  string(" has no span"))); 
      return false;
    }
    if( _attributes.isIndex ) {

// Won't compile under OSF1!  Replace with following line.  JMM 15 Oct. 2001
//    int indexVal = (int)newVal;
      int indexVal = forceInt( newVal );

      if( indexVal < 0 ) {
        ZMthrow(ZMxHepTypeMismatch
  	      (string("Index column must be of type int: ")
	       +_attributes.tag));
      return false;
      }

      if( (indexVal > _attributes.indexHi || indexVal < _attributes.indexLo) ) {
        ZMthrow(ZMxHepOutOfRangeValue
  	      (string("Attempted capture with out-of-range value for index column: ")
	       +_attributes.tag));
      return false;
      }
    }
    value = newVal;
    return true;
  } else {
    // Case where the column actually contain an array!
    ZMthrow(ZMxHepImproperUse(
			"Can not use captureValue with an Array Column"));
    return false;
  }
}

template <class T>
bool ColumnT<T>::captureValues(const T newVal[],int indexVal) {
  if ( !captureCheck() ) {
    ZMthrow(ZMxHepAlreadyDone(string("Column ")+name()+
			      " has already been captured"));
    return false;
  }
  setIsCaptured(true);
  if ( _attributes.ndim == 0 ) {
    // Case of a single variable
    ZMthrow(ZMxHepImproperUse(
		"captureValues can only be used with an Array Column"));

    return false;
  } else {
    // Case where the column actually contain an array!
    if ( indexVal == 0 ) {
      indexVal = _attributes.sumDim();
    }
    if ( valuesArray == NULL ) {
      setToDefault();
    }
    memcpy(valuesArray,newVal,sizeof(T)*indexVal);
    return true;
  }
}

// *************************** //
//                             //
// reset default.              //
//                             //
// *************************** //

template <class T>
void ColumnT<T>::setToDefault() {
  if ( _attributes.ndim == 0 ) {
    // Case of a single variable

    if ( _attributes.defaultVal != NULL ) {
      value = * ((T*) _attributes.defaultVal);
    } else {
      value = 0;
    }
  } else {
    // Case where the column actually contain an array!
    int sumDim = _attributes.sumDim();
    if ( valuesArray == NULL ) {
      valuesArray = new T[sumDim];
    }
    if ( _attributes.defaultVal != NULL ) {
      for (int i=0; i<sumDim; i++) {
	valuesArray[i] = * ((T*) _attributes.defaultVal);
      }
    } else {
      for (int i=0; i<sumDim; i++) {
	valuesArray[i] = 0;
      }      
    }
  }
}

// *************************** //
//                             //
// Accessors                   //
//                             //
// *************************** //

// return the address of the value of the column.
template <class T>
void* ColumnT<T>::getValueAddr() {
  if ( _attributes.ndim != 0 ) {
    if ( valuesArray == NULL ) {
      setToDefault();
    }
    return valuesArray;
  }
  return &value;
}

// return the size of the base type of the column element
template <class T>
std::string::size_type ColumnT<T>::sizeofSingleElem() const {
  return sizeof(T);
}

// return the size of the content of the column
template <class T>
std::string::size_type ColumnT<T>::sizeofElem() const {
  if (  _attributes.ndim == 0 ) {
    return sizeof(T);
  } else {
    return _attributes.sumDim()* sizeof(T);
  }
}

// *************************** //
//                             //
// Memory copy functions       //
//                             //
// *************************** //

// this copy the content of the column at the location indicated by
// addr and return (addr + sizeofElem())
template <class T>
void* ColumnT<T>::copyToMem(void* addr) {
  if (  _attributes.ndim == 0 ) {
    //    *(T*)addr = value;
    // to avoid alignment errors
    memcpy(addr,&value,sizeof(T));
  } else {
    if ( valuesArray == NULL ) {
      setToDefault();
    }
    memcpy(addr,valuesArray,sizeof(T)*_attributes.sumDim());
  }
  return ((char*)addr+sizeofElem());
}

// this copy the content of the column FROM the location indicated by
// addr and return (addr + sizeofElem())
template <class T>
void* ColumnT<T>::copyFromMem(const void* addr) {
  if (  _attributes.ndim == 0 ) {
    //    *(T*)addr = value;
    // to avoid alignment errors
    memcpy(&value,addr,sizeof(T));
  } else {
    if ( valuesArray == NULL ) {
      setToDefault();
    }
    memcpy(valuesArray,addr,sizeof(T)*_attributes.sumDim());
  }
  return (void*)((char*)addr+sizeofElem());
}

template <class T>
bool ColumnT<T>::copyToMem(void* addr, const string& indices) {
  if (  _attributes.ndim == 0 ) {
    ZMthrow(ZMxHepImproperUse("Non-array column used as a array"));
    return false;
  }
  // Parse the string; we expect the indices string to be
  // a comma delimited list of indices.
  // the slowest varying indices is the last one.

  int offset = 0;
  int dimension = 0;
  int accumulateDim = 1;
  for (std::string::size_type i = 0; (i < indices.length()) && (dimension < _attributes.ndim); i++) {
    int loopStart = i;
    if ( !isdigit(indices[i]) ) {
      ZMthrow(ZMxHepBadFormat("Bad indices format in ColumnT::copyToMem"));
      return false;
    }
    while (  i < indices.length() && isdigit(indices[i]) ) {
      i++;
    };
    int val = atoi(indices.substr(loopStart,i-loopStart).c_str());
    if ( (val < 0) || (val >= _attributes.extents[dimension] )) {
      ZMthrow(ZMxHepOutOfRangeValue(string("for ")+name()+indices));
      return false;
    }
    offset += val*accumulateDim;
    accumulateDim *= _attributes.extents[dimension];
    dimension++;

    if ( i < indices.length() ) {
      if ( indices[i] != HBookNameTag::IndicesDelimiter[0] ) {
	ZMthrow(ZMxHepBadFormat("Bad indices format in ColumnT::copyToMem"));
	return false;
      }
    }
  }
  if ( dimension != _attributes.ndim ) {
    ZMthrow(ZMxHepBadFormat("Too many indices in format in ColumnT::copyToMem"));
    return false;
  }
  *(T*) addr = valuesArray[offset];
  return true;
}

// ******************************************************************** //
//                                                                      //
// Reading functions                                                    //
//                                                                      //
//  virtual bool read(void * addr);                                     //
// copy the value pointed to by addr to the designated variable         //
// function/method.  WARNING This CAN NOT check if the value is of      //
// the proper type. The addr MUST point to an array of the proper size  //
// if the column is an array.                                           //
//                                                                      //
// ******************************************************************** //

template <class T>
bool ColumnT<T>::read(const void* addr) {
  T* value_ptr = (T*)addr;

  if (  _attributes.ndim == 0 ) {
    // case of single value column

    if ( _attributes.destination != NULL ) {
      *(T*) _attributes.destination = *value_ptr;
      return true;
    } else if ( _attributes.destFunction != NULL ) {
      (reinterpret_cast<outputFunction>( _attributes.destFunction )) ( *value_ptr );
      return true;
    } else if ( _attributes.setMethod != NULL ) {
      ((ZMsetMethod<T>*) _attributes.setMethod)->set(*value_ptr);
      return true;
    }
  } else {
    if ( _attributes.destination != NULL ) {
      memcpy(_attributes.destination,addr,sizeof(T)*_attributes.sumDim());
      return true;
    }
  }
  return false;
}

// ******************************************************** //
//                                                          //
//  virtual bool read();                                    //
// copy the value of the column to the designated variable  //
// function/method.                                         //
//                                                          //
// ******************************************************** //

template <class T>
bool ColumnT<T>::read() {

  if (  _attributes.ndim == 0 ) {
    // case of single value column

    if ( _attributes.destination != NULL ) {
      *(T*) _attributes.destination = value;
      return true;
    } else if ( _attributes.destFunction != NULL ) {
      (reinterpret_cast<outputFunction>( _attributes.destFunction ))  ( value );
      return true;
    } else if ( _attributes.setMethod != NULL ) {
      ((ZMsetMethod<T>*) _attributes.setMethod)->set(value);
      return true;
    }
  } else {
    if ( _attributes.destination != NULL ) {
      memcpy(_attributes.destination,valuesArray,sizeof(T)*_attributes.sumDim());
      return true;
    }
  }
  return false;
}

// *************************** //
//                             //
// Explicit instantiation      //
//                             //
// *************************** //

template class ColumnT<Int1>;
template class ColumnT<Int2>;
template class ColumnT<Int4>;

#ifdef Int8
template class ColumnT<Int8>;
#endif

template class ColumnT<UInt1>;
template class ColumnT<UInt2>;
template class ColumnT<UInt4>;

#ifdef Uint8
template class ColumnT<UInt8>;
#endif

template class ColumnT<Float4>;
template class ColumnT<Float8>;

#ifdef Float16
template class ColumnT<Float16>;
#endif

template class ColumnT<bool>;
template class ColumnT<void*>;

ZM_END_NAMESPACE( zmht )	/*  }  // namespace zmht  */