//#     Filename:       VarStr.hxx
//#
//#     VarStr class functions
//#
//#
//#     Author:         Peter Z Kunszt
//#     
//#     Date:           July 4 2000
//#
//#
//# Copyright (C) 2000  Peter Z. Kunszt, Alex S. Szalay, Aniruddha R. Thakar
//#                     The Johns Hopkins University
//#
//# 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 program 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 this program; if not, write to the Free Software
//# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//#
/* --- VarStr methods ------------------------------------------------------ */
#include <stdlib.h>
#include <iostream.h>
inline
char *	VarStr::data() const{
  return vector_;
}

inline
bool 	VarStr::empty() const {
  return ( length_ == 0 ? true : false );
}

/////////////<<///////////////////////////////////////////
// write to ostream
//
inline
ostream& operator <<( ostream& out, const VarStr & s) {
  return(  out << s.data() );
}


// binary mode string extension
   
inline VarStr& 
VarStr::operator *=( const uint8 num )
{
   append( ((unsigned char *)&num), sizeof(num) );
   return *this;
}

// extension operator for short int

inline VarStr& 
VarStr::operator *=( const int16 num )
{
   append( ((unsigned char *)&num), sizeof(num) );
   return *this;
}

// extension operator for unsigned short int

inline VarStr& 
VarStr::operator *=( const uint16 num )
{
   append( ((unsigned char *)&num), sizeof(num) );
   return *this;
}

// extension operator for integer

inline VarStr& 
VarStr::operator *=( const int32 num )
{
   append( ((unsigned char *)&num), sizeof(num) );
   return *this;
}

// extension operator for unsigned integer

inline VarStr& 
VarStr::operator *=( const uint32 num )
{
   append( ((unsigned char *)&num), sizeof(num) );
   return *this;
}

// extension operator for long int

inline VarStr& 
VarStr::operator *=( const int64 num )
{
   append( ((unsigned char *)&num), sizeof(num) );
   return *this;
}

// extension operator for unsigned long int

inline VarStr& 
VarStr::operator *=( const uint64 num )
{
   append( ((unsigned char *)&num), sizeof(num) );
   return *this;
}

// extension operator for float

inline VarStr& 
VarStr::operator *=( const float32 num )
{
   append( ((unsigned char *)&num), sizeof(num) );
   return *this;
}

// extension operator for double

inline VarStr& 
VarStr::operator *=( const float64 num )
{
   append( ((unsigned char *)&num), sizeof(num) );
   return *this;
}

// append method: efficiently insert element at end of array

inline size_t	
VarStr::append( unsigned char *pBuf, const int len )
{
#if !defined(SXBIGENDIAN) && !defined(SPATIALBIGENDIAN)
   swapEndian( pBuf, len, 1 );
#endif
   for( int i = 0; i < len; i++ )
     (length_ < capacity_ ? vector_[length_++] : at(length_)) = pBuf[ i ];
   return length_;
}


inline void
VarStr::write( ostream& _out ) const {
  _out.write( vector_, length_ );
  _out.flush();
}