Gap_Map.hh

Go to the documentation of this file.

/*  HiRISE Gap Map
 
PIRL CVS ID: Gap_Map.hh,v 1.10 2020/02/25 00:16:17 schaller Exp
 
Copyright (C) 2005-2020 Arizona Board of Regents on behalf of the Lunar and
Planetary Laboratory at the University of Arizona.
 
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at
 
   http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software distributed
under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
CONDITIONS OF ANY KIND, either express or implied. See the License for the
specific language governing permissions and limitations under the License.
*/
#ifndef _HIRISE_GAP_MAP_
#define _HIRISE_GAP_MAP_
 
#include    "Data_Component.hh"
 
#if defined (INCLUDE_PVL)
//  idaeim::PVL
#include    "PVL.hh"
#endif
 
#include    <iosfwd>
#include    <string>
#include    <vector>
#include    <utility>
 
namespace UA
{
namespace HiRISE
{
/*******************************************************************************
    Gap_Map
*/
class Gap_Map
:   public Data_Component
{
public:
/*==============================================================================
    Types:
*/
typedef u_int_32                        Location;
 
typedef std::pair<Location, Location>   Range;
 
typedef std::vector<Range>              List;
 
/*==============================================================================
    Constants:
*/
static const char* const
    ID;
 
static const char* const
    NAME;
 
enum End_Point
    {
    RANGE_START,
    RANGE_END
    };
 
static const char* const
    END_POINT_NAMES[];
 
enum
    {
    INSIDE = -1,
    OUTSIDE = 0,
    OVERLAP = 1
    };
 
static const unsigned int
    DEFAULT_SEQUENCE_THRESHOLD;
 
static const u_int_8
    GAP_BYTE_VALUE;
 
/*==============================================================================
    Constructors
*/
Gap_Map ();
 
Gap_Map (std::istream& stream, unsigned int count);
 
Gap_Map (const Gap_Map& map, bool data_duplicate = true);
 
Gap_Map& operator= (const Gap_Map& map);
 
/*==============================================================================
    Accessors
*/
virtual std::string id () const;
 
virtual const char* name () const;
 
virtual Location get (Index range, End_Point end_point) const;
 
Gap_Map::Range gap (Index range) const;
 
Gap_Map::List gaps () const;
 
unsigned int total_gaps () const
{return count_of (0) >> 1;}
 
bool in_gap (const Location location) const;
 
int in_gap (const Location start, const Location end) const;
 
int in_gap (const Gap_Map::Range& range) const
    {return in_gap (range.first, range.second);}
 
/*==============================================================================
    Manipulators
*/
Gap_Map& set (const Location start, const Location end);
 
Gap_Map& set (const Gap_Map::Range& range)
    {return set (range.first, range.second);}
 
Gap_Map& set (const Gap_Map::List list);
 
Gap_Map& clear (const Location start, const Location end);
 
Gap_Map& clear ()
    {return clear (0, (Location)-1);}
 
Gap_Map& clear (const Gap_Map::Range& range)
    {return clear (range.first, range.second);}
 
Gap_Map& clear (const Gap_Map::List list);
 
Gap_Map& shift (int_32 amount);
 
/*------------------------------------------------------------------------------
    Direct range manipulation.
*/
protected:
 
virtual Data_Component& put
    (const Location location, Index range, End_Point end_point);
 
Gap_Map& insert_range (Index range, Location start, Location end);
 
Gap_Map& remove_range (Index first, Index last = (Index)-1);
 
/*==============================================================================
    Printing
*/
public:
virtual std::ostream& print
    (std::ostream& stream = std::cout, bool verbose = false) const;
 
#if defined (INCLUDE_PVL)
/*==============================================================================
    PVL
*/
virtual idaeim::PVL::Aggregate* PVL () const;
 
idaeim::PVL::Aggregate* PVL_description () const;
 
#endif  // defined (INCLUDE_PVL)
 
/*==============================================================================
    Validation
*/
virtual bool is_valid () const;
 
/*==============================================================================
    Utility
*/
static Gap_Map::List gaps_in
    (void* start, void* end, unsigned int threshold = 0);
 
static unsigned int sequence_threshold (unsigned int threshold = 0);
 
static Gap_Map::Range& shift (Gap_Map::Range& range, int_32 amount);
 
static Gap_Map::List& shift (Gap_Map::List& list, int_32 amount);
 
/*------------------------------------------------------------------------------
    Data
*/
private:
 
static unsigned int
    Sequence_Threshold;
 
u_int_32
    Map_Storage_Amount;
 
};  //  class Gap_Map
 
/*==============================================================================
    Helper functions
*/
std::ostream& operator<<
    (std::ostream& stream, const Gap_Map& map);
 
 
}   //  namespace HiRISE
}   //  namespace UA
#endif