//===========================================================================
//  @(#) $Name: arts++-1-1-a12 $
//  @(#) $Id: ArtsTosTableData.cc,v 1.3 2004/10/22 18:26:27 rkoga Exp $
//===========================================================================
//  Copyright Notice
//
//  By accessing this software, arts++, you are duly informed
//  of and agree to be bound by the conditions described below in this
//  notice:
//
//  This software product, arts++, is developed by Daniel W. McRobb, and
//  copyrighted(C) 1998 by the University of California, San Diego
//  (UCSD), with all rights reserved.  UCSD administers the CAIDA grant,
//  NCR-9711092, under which part of this code was developed.
//
//  There is no charge for arts++ software.  You can redistribute it
//  and/or modify it under the terms of the GNU Lesser General Public
//  License, Version 2.1, February 1999, which is incorporated by
//  reference herein.
//
//  arts++ is distributed WITHOUT ANY WARRANTY, IMPLIED OR EXPRESS, OF
//  MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE or that the use
//  of it will not infringe on any third party's intellectual
//  property rights.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with arts++.  Copies can also be obtained from:
//
//    http://www.gnu.org/copyleft/lesser.html
//
//  or by writing to:
//
//  Free Software Foundation, Inc.
//  59 Temple Place, Suite 330
//  Boston, MA 02111-1307
//  USA
//
//  Or contact:
//
//    info@caida.org
//===========================================================================

#include <string>
#include <algorithm>

#include "Arts.hh"
#include "ArtsPrimitive.hh"
#include "ArtsTosTableData.hh"

using namespace std;

static const std::string rcsid = "@(#) $Name: arts++-1-1-a12 $ $Id: ArtsTosTableData.cc,v 1.3 2004/10/22 18:26:27 rkoga Exp $";

//-------------------------------------------------------------------------
//             ArtsTosTableEntry::ArtsTosTableEntry()
//-------------------------------------------------------------------------
ArtsTosTableEntry::ArtsTosTableEntry()
{
  this->_descriptor = 0;
  this->_tosNum = 0;
  this->_pkts = 0;
  this->_bytes = 0;

  #ifndef NDEBUG
    ++this->_numObjects;
  #endif
}

//-------------------------------------------------------------------------
//            ArtsTosTableEntry::~ArtsTosTableEntry()
//-------------------------------------------------------------------------
ArtsTosTableEntry::~ArtsTosTableEntry()
{
  #ifndef NDEBUG
    --this->_numObjects;
  #endif
}

//-------------------------------------------------------------------------
//         uint8_t ArtsTosTableEntry::TosNumber() const
//-------------------------------------------------------------------------
uint8_t ArtsTosTableEntry::TosNumber() const
{
  return(this->_tosNum);
}

//-------------------------------------------------------------------------
//  uint8_t ArtsTosTableEntry::TosNumber(uint8_t tosNum)
//-------------------------------------------------------------------------
uint8_t ArtsTosTableEntry::TosNumber(uint8_t tosNum)
{
  this->_tosNum = tosNum;
  return(this->_tosNum);
}

//-------------------------------------------------------------------------
//             uint64_t ArtsTosTableEntry::Pkts() const
//-------------------------------------------------------------------------
uint64_t ArtsTosTableEntry::Pkts() const
{
  return(this->_pkts);
}

//-------------------------------------------------------------------------
//          uint64_t ArtsTosTableEntry::Pkts(uint64_t pkts)
//-------------------------------------------------------------------------
uint64_t ArtsTosTableEntry::Pkts(uint64_t pkts)
{
  this->_pkts = pkts;

  if (pkts > (uint64_t)0xffffffff) {
    this->_descriptor = (this->_descriptor & 0xc7) | 0x38;    // use 8 bytes
  } else if (pkts > (uint64_t)0xffff) {
    this->_descriptor = (this->_descriptor & 0xc7) | 0x18;    // use 4 bytes
  } else if (pkts > (uint64_t)0xff) {
    this->_descriptor = (this->_descriptor & 0xc7) | 0x08;    // use 2 bytes
  } else {
    this->_descriptor = (this->_descriptor & 0xc7);           // use 1 byte
  }
  return(this->_pkts);
}

//-------------------------------------------------------------------------
//            uint64_t ArtsTosTableEntry::Bytes() const
//-------------------------------------------------------------------------
uint64_t ArtsTosTableEntry::Bytes() const
{
  return(this->_bytes);
}

//-------------------------------------------------------------------------
//        uint64_t ArtsTosTableEntry::Bytes(uint64_t bytes)
//-------------------------------------------------------------------------
uint64_t ArtsTosTableEntry::Bytes(uint64_t bytes)
{
  this->_bytes = bytes;

  if (bytes > (uint64_t)0xffffffff) {
    this->_descriptor = (this->_descriptor & 0xf8) | 0x07;    // use 8 bytes
  } else if (bytes > (uint64_t)0xffff) {
    this->_descriptor = (this->_descriptor & 0xf8) | 0x03;    // use 4 bytes
  } else if (bytes > (uint64_t)0xff) {
    this->_descriptor = (this->_descriptor & 0xf8) | 0x01;    // use 2 bytes
  } else {
    this->_descriptor = (this->_descriptor & 0xf8);           // use 1 byte
  }
  
  return(this->_bytes);
}

//-------------------------------------------------------------------------
//          uint8_t ArtsTosTableEntry::Descriptor() const
//-------------------------------------------------------------------------
uint8_t ArtsTosTableEntry::Descriptor() const
{
  return(this->_descriptor);
}

//-------------------------------------------------------------------------
//    uint8_t ArtsTosTableEntry::Descriptor(uint8_t descriptor)
//-------------------------------------------------------------------------
uint8_t ArtsTosTableEntry::Descriptor(uint8_t descriptor)
{
  this->_descriptor = descriptor;
  return(this->_descriptor);
}

//-------------------------------------------------------------------------
//   uint32_t ArtsTosTableEntry::Length(uint8_t version) const
//-------------------------------------------------------------------------
uint32_t ArtsTosTableEntry::Length(uint8_t version) const
{
  uint32_t  len = 0;

  len += sizeof(this->_tosNum);
  len += sizeof(this->_descriptor);
  len += (((this->_descriptor >> 3) + 1) +
          ((this->_descriptor & 0x07) + 1));
  
  return(len);
}

//-------------------------------------------------------------------------
// istream& ArtsTosTableEntry::read(istream& is, uint8_t version)
//-------------------------------------------------------------------------
istream& ArtsTosTableEntry::read(istream& is, uint8_t version)
{
  uint8_t  fieldLen;

  //  tos number
  is.read((char*)&this->_tosNum,sizeof(this->_tosNum));
  
  //  descriptor
  is.read((char*)&this->_descriptor,sizeof(this->_descriptor));

  //  pkts
  fieldLen = (this->_descriptor >> 3) + 1;
  g_ArtsLibInternal_Primitive.ReadUint64(is,this->_pkts,fieldLen);

  //  bytes
  fieldLen = (this->_descriptor & 0x07) + 1;
  g_ArtsLibInternal_Primitive.ReadUint64(is,this->_bytes,fieldLen);

  return(is);
}

//-------------------------------------------------------------------------
//      int ArtsTosTableEntry::read(int fd, uint8_t version)
//-------------------------------------------------------------------------
int ArtsTosTableEntry::read(int fd, uint8_t version)
{
  uint8_t  fieldLen;
  int      rc = 0;

  //  tos number
  rc += g_ArtsLibInternal_Primitive.FdRead(fd,&this->_tosNum,
                                           sizeof(this->_tosNum));
  
  //  descriptor
  rc += g_ArtsLibInternal_Primitive.FdRead(fd,&this->_descriptor,1);
  
  //  pkts
  fieldLen = (this->_descriptor >> 3) + 1;
  rc += g_ArtsLibInternal_Primitive.ReadUint64(fd,this->_pkts,fieldLen);

  //  bytes
  fieldLen = (this->_descriptor & 0x07) + 1;
  rc += g_ArtsLibInternal_Primitive.ReadUint64(fd,this->_bytes,fieldLen);

  if (rc != (int)this->Length(version))
    rc = -1;

  return(rc);
}

//-------------------------------------------------------------------------
//    ostream& ArtsTosTableEntry::write(ostream& os,
//                                           uint8_t version) const
//-------------------------------------------------------------------------
ostream& ArtsTosTableEntry::write(ostream& os,
                                       uint8_t version) const
{
  uint8_t  fieldLen;

  //  tos number
  os.write((char*)&this->_tosNum,sizeof(this->_tosNum));
  
  //  descriptor
  os.write((char*)&this->_descriptor,1);
  
  //  pkts
  fieldLen = (this->_descriptor >> 3) + 1;
  g_ArtsLibInternal_Primitive.WriteUint64(os,this->_pkts,fieldLen);

  //  bytes
  fieldLen = (this->_descriptor & 0x07) + 1;
  g_ArtsLibInternal_Primitive.WriteUint64(os,this->_bytes,fieldLen);

  return(os);
}

//-------------------------------------------------------------------------
//  int ArtsTosTableEntry::write(int fd, uint8_t version) const
//-------------------------------------------------------------------------
int ArtsTosTableEntry::write(int fd, uint8_t version) const
{
  uint8_t  fieldLen;
  int      rc = 0;

  //  tos number
  rc += g_ArtsLibInternal_Primitive.FdWrite(fd,&this->_tosNum,
                                            sizeof(this->_tosNum));

  //  descriptor
  rc += g_ArtsLibInternal_Primitive.FdWrite(fd,&this->_descriptor,1);

  //  pkts
  fieldLen = (this->_descriptor >> 3) + 1;
  rc += g_ArtsLibInternal_Primitive.WriteUint64(fd,this->_pkts,fieldLen);

  //  bytes
  fieldLen = (this->_descriptor & 0x07) + 1;
  rc += g_ArtsLibInternal_Primitive.WriteUint64(fd,this->_bytes,fieldLen);

  if (rc != (int)this->Length(version))
    rc = -1;

  return(rc);
}

//-------------------------------------------------------------------------
//   ArtsTosTableEntry &
//   operator = (const ArtsTosTableEntry & artsTosTableEntry)
//-------------------------------------------------------------------------
ArtsTosTableEntry &
ArtsTosTableEntry::operator = (const ArtsTosTableEntry & artsTosTableEntry)
{
  this->_tosNum = artsTosTableEntry.TosNumber();
  this->_descriptor = artsTosTableEntry.Descriptor();
  this->_pkts = artsTosTableEntry.Pkts();
  this->_bytes = artsTosTableEntry.Bytes();
  return(*this);
}

//-------------------------------------------------------------------------
//   ostream &                                
//   operator << (ostream& os,                
//                const ArtsTosTableEntry & artsTosTableEntry) 
//-------------------------------------------------------------------------
ostream &
operator << (ostream& os,
             const ArtsTosTableEntry & artsTosTableEntry)
{
  os << "\tTOS TABLE ENTRY" << endl;
  os << "\t\ttos: " << (int)artsTosTableEntry.TosNumber()
     << endl;
  os << "\t\tdescriptor: 0x"
     << hex << (int)artsTosTableEntry.Descriptor() << dec << endl;
  os << "\t\tpkts: " << artsTosTableEntry.Pkts() << endl;
  os << "\t\tbytes: " << artsTosTableEntry.Bytes() << endl;
  return(os);
}

//---------------------------------------------------------------------------
//      bool ArtsTosEntryGreaterBytes::
//      operator()(const ArtsTosTableEntry & tosEntry1,
//                 const ArtsTosTableEntry & tosEntry2) const
//---------------------------------------------------------------------------
bool ArtsTosEntryGreaterBytes::
operator()(const ArtsTosTableEntry & tosEntry1,
           const ArtsTosTableEntry & tosEntry2) const
{
  return(tosEntry1.Bytes() > tosEntry2.Bytes());
}

//---------------------------------------------------------------------------
//        bool ArtsTosEntryGreaterPkts::
//        operator()(const ArtsTosTableEntry & tosEntry1,
//                   const ArtsTosTableEntry & tosEntry2) const
//---------------------------------------------------------------------------
bool ArtsTosEntryGreaterPkts::
operator()(const ArtsTosTableEntry & tosEntry1,
           const ArtsTosTableEntry & tosEntry2) const
{
  return(tosEntry1.Pkts() > tosEntry2.Pkts());
}

uint32_t ArtsTosTableEntry::_numObjects = 0;





//-------------------------------------------------------------------------
//             ArtsTosTableData::ArtsTosTableData()
//.........................................................................
//  
//-------------------------------------------------------------------------
ArtsTosTableData::ArtsTosTableData()
{
  this->_sampleInterval = 1;
  this->_totpkts = 0;
  this->_totbytes = 0;
  this->_length = 0;

  #ifndef NDEBUG
    ++this->_numObjects;
  #endif
}

//-------------------------------------------------------------------------
//             ArtsTosTableData::~ArtsTosTableData()
//.........................................................................
//  
//-------------------------------------------------------------------------
ArtsTosTableData::~ArtsTosTableData()
{
  #ifndef NDEBUG
    --this->_numObjects;
  #endif
}

//-------------------------------------------------------------------------
//        uint16_t ArtsTosTableData::SampleInterval() const           
//.........................................................................
//  
//-------------------------------------------------------------------------
uint16_t ArtsTosTableData::SampleInterval() const
{
  return(this->_sampleInterval);
}

//-------------------------------------------------------------------------
// uint16_t ArtsTosTableData::SampleInterval(uint16_t sampleInterval)
//.........................................................................
//  
//-------------------------------------------------------------------------
uint16_t ArtsTosTableData::SampleInterval(uint16_t sampleInterval)
{
  this->_sampleInterval = sampleInterval;
  return(this->_sampleInterval);
}

//-------------------------------------------------------------------------
//           uint64_t ArtsTosTableData::TotalPkts() const              
//.........................................................................
//  
//-------------------------------------------------------------------------
uint64_t ArtsTosTableData::TotalPkts() const
{
  return(this->_totpkts);
}

//-------------------------------------------------------------------------
//      uint64_t ArtsTosTableData::TotalPkts(uint64_t totalPkts)
//.........................................................................
//  
//-------------------------------------------------------------------------
uint64_t ArtsTosTableData::TotalPkts(uint64_t totalPkts)
{
  this->_totpkts = totalPkts;
  return(this->_totpkts);
}

//-------------------------------------------------------------------------
//          uint64_t ArtsTosTableData::TotalBytes() const
//.........................................................................
//  
//-------------------------------------------------------------------------
uint64_t ArtsTosTableData::TotalBytes() const
{
  return(this->_totbytes);
}

//-------------------------------------------------------------------------
//    uint64_t ArtsTosTableData::TotalBytes(uint64_t totalBytes)
//.........................................................................
//  
//-------------------------------------------------------------------------
uint64_t ArtsTosTableData::TotalBytes(uint64_t totalBytes)
{
  this->_totbytes = totalBytes;
  return(this->_totbytes);
}

//-------------------------------------------------------------------------
//            vector<ArtsTosTableEntry> &
//            ArtsTosTableData::TosEntries() const
//.........................................................................
//  
//-------------------------------------------------------------------------
vector<ArtsTosTableEntry> &
ArtsTosTableData::TosEntries() const
{
  return(this->_tosEntries);
}

//-------------------------------------------------------------------------
//             void ArtsTosTableData::SortEntriesByBytes()            
//.........................................................................
//  
//-------------------------------------------------------------------------
void ArtsTosTableData::SortEntriesByBytes()
{
  sort(this->_tosEntries.begin(),this->_tosEntries.end(),
       ArtsTosEntryGreaterBytes());
  return;
}

//-------------------------------------------------------------------------
//             void ArtsTosTableData::SortEntriesByPkts()            
//.........................................................................
//  
//-------------------------------------------------------------------------
void ArtsTosTableData::SortEntriesByPkts()
{
  sort(this->_tosEntries.begin(),this->_tosEntries.end(),
       ArtsTosEntryGreaterPkts());
  return;
}

//-------------------------------------------------------------------------
// uint32_t ArtsTosTableData::ComputeLength(uint8_t version) const
//.........................................................................
//  
//-------------------------------------------------------------------------
uint32_t ArtsTosTableData::ComputeLength(uint8_t version) const
{
  this->_length = 0;
  
  this->_length += sizeof(_sampleInterval);
  this->_length += sizeof(_totpkts);
  this->_length += sizeof(_totbytes);
  this->_length += sizeof(uint32_t);  // number of tos entries

  vector<ArtsTosTableEntry>::const_iterator  tosEntry;

  for (tosEntry = this->_tosEntries.begin();
       tosEntry != this->_tosEntries.end(); tosEntry++) {
    this->_length += tosEntry->Length(version);
  }
  return(this->_length);
}

//-------------------------------------------------------------------------
//    uint32_t ArtsTosTableData::Length(uint8_t version) const
//.........................................................................
//  
//-------------------------------------------------------------------------
uint32_t ArtsTosTableData::Length(uint8_t version) const
{
  this->ComputeLength(version);
  return(this->_length);
}

//-------------------------------------------------------------------------
// istream& ArtsTosTableData::read(istream& is, uint8_t version)
//.........................................................................
//  
//-------------------------------------------------------------------------
istream& ArtsTosTableData::read(istream& is, uint8_t version)
{
  uint32_t            numToss;
  uint32_t            tosNum;
  ArtsTosTableEntry  tosEntry;
  
  g_ArtsLibInternal_Primitive.ReadUint16(is,this->_sampleInterval,2);
  g_ArtsLibInternal_Primitive.ReadUint64(is,this->_totpkts,8);
  g_ArtsLibInternal_Primitive.ReadUint64(is,this->_totbytes,8);
  g_ArtsLibInternal_Primitive.ReadUint32(is,numToss,4);
  this->_tosEntries.reserve(numToss);
  for (tosNum = 0; tosNum < numToss; tosNum++) {
    tosEntry.read(is,version);
    this->_tosEntries.push_back(tosEntry);
  }
  return(is);
}

//-------------------------------------------------------------------------
//      int ArtsTosTableData::read(int fd, uint8_t version)
//.........................................................................
//  
//-------------------------------------------------------------------------
int ArtsTosTableData::read(int fd, uint8_t version)
{
  uint32_t            numToss;
  uint32_t            tosNum;
  ArtsTosTableEntry  tosEntry;
  int                 rc;
  int                 bytesRead = 0;

  rc = g_ArtsLibInternal_Primitive.ReadUint16(fd,this->_sampleInterval,2);
  if (rc < 2)
    return(-1);
  bytesRead += rc;
  rc = g_ArtsLibInternal_Primitive.ReadUint64(fd,this->_totpkts,8);
  if (rc < 8)
    return(-1);
  bytesRead += rc;
  rc = g_ArtsLibInternal_Primitive.ReadUint64(fd,this->_totbytes,8);
  if (rc < 8)
    return(-1);
  bytesRead += rc;
  rc = g_ArtsLibInternal_Primitive.ReadUint32(fd,numToss,4);
  if (rc < 4)
    return(-1);
  bytesRead += rc;
  for (tosNum = 0; tosNum < numToss; tosNum++) {
    rc = tosEntry.read(fd,version);
    if (rc < 0)
      return(rc);
    bytesRead += rc;
    this->_tosEntries.push_back(tosEntry);
  }

  return(bytesRead);
}

//-------------------------------------------------------------------------
//    ostream& ArtsTosTableData::write(ostream& os,
//                                          uint8_t version) const
//.........................................................................
//  
//-------------------------------------------------------------------------
ostream& ArtsTosTableData::write(ostream& os,
                                      uint8_t version) const
{
  uint32_t            numToss;
  
  g_ArtsLibInternal_Primitive.WriteUint16(os,this->_sampleInterval,2);
  g_ArtsLibInternal_Primitive.WriteUint64(os,this->_totpkts,8);
  g_ArtsLibInternal_Primitive.WriteUint64(os,this->_totbytes,8);
  numToss = this->_tosEntries.size();
  g_ArtsLibInternal_Primitive.WriteUint32(os,numToss,4);

  vector<ArtsTosTableEntry>::const_iterator  tosEntry;
  
  for (tosEntry = this->_tosEntries.begin();
       tosEntry != this->_tosEntries.end(); tosEntry++) {
    tosEntry->write(os,version);
  }

  return(os);
}

//-------------------------------------------------------------------------
//  int ArtsTosTableData::write(int fd, uint8_t version) const
//.........................................................................
//  
//-------------------------------------------------------------------------
int ArtsTosTableData::write(int fd, uint8_t version) const
{
  uint32_t      numToss;
  int           rc;
  int           bytesWritten = 0;
  
  rc = g_ArtsLibInternal_Primitive.WriteUint16(fd,this->_sampleInterval,2);
  if (rc < 2)
    return(-1);
  bytesWritten += rc;
  
  rc = g_ArtsLibInternal_Primitive.WriteUint64(fd,this->_totpkts,8);
  if (rc < 8)
    return(-1);
  bytesWritten += rc;

  rc = g_ArtsLibInternal_Primitive.WriteUint64(fd,this->_totbytes,8);
  if (rc < 8)
    return(-1);
  bytesWritten += rc;

  numToss = this->_tosEntries.size();
  g_ArtsLibInternal_Primitive.WriteUint32(fd,numToss,4);
  if (rc < 4)
    return(-1);
  bytesWritten += rc;

  vector<ArtsTosTableEntry>::const_iterator  tosEntry;
  
  for (tosEntry = this->_tosEntries.begin();
       tosEntry != this->_tosEntries.end(); tosEntry++) {
    rc = tosEntry->write(fd,version);
    if (rc < 0)
      return(rc);
    bytesWritten += rc;
  }

  return(bytesWritten);
}

//-------------------------------------------------------------------------
//  ArtsTosTableData &                           
//  operator = (const ArtsTosTableData & artsTosTableData) 
//.........................................................................
//  
//-------------------------------------------------------------------------
ArtsTosTableData &
ArtsTosTableData::operator = (const ArtsTosTableData & artsTosTableData)
{
  this->_sampleInterval = artsTosTableData.SampleInterval();
  this->_totpkts = artsTosTableData.TotalPkts();
  this->_totbytes = artsTosTableData.TotalBytes();
  this->_tosEntries = artsTosTableData.TosEntries();
  this->_length = artsTosTableData.Length();
  return(*this);
}

//-------------------------------------------------------------------------
//    ostream &
//    operator << (ostream& os,                   
//                 const ArtsTosTableData & artsTosTableData) 
//.........................................................................
//  
//-------------------------------------------------------------------------
ostream & operator << (ostream& os,
                       const ArtsTosTableData & artsTosTableData)
{
  os << "TOS OBJECT DATA" << endl;
  os << "\tsample_interval: " << artsTosTableData.SampleInterval()
     << endl;
  os << "\tcount: " << artsTosTableData.TosEntries().size() << endl;
  os << "\ttotpkts: " << artsTosTableData.TotalPkts() << endl;
  os << "\ttotbytes: " << artsTosTableData.TotalBytes() << endl;

  vector<ArtsTosTableEntry>::const_iterator  tosEntry;

  for (tosEntry = artsTosTableData.TosEntries().begin();
       tosEntry != artsTosTableData.TosEntries().end();
       tosEntry++) {
    os << *tosEntry;
  }
  
  return(os);
}

uint32_t  ArtsTosTableData::_numObjects = 0;