evPriorityScheduleEntry.h

Go to the documentation of this file.

/*
 *
 * EVITA: Efficient Visualization of Terascale Datasets
 * Copyright (C) 2000-2016  Team Evita
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * 
 * This library 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
 * Library General Public License for more details.
 * 
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 675 Mass Ave, Cambridge,
 * MA 02139, USA.
 *
 */


#ifndef __evPriorityScheduleEntry_h
#define __evPriorityScheduleEntry_h


#include "evBitBuffer.h"
#include "evBoundingBox.h"


#define EVPRIORITYSCHEDULEENTRY_ROI 0x01
#define EVPRIORITYSCHEDULEENTRY_TILE 0x02
#define EVPRIORITYSCHEDULEENTRY_COMPONENT 0x04
#define EVPRIORITYSCHEDULEENTRY_BITPLANE 0x08
#define EVPRIORITYSCHEDULEENTRY_SCALE 0x10


class evPriorityScheduleEntry : public evDataObject
{
 public:
  evPriorityScheduleEntry(const unsigned int roi = 0,
                          const unsigned int tile = 0,
                          const unsigned int component = 0,
                          const unsigned int bitplane = 0,
                          const unsigned int scale = 0,
                          const unsigned int bitplane_length = 0,
                          const double priority = 0,
                          const evFilePosition file_position = 0,
                          const evBoundingBox &bounding_box = evBoundingBox(),
                          const double grid_spacing = 0,
                          const unsigned int max_num_scales = 0);
  evPriorityScheduleEntry(const evPriorityScheduleEntry &priority_schedule);
  
  static evPriorityScheduleEntry *Create(const unsigned int roi,
                                         const unsigned int tile,
                                         const unsigned int component,
                                         const unsigned int bitplane,
                                         const unsigned int scale,
                                         const unsigned int bitplane_length,
                                         const double priority,
                                         const evFilePosition file_position,
                                         const evBoundingBox &bounding_box,
                                         const double grid_spacing,
                                         const unsigned int max_num_scales);
  static evPriorityScheduleEntry *Create(const evPriorityScheduleEntry
                                         &priority_schedule_entry);
  virtual ~evPriorityScheduleEntry(void);
  
  virtual const evString GetClassName(void) const
    {
      return(evString("evPriorityScheduleEntry"));
    }
  
  int operator== (const evPriorityScheduleEntry &priority_schedule_entry)
    const;
  int IsEqual(const evPriorityScheduleEntry &priority_schedule_entry,
              const unsigned int match_mask) const;

  void SetROI(const unsigned int roi);
  unsigned int GetROI(void) const;

  void SetTile(const unsigned int tile);
  unsigned int GetTile(void) const;

  void SetComponent(const unsigned int component);
  unsigned int GetComponent(void) const;

  void SetBitplane(const unsigned int bitplane);
  unsigned int GetBitplane(void) const;

  void SetScale(const unsigned int scale);
  unsigned int GetScale(void) const;

  void SetBitplaneLength(const unsigned int bitplane_length);
  unsigned int GetBitplaneLength(void) const;

  void SetPriority(const double priority);
  double GetPriority(void) const;
  
  void SetFilePosition(const evFilePosition file_position);
  evFilePosition GetFilePosition(void) const;
  
  void SetBoundingBox(const evBoundingBox &bounding_box);
  evBoundingBox GetBoundingBox(void) const;

  void SetGridSpacing(const double grid_spacing);
  double GetGridSpacing(void) const;

  void SetMaxNumScale(const unsigned int max_num_scales);
  unsigned int GetMaxNumScales(void) const;
  
  void SetNext(evPriorityScheduleEntry *next);
  evPriorityScheduleEntry *GetNext(void) const;

  void SetPrevious(evPriorityScheduleEntry *previous);
  evPriorityScheduleEntry *GetPrevious(void) const;
  
  static evPriorityScheduleEntry *Read(evBitBuffer &input_buffer,
                                       const unsigned int num_dimensions);
  int Write(evBitBuffer &output_buffer) const;
  
  unsigned int CalcDisplayScale(const double pixel_size) const;
  
  void PrintSelf(const int tabbing) const;
  
 protected:
  
 private:
  unsigned int ROI;
  unsigned int Tile;
  unsigned int Component;
  unsigned int Bitplane;
  unsigned int Scale;
  unsigned int BitplaneLength;
  double Priority;
  evFilePosition FilePosition;
  evBoundingBox BoundingBox;
  double GridSpacing;
  unsigned int MaxNumScales;
  evPriorityScheduleEntry *Previous;
  evPriorityScheduleEntry *Next;
};


inline
evPriorityScheduleEntry::evPriorityScheduleEntry(const unsigned int roi,
                                                 const unsigned int tile,
                                                 const unsigned int component,
                                                 const unsigned int bitplane,
                                                 const unsigned int scale,
                                                 const unsigned int
                                                 bitplane_length,
                                                 const double priority,
                                                 const evFilePosition
                                                 file_position,
                                                 const evBoundingBox
                                                 &bounding_box,
                                                 const double grid_spacing,
                                                 const unsigned int
                                                 max_num_scales) :
  ROI(roi), Tile(tile), Component(component), Bitplane(bitplane), Scale(scale),
  BitplaneLength(bitplane_length), Priority(priority),
  FilePosition(file_position), BoundingBox(bounding_box),
  GridSpacing(grid_spacing), MaxNumScales(max_num_scales),
  Previous(NULL), Next(NULL)
{ }


inline
evPriorityScheduleEntry::evPriorityScheduleEntry(const evPriorityScheduleEntry
                                                 &priority_schedule)
{
  this->ROI = priority_schedule.ROI;
  this->Tile = priority_schedule.Tile;
  this->Component = priority_schedule.Component;
  this->Bitplane = priority_schedule.Bitplane;
  this->Scale = priority_schedule.Scale;
  this->BitplaneLength = priority_schedule.BitplaneLength;
  this->Priority = priority_schedule.Priority;
  this->FilePosition = priority_schedule.FilePosition;
  this->BoundingBox = priority_schedule.BoundingBox;
  this->GridSpacing = priority_schedule.GridSpacing;
  this->MaxNumScales = priority_schedule.MaxNumScales;
  this->Next = NULL;
  this->Previous = NULL;
}


inline evPriorityScheduleEntry
*evPriorityScheduleEntry::Create(const unsigned int roi,
                                 const unsigned int tile,
                                 const unsigned int component,
                                 const unsigned int bitplane,
                                 const unsigned int scale,
                                 const unsigned int bitplane_length,
                                 const double priority,
                                 const evFilePosition file_position,
                                 const evBoundingBox &bounding_box,
                                 const double grid_spacing,
                                 const unsigned int max_num_scales)
{
  return(new evPriorityScheduleEntry(roi,
                                     tile,
                                     component,
                                     bitplane,
                                     scale,
                                     bitplane_length,
                                     priority,
                                     file_position,
                                     bounding_box,
                                     grid_spacing,
                                     max_num_scales));
}


inline evPriorityScheduleEntry
*evPriorityScheduleEntry::Create(const evPriorityScheduleEntry
                                 &priority_schedule_entry)
{
  return(new evPriorityScheduleEntry(priority_schedule_entry));
}

  
inline evPriorityScheduleEntry::~evPriorityScheduleEntry(void)
{
}
  

inline int evPriorityScheduleEntry::operator== (const evPriorityScheduleEntry
                                                &priority_schedule_entry) const
{
  return((this->ROI == priority_schedule_entry.ROI) &&
         (this->Tile == priority_schedule_entry.Tile) &&
         (this->Component == priority_schedule_entry.Component) &&
         (this->Bitplane == priority_schedule_entry.Bitplane) &&
         (this->Scale == priority_schedule_entry.Scale));
}


inline int evPriorityScheduleEntry::IsEqual(const evPriorityScheduleEntry
                                            &priority_schedule_entry,
                                            const unsigned int match_mask) const
{
  return(((!(match_mask & EVPRIORITYSCHEDULEENTRY_ROI)) ||
          (this->ROI == priority_schedule_entry.ROI)) &&
         ((!(match_mask & EVPRIORITYSCHEDULEENTRY_TILE)) ||
          (this->Tile == priority_schedule_entry.Tile)) &&
         ((!(match_mask & EVPRIORITYSCHEDULEENTRY_COMPONENT)) ||
          (this->Component == priority_schedule_entry.Component)) &&
         ((!(match_mask & EVPRIORITYSCHEDULEENTRY_BITPLANE)) ||
          (this->Bitplane == priority_schedule_entry.Bitplane)) &&
         ((!(match_mask & EVPRIORITYSCHEDULEENTRY_SCALE)) ||
          (this->Scale == priority_schedule_entry.Scale)));
}


inline void evPriorityScheduleEntry::SetROI(const unsigned int roi)
{
  this->ROI = roi;
}


inline unsigned int evPriorityScheduleEntry::GetROI(void) const
{
  return(this->ROI);
}


inline void evPriorityScheduleEntry::SetTile(const unsigned int tile)
{
  this->Tile = tile;
}


inline unsigned int evPriorityScheduleEntry::GetTile(void) const
{
  return(this->Tile);
}


inline void evPriorityScheduleEntry::SetComponent(const unsigned int component)
{
  this->Component = component;
}


inline unsigned int evPriorityScheduleEntry::GetComponent(void) const
{
  return(this->Component);
}


inline void evPriorityScheduleEntry::SetBitplane(const unsigned int bitplane)
{
  this->Bitplane = bitplane;
}


inline unsigned int evPriorityScheduleEntry::GetBitplane(void) const
{
  return(this->Bitplane);
}


inline void evPriorityScheduleEntry::SetScale(const unsigned int scale)
{
  this->Scale = scale;
}


inline unsigned int evPriorityScheduleEntry::GetScale(void) const
{
  return(this->Scale);
}


inline void evPriorityScheduleEntry::SetBitplaneLength(const unsigned int
                                                       bitplane_length)
{
  this->BitplaneLength = bitplane_length;
}


inline unsigned int evPriorityScheduleEntry::GetBitplaneLength(void) const
{
  return(this->BitplaneLength);
}


inline void evPriorityScheduleEntry::SetPriority(const double priority)
{
  this->Priority = priority;
}


inline double evPriorityScheduleEntry::GetPriority(void) const
{
  return(this->Priority);
}


inline void evPriorityScheduleEntry::SetFilePosition(const evFilePosition
                                                     file_position)
{
  this->FilePosition = file_position;
}


inline evFilePosition evPriorityScheduleEntry::GetFilePosition(void) const
{
  return(this->FilePosition);
}


inline void evPriorityScheduleEntry::SetBoundingBox(const evBoundingBox
                                                    &bounding_box)
{
  this->BoundingBox = bounding_box;
}


inline evBoundingBox evPriorityScheduleEntry::GetBoundingBox(void) const
{
  return(this->BoundingBox);
}


inline void evPriorityScheduleEntry::SetMaxNumScale(const unsigned int
                                                    max_num_scales)
{
  this->MaxNumScales = max_num_scales;
}


inline unsigned int evPriorityScheduleEntry::GetMaxNumScales(void) const
{
  return(this->MaxNumScales);
}


inline void evPriorityScheduleEntry::SetNext(evPriorityScheduleEntry *next)
{
  this->Next = next;
}


inline evPriorityScheduleEntry *evPriorityScheduleEntry::GetNext(void) const
{
  return(this->Next);
}


inline void evPriorityScheduleEntry::SetPrevious(evPriorityScheduleEntry
                                                 *previous)
{
  this->Previous = previous;
}


inline evPriorityScheduleEntry *evPriorityScheduleEntry::GetPrevious(void)
  const
{
  return(this->Previous);
}

  
#endif