DataSet Class Reference

Declaration of DataSet class. More...

#include <DataSet.h>

Inheritance diagram for DataSet:

Public Member Functions
	DataSet ()
	DataSet (int enum_type)
	~DataSet ()
void	Marshall (char **pmarshalled_data, int *pmarshalled_data_size, int marshall_direction)
int	GetEnum ()
int	GetEnum (int offset)
void	Echo ()
void	DeepEcho ()
int	AddObject (Object *object)
int	DeleteObject (int id)
int	Size ()
void	clear ()
Object *	GetObjectByOffset (int offset)
Object *	GetObjectById (int *poffset, int eid)
void	Presort ()
void	Sort ()
DataSet *	Copy (void)
int	DeleteObject (Object *object)

Data Fields
std::vector< Object * >	objects
int	enum_type
int	sorted
int	presorted
int	numsorted
int *	sorted_ids
int *	id_offsets

Detailed Description

Declaration of DataSet class.

Declaration of DataSet class. A DataSet is a Container of Objects.

Definition at line 14 of file DataSet.h.

Constructor & Destructor Documentation

DataSet() [1/2]

DataSet::DataSet

(

)

Definition at line 27 of file DataSet.cpp.

                {/*{{{*/
 
   sorted=0;
   numsorted=0;
   presorted=0;
   enum_type=-1;
   sorted_ids=NULL;
   id_offsets=NULL;
 
}

DataSet() [2/2]

DataSet::DataSet

(

int

enum_type

)

Definition at line 38 of file DataSet.cpp.

                                {/*{{{*/
   enum_type=dataset_enum;
 
   sorted=0;
   numsorted=0;
   presorted=0;
   sorted_ids=NULL;
   id_offsets=NULL;
 
}

~DataSet()

DataSet::~DataSet

(

)

Definition at line 85 of file DataSet.cpp.

                 {/*{{{*/
   clear();
   xDelete<int>(sorted_ids);
   xDelete<int>(id_offsets);
}

Member Function Documentation

Marshall()

void DataSet::Marshall	(	char **	pmarshalled_data,
		int *	pmarshalled_data_size,
		int	marshall_direction
	)

Definition at line 93 of file DataSet.cpp.

                                                                                                  { /*{{{*/
 
   vector<Object*>::iterator obj;
   int obj_size=0;
   int obj_enum=0;
   int i;
 
   if(marshall_direction==MARSHALLING_FORWARD || marshall_direction==MARSHALLING_SIZE){
      obj_size=objects.size();
   }
   else{
      clear();
   }
 
   MARSHALLING_ENUM(DataSetEnum);
   MARSHALLING(enum_type);
   MARSHALLING(sorted);
   MARSHALLING(presorted);
   MARSHALLING(numsorted);
 
   /*Now branch according to direction of marshalling: */
   if(marshall_direction==MARSHALLING_FORWARD || marshall_direction==MARSHALLING_SIZE){
      if(!(this->sorted && numsorted>0 && this->id_offsets)){
         sorted_ids=NULL;
         id_offsets=NULL;
        }
      MARSHALLING_DYNAMIC(sorted_ids,int,numsorted);
      MARSHALLING_DYNAMIC(id_offsets,int,numsorted);
      MARSHALLING(obj_size);
 
      /*Go through our objects, and marshall them into the buffer: */
      for( obj=this->objects.begin() ; obj < this->objects.end(); obj++ ){
         obj_enum=(*obj)->ObjectEnum();
         MARSHALLING(obj_enum);
         (*obj)->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
      }
   }
   else{
 
      MARSHALLING_DYNAMIC(sorted_ids,int,numsorted);
      MARSHALLING_DYNAMIC(id_offsets,int,numsorted);
      if (!(this->sorted && numsorted>0)){
       sorted_ids=NULL;
       id_offsets=NULL;
      }
      MARSHALLING(obj_size);
 
      /*This is the heart of the demashalling method. We have a buffer coming
       in, and we are supposed to create a dataset out of it. No such thing
       as class orientation for buffers, we need to key off the enum of each
       object stored in the buffer. */
      for(i=0;i<obj_size;i++){
 
         /*Recover enum of object first: */
         MARSHALLING(obj_enum); 
 
         /*Giant case statement to spin-up the right object, and demarshall into it the information 
          *stored in the buffer: */
         if(obj_enum==NodeEnum){
            Node* node=NULL;
            node=new Node();
            node->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(node);
         }
         else if(obj_enum==VertexEnum){
            Vertex* vertex=NULL;
            vertex=new Vertex();
            vertex->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(vertex);
         }
         else if(obj_enum==MaticeEnum){
            Matice* matice=NULL;
            matice=new Matice();
            matice->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(matice);
         }
         else if(obj_enum==MatestarEnum){
            Matestar* matestar=NULL;
            matestar=new Matestar();
            matestar->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(matestar);
         }
         else if(obj_enum==SpcStaticEnum){
            SpcStatic* spcstatic=NULL;
            spcstatic=new SpcStatic();
            spcstatic->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(spcstatic);
         }
         else if(obj_enum==SpcDynamicEnum){
            SpcDynamic* spcdynamic=NULL;
            spcdynamic=new SpcDynamic();
            spcdynamic->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(spcdynamic);
         }
         else if(obj_enum==SpcTransientEnum){
            SpcTransient* spctransient=NULL;
            spctransient=new SpcTransient();
            spctransient->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(spctransient);
         }
         else if(obj_enum==TriaEnum){
            Tria* tria=NULL;
            tria=new Tria();
            tria->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(tria);
         }
         else if(obj_enum==PentaEnum){
            Penta* penta=NULL;
            penta=new Penta();
            penta->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(penta);
         }
         else if(obj_enum==TetraEnum){
            Tetra* tetra=NULL;
            tetra=new Tetra();
            tetra->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(tetra);
         }
         else if(obj_enum==SegEnum){
            Seg* seg=NULL;
            seg=new Seg();
            seg->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(seg);
         }
         else if(obj_enum==RiftfrontEnum){
            Riftfront* rift=NULL;
            rift=new Riftfront();
            rift->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(rift);
         }
         else if(obj_enum==NumericalfluxEnum){
            Numericalflux* numflux=NULL;
            numflux=new Numericalflux();
            numflux->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(numflux);
         }
         else if(obj_enum==PengridEnum){
            Pengrid* pengrid=NULL;
            pengrid=new Pengrid();
            pengrid->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(pengrid);
         }
         else if(obj_enum==PenpairEnum){
            Penpair* penpair=NULL;
            penpair=new Penpair();
            penpair->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            this->AddObject(penpair);
         }
         else if(obj_enum==DoubleExternalResultEnum){
            GenericExternalResult<double>* result=new GenericExternalResult<double>();
            result->Marshall(pmarshalled_data,pmarshalled_data_size,marshall_direction);
            result->Echo();
            this->AddObject(result);
         }
         else _error_("could not recognize enum type: " << obj_enum << ": " << EnumToStringx(obj_enum) ); 
      }
   }
}

GetEnum() [1/2]

int DataSet::GetEnum

(

)

Definition at line 324 of file DataSet.cpp.

                      {/*{{{*/
   return enum_type;
}

GetEnum() [2/2]

int DataSet::GetEnum

(

int

offset

)

Definition at line 328 of file DataSet.cpp.

                                {/*{{{*/
 
   return objects[offset]->ObjectEnum();
 
}

Echo()

void DataSet::Echo

(

void

)

Definition at line 307 of file DataSet.cpp.

                   {/*{{{*/
 
   vector<Object*>::iterator object;
 
   _assert_(this);
 
   _printf0_("DataSet echo: " << objects.size() << " objects\n");
 
   for ( object=objects.begin() ; object < objects.end(); object++ ){
 
      /*Call echo on object: */
      (*object)->Echo();
 
   }
   return;
}

DeepEcho()

void DataSet::DeepEcho

(

void

)

Definition at line 291 of file DataSet.cpp.

                       {/*{{{*/
 
   vector<Object*>::iterator object;
 
   _assert_(this);
 
   _printf0_("DataSet echo: " << objects.size() << " objects\n");
 
   for ( object=objects.begin() ; object < objects.end(); object++ ){
 
      /*Call deep echo on object: */
      (*object)->DeepEcho();
 
   }
}

AddObject()

int DataSet::AddObject

(

Object *

object

)

Definition at line 252 of file DataSet.cpp.

                                      {/*{{{*/
 
   _assert_(this);
   objects.push_back(object);
 
   return 1;
}

DeleteObject() [1/2]

int DataSet::DeleteObject

(

int

id

)

Size()

int DataSet::Size

(

void

)

Definition at line 399 of file DataSet.cpp.

                       {/*{{{*/
   _assert_(this!=NULL);
 
   return objects.size();
}

clear()

void DataSet::clear

(

)

Definition at line 260 of file DataSet.cpp.

                    {/*{{{*/
 
/*  use reverse_iterator for efficiency in matlab memory manager
   (keeping old code in case it needs to revert back)  */
 
// vector<Object*>::iterator object;
   vector<Object*>::reverse_iterator object;
 
// for ( object=objects.begin() ; object < objects.end(); object++ ){
//    delete (*object);
// }
   for ( object=objects.rbegin() ; object < objects.rend(); object++ ){
      delete (*object);
   }
   objects.clear();
}

GetObjectByOffset()

Object * DataSet::GetObjectByOffset

(

int

offset

)

Definition at line 334 of file DataSet.cpp.

                                            {/*{{{*/
 
   /*Check index in debugging mode*/
   _assert_(this!=NULL);
   _assert_(offset>=0);
   _assert_(offset<this->Size());
 
   return objects[offset];
 
}

GetObjectById()

Object * DataSet::GetObjectById	(	int *	poffset,
		int	eid
	)

Definition at line 345 of file DataSet.cpp.

                                                  {/*{{{*/
 
   int id_offset;
   int offset;
 
   _assert_(this);
   if(!sorted || objects.size()>numsorted)_error_("trying to binary search on a non-sorted dataset!");
 
   /*Carry out a binary search on the sorted_ids: */
   if(!binary_search(&id_offset,eid,sorted_ids,objects.size())){
      _error_("could not find object with id " << eid << " in DataSet " << EnumToStringx(enum_type));
   }
 
   /*Convert  the id offset into sorted offset: */
   offset=id_offsets[id_offset];
 
   /*Assign output pointers if requested:*/
   if(poffset)*poffset=offset;
 
   /*Return object at offset position in objects :*/
   return objects[offset];
}

Presort()

void DataSet::Presort

(

)

Definition at line 368 of file DataSet.cpp.

                      {/*{{{*/
 
   /*vector of objects is already sorted, just allocate the sorted ids and their
    * offsets:*/
   if(objects.size()){
 
      /*Delete existing ids*/
      if(sorted_ids) xDelete<int>(sorted_ids);
      if(id_offsets) xDelete<int>(id_offsets);
 
      /*Allocate new ids*/
      sorted_ids=xNew<int>(objects.size());
      id_offsets=xNew<int>(objects.size());
 
      /*Build id_offsets and sorted_ids*/
      for(int i=0;i<objects.size();i++){
         id_offsets[i]=i;
         sorted_ids[i]=objects[i]->Id();
 
         /*In debugging mode, make sure Ids are ACTUALLY sorted...*/
         #ifdef _ISSM_DEBUG_
         //if(i>0) _assert_(sorted_ids[i]>sorted_ids[i-1]);
         #endif
      }
   }
 
   /*set sorted flag: */
   numsorted=objects.size();
   sorted=1;
}

Sort()

void DataSet::Sort

(

)

Definition at line 405 of file DataSet.cpp.

                   {/*{{{*/
 
   /*Only sort if we are not already sorted: */
   if(!sorted){
      _error_("not implemented yet!");
   }
}

Copy()

DataSet * DataSet::Copy

(

void

)

Definition at line 49 of file DataSet.cpp.

                          {/*{{{*/
 
   vector<Object*>::iterator obj;
   Object* object_copy=NULL;
 
   DataSet* copy=new DataSet(this->enum_type);
 
   copy->sorted=this->sorted;
   copy->numsorted=this->numsorted;
   copy->presorted=this->presorted;
 
   /*Now we need to deep copy the objects: */
   for ( obj=this->objects.begin() ; obj < this->objects.end(); obj++ ){
      /*Call copy on object: */
      object_copy = (*obj)->copy();
      copy->AddObject(object_copy);
   }
 
   /*Build id_offsets and sorted_ids*/
   int objsize = this->numsorted;
   if(this->sorted && objsize>0 && this->id_offsets){ 
      /*Allocate new ids*/
      copy->id_offsets=xNew<int>(objsize);
      xMemCpy<int>(copy->id_offsets,this->id_offsets,objsize);
   }
   else copy->id_offsets=NULL;
   if(this->sorted && objsize>0 && this->sorted_ids){
      /*Allocate new ids*/
      copy->sorted_ids=xNew<int>(objsize);
      xMemCpy<int>(copy->sorted_ids,this->sorted_ids,objsize);
   }
   else copy->sorted_ids=NULL;
 
   return copy;
}

DeleteObject() [2/2]

int DataSet::DeleteObject

(

Object *

object

)

Definition at line 277 of file DataSet.cpp.

                                         {/*{{{*/
 
   vector<Object*>::iterator iterator;
 
   if(object){
      iterator = find(objects.begin(), objects.end(),object);
      delete *iterator;
      objects.erase(iterator);
   }
 
   return 1;
 
}

Field Documentation

objects

std::vector<Object*> DataSet::objects

Definition at line 19 of file DataSet.h.

enum_type

int DataSet::enum_type

Definition at line 22 of file DataSet.h.

sorted

int DataSet::sorted

Definition at line 25 of file DataSet.h.

presorted

int DataSet::presorted

Definition at line 26 of file DataSet.h.

numsorted

int DataSet::numsorted

Definition at line 27 of file DataSet.h.

sorted_ids

int* DataSet::sorted_ids

Definition at line 28 of file DataSet.h.

id_offsets

int* DataSet::id_offsets

Definition at line 29 of file DataSet.h.

---

The documentation for this class was generated from the following files:

• src/c/datastructures/DataSet.h
• src/c/datastructures/DataSet.cpp