#include "ebasearray.h"

#include "evar.h"
#include "efile.h"

ebasearray::ebasearray(){}
ebasearray::~ebasearray(){}

void ebasearray::save(const estr& file) const
{
  efile f(file,"w");
  estr s;
  serial(s);

  cout << "serialized len: " << s.len() << endl;
  f.write(s);
}

void ebasearray::load(const estr& file)
{
  efile f(file,"r");
  estr s;
  f.read(s);
  size_t i=0;
  unserial(s,i);
}

void ebasearray::json_serial(estr& data) const
{
  data+="[";
  size_t i;
  for (i=0; i<size(); ++i){
    getvar(i).json_serial(data);
    if (i+1<size()) data+=",";
  }
  data+="]";
}

void ebasearray::serial(estr& data) const
{
  serialuint(size(),data);
  size_t i;
  for (i=0; i<size(); ++i)
    getvar(i).serial(data);
}

size_t ebasearray::unserial(const estr& data,size_t i)
{
  if (i==-1) return(i);

  unsigned int count;
  evar var;
  i=unserialuint(count,data,i);
  if (i==-1) return(-1);
  while(count && i<data.len()){
    var.clear();
    i=var.unserial(data,i);
    if (i==-1) return(-1);
    addvar(var);
    --count;
  }
  if (count>0) return(-1);
  return(i);
}

void ebasearray::serial(const efile& f) const
{
  serialuint(size(),f);
  size_t i;
  for (i=0; i<size(); ++i)
    getvar(i).serial(f);
}

bool ebasearray::unserial(const efile& f)
{
  unsigned int count;
  evar var;
  clear();
  if (!unserialuint(count,f)) return(false);

  while(count){
    var.clear();
    if (!var.unserial(f)) return(false);
    addvar(var);
    --count;
  }
  if (count>0) return(false);
  return(true);
}

evar ebasearray::operator[](size_t i) const
{
  return(getvar(i));
}

ostream& operator<<(ostream& stream,const ebasearray& arr)
{
  size_t i;
  stream << "[";
  if (arr.size()==0) { stream << "]"; return(stream); }

  for (i=0; i<arr.size()-1; ++i)
    stream << arr.getvar(i) << ",";
  stream << arr.getvar(i);
  stream << "]";
  return(stream);
}