Data_Component.hh

Go to the documentation of this file.

/*  HiRISE Data Component
 
PIRL CVS ID: Data_Component.hh,v 1.38 2020/02/14 01:17:18 schaller Exp
 
Copyright (C) 2004-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_Data_Component_
#define _HiRISE_Data_Component_
 
#include    "Instrument.hh"
 
//  PIRL
#include    "Data_Block.hh"
 
#if defined (INCLUDE_PVL)
//  idaeim::PVL
#include    "PVL.hh"
#endif
 
#include    <iostream>
#include    <string>
#include    <vector>
 
namespace UA
{
namespace HiRISE
{
/*==============================================================================
    Types
*/
#ifndef INT_8_TYPE
#define INT_8_TYPE                  char
#endif
typedef INT_8_TYPE                  int_8;
 
#ifndef U_INT_8_TYPE
#define U_INT_8_TYPE                unsigned char
#endif
typedef U_INT_8_TYPE                u_int_8;
 
#ifndef INT_16_TYPE
#define INT_16_TYPE                 short int
#endif
typedef INT_16_TYPE                 int_16;
 
#ifndef U_INT_16_TYPE
#define U_INT_16_TYPE               unsigned short int
#endif
typedef U_INT_16_TYPE               u_int_16;
 
#ifndef INT_32_TYPE
#define INT_32_TYPE                 int
#endif
typedef INT_32_TYPE                 int_32;
 
#ifndef U_INT_32_TYPE
#define U_INT_32_TYPE               unsigned int
#endif
typedef U_INT_32_TYPE               u_int_32;
 
#ifndef INT_64_TYPE
#define INT_64_TYPE                 long int
#endif
typedef INT_64_TYPE                 int_64;
 
#ifndef U_INT_64_TYPE
#define U_INT_64_TYPE               unsigned long int
#endif
typedef U_INT_64_TYPE               u_int_64;
 
typedef PIRL::Data_Block::Index     Index;
 
typedef u_int_16                    Pixel_type;
 
/*******************************************************************************
    Data_Component
*/
class Data_Component
:   public Instrument,
    public PIRL::Data_Block
{
public:
/*==============================================================================
    Constants:
*/
static const char* const
    ID;
 
static const int
    DECIMAL,
    HEX,
    BOOLEAN;
 
static const char
    PATHNAME_DELIMITER;
 
static const int
    UTC_SECONDS_PRECISION;
 
static const char
    SUBSECONDS_DELIMITER;
 
#if defined (INCLUDE_CSPICE)
static const char* const
    SPICE_METAKERNEL_VARIABLE;
 
static const char* const
    DEFAULT_SPICE_METAKERNEL;
 
static const int
    MRO_CLOCK_ID;
 
#endif  //  INCLUDE_SPICE
 
static const char* const
    INVALID_UTC_TIME;
 
/*==============================================================================
    Constructors
*/
Data_Component
    (
    const char**    names = NULL,
    unsigned int    size = 0,
    const Index*    offsets = NULL,
    const Index     indexed_arrays[][2] = NULL,
    Data_Order      order = Data_Block::MSB
    );
 
Data_Component (const Data_Component& component, bool data_duplicate = true);
 
Data_Component& operator= (const Data_Component& component);
 
virtual ~Data_Component ();
 
/*==============================================================================
    Accessors
*/
virtual std::string id () const;
 
virtual const char* name () const = 0;
 
const char* name (Index element) const;
 
virtual u_int_32 get (Index element, Index index = 0) const;
 
virtual Data_Component& put
    (const u_int_32 value, Index element, Index index = 0);
 
#if defined (INCLUDE_PVL)
/*==============================================================================
    PVL
*/
virtual idaeim::PVL::Aggregate* PVL () const = 0;
 
#endif  // defined (INCLUDE_PVL)
 
/*==============================================================================
    Printing
*/
virtual std::ostream& print
    (std::ostream& stream = std::cout, bool verbose = false) const = 0;
 
std::ostream& print_element (const Index element, int format = DECIMAL,
    std::ostream& stream = std::cout, int width = 0) const;
 
std::ostream& print_element (const Index element, std::ostream& stream) const
    {return print_element (element, DECIMAL, stream, 0);}
 
std::ostream& print_element_location (const Index element,
    std::ostream& stream = std::cout) const;
 
unsigned int element_location_print_width (Index element) const;
 
unsigned int name_field_width () const;
 
Data_Component& name_field_width (unsigned int width);
 
/*==============================================================================
    Validation
*/
virtual bool is_valid () const = 0;
 
/*------------------------------------------------------------------------------
    Data
*/
Data_Block& data (void* const block);
 
Data_Block& attach (void* const block, unsigned int size);
 
Data_Component& resize (unsigned int size);
 
unsigned char* data () const
    {return PIRL::Data_Block::data ();}
 
unsigned int local_data ()
    {return Local_Data;}
 
u_int_16 internet_checksum () const;
 
//..............................................................................
private:
 
unsigned int
    Local_Data;
 
const char**
    Names;
 
unsigned int
    Max_Name_Length;
 
unsigned int
    Name_Field_Width;
 
};  //  class Data_Component
 
 
/*==============================================================================
    Output operator
*/
std::ostream& operator<<
    (std::ostream& stream, const Data_Component& component);
 
/*******************************************************************************
    Helpers
*/
std::ostream& print_value (u_int_32 value, int format = Data_Component::DECIMAL,
    std::ostream& stream = std::cout, int width = 0);
 
#if defined (INCLUDE_PVL)
/*------------------------------------------------------------------------------
    PVL
*/
enum Parameter_Class_Selection
    {
    AGGREGATE_PARAMETER  = -1,
    ANY_PARAMETER        =  0,
    ASSIGNMENT_PARAMETER =  1
    };
 
idaeim::PVL::Parameter*
PVL_parameter
    (
    idaeim::PVL::Aggregate&     aggregate,
    std::string                 pathname,
    bool                        case_sensitive = false,
    int                         skip = 0,
    Parameter_Class_Selection   parameter_class = ANY_PARAMETER
    );
 
std::vector<std::string>
PVL_values
    (
    idaeim::PVL::Aggregate& aggregate,
    std::string             pathname,
    bool                    case_sensitive = false,
    int                     skip = 0
    );
 
bool
PVL_value
    (
    idaeim::PVL::Aggregate& aggregate,
    std::string             pathname,
    unsigned int            value,
    bool                    case_sensitive = false,
    int                     skip = 0
    );
 
bool
PVL_value
    (
    idaeim::PVL::Aggregate& aggregate,
    std::string             pathname,
    int                     value,
    bool                    case_sensitive = false,
    int                     skip = 0
    );
 
bool
PVL_value
    (
    idaeim::PVL::Aggregate& aggregate,
    std::string             pathname,
    const std::string&      value,
    bool                    case_sensitive = false,
    int                     skip = 0
    );
 
#endif  // defined (INCLUDE_PVL)
 
/*------------------------------------------------------------------------------
    Time
*/
std::string UTC_time
    (double seconds, unsigned int epoch = Instrument::SPACECRAFT_EPOCH);
 
 
enum Clock_Selector
    {
    HiRISE_Clock,
    MRO_Clock
    };
 
std::string clock_count (double seconds, Clock_Selector clock = HiRISE_Clock);
 
double seconds
    (const std::string& clock_count, Clock_Selector clock = HiRISE_Clock);
 
/*------------------------------------------------------------------------------
    Files
*/
bool file_exists (const std::string& filename);
 
std::string pathname (const std::string& filename = "");
 
std::string pathname
    (
    const std::string&  directory,
    const std::string&  filename,
    const std::string&  extension
    );
 
std::string filename (const std::string& pathname);
 
/*------------------------------------------------------------------------------
    Stringy thingies
*/
std::string bits (const unsigned int value, unsigned int count = 0);
 
unsigned int max_strlen (const char** strings);
 
std::string to_upper (const std::string& characters);
 
std::string shift (std::string lines, int amount);
 
std::string plural (int count);
 
/*------------------------------------------------------------------------------
    Miscellaneous
*/
std::string hostname ();
 
bool member_of
    (const unsigned int value, const unsigned int *array, int size);
 
bool member_of
    (const char* const value, const char* const array[], int size);
 
 
}   //  namespace HiRISE
}   //  namespace UA
#endif