D4Sequence.h

// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2013 OPeNDAP, Inc.
// Author: James Gallagher <jgallagher@opendap.org>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
#ifndef _d4sequence_h
#define _d4sequence_h 1
 
#include "Constructor.h"
 
// DAP2 Sequence supported subsetting using the array notation. This might
// be introduced into DAP4 later on.
#define INDEX_SUBSETTING 0
 
class Crc32;
 
namespace libdap
{
class BaseType;
class D4FilterClauseList;
 
typedef vector<BaseType *> D4SeqRow;
 
typedef vector<D4SeqRow *> D4SeqValues;
 
typedef vector<BaseType *> BaseTypeRow;
 
typedef vector<BaseTypeRow *> SequenceValues;
 
 
class D4Sequence: public Constructor
{
private:
    // This may be zero (nullptr) but the accessor (clauses()) allocates an
    // instance if that is the case.
    D4FilterClauseList *d_clauses;
 
    // Use this to control if ptr_duplicate(), ..., copy the filter clauses.
    // Because the values of a child sequence are held in copies of the Seq
    // object they clauses will bound to the 'master' instance will be copied
    // but the copies will never be used. This field can be used to control
    // that. ...purely an optimization.
    bool d_copy_clauses;
 
protected:
    // This holds the values of the sequence. Values are stored in
    // instances of BaseTypeRow objects which hold instances of BaseType.
    //
    // Allow these values to be accessed by subclasses
    D4SeqValues d_values;
 
    int64_t d_length;   // How many elements are in the sequence; -1 if not currently known
 
#if INDEX_SUBSETTING
    int d_starting_row_number;
    int d_row_stride;
    int d_ending_row_number;
#endif
 
    void m_duplicate(const D4Sequence &s);
 
    // Specialize this if you have a data source that requires read()
    // recursively call itself for child sequences.
    void read_sequence_values(bool filter);
 
    friend class D4SequenceTest;
 
public:
 
    D4Sequence(const string &n);
    D4Sequence(const string &n, const string &d);
 
    D4Sequence(const D4Sequence &rhs);
 
    virtual ~D4Sequence();
 
    D4Sequence &operator=(const D4Sequence &rhs);
 
    virtual BaseType *ptr_duplicate();
 
    virtual void clear_local_data();
 
    virtual int length() const { return (int)d_length; }
 
    virtual void set_length(int count) { d_length = (int64_t)count; }
 
    virtual bool read_next_instance(bool filter);
 
    virtual void intern_data(ConstraintEvaluator &, DDS &) {
        throw InternalErr(__FILE__, __LINE__, "Not implemented for DAP4");
    }
    virtual bool serialize(ConstraintEvaluator &, DDS &, Marshaller &, bool ) {
        throw InternalErr(__FILE__, __LINE__, "Not implemented for DAP4");
    }
    virtual bool deserialize(UnMarshaller &, DDS *, bool ) {
        throw InternalErr(__FILE__, __LINE__, "Not implemented for DAP4");
    }
 
    // DAP4
    virtual void intern_data(/*Crc32 &checksum, DMR &dmr, ConstraintEvaluator &eval*/);
    virtual void serialize(D4StreamMarshaller &m, DMR &dmr, /*ConstraintEvaluator &eval,*/ bool filter = false);
    virtual void deserialize(D4StreamUnMarshaller &um, DMR &dmr);
 
    D4FilterClauseList &clauses();
 
#if INDEX_SUBSETTING
    virtual int get_starting_row_number() const { return d_starting_row_number; }
 
    virtual int get_row_stride() const { return d_row_stride; }
 
    virtual int get_ending_row_number() const { return d_ending_row_number; }
 
    virtual void set_row_number_constraint(int start, int stop, int stride = 1);
#endif
 
    virtual void set_value(D4SeqValues &values) { d_values = values; d_length = d_values.size(); }
 
    virtual D4SeqValues value() const { return d_values; }
 
    virtual D4SeqValues &value_ref() { return d_values; }
 
    virtual D4SeqRow *row_value(size_t row);
    virtual BaseType *var_value(size_t row, const string &name);
    virtual BaseType *var_value(size_t row, size_t i);
 
    virtual void print_one_row(ostream &out, int row, string space,
                               bool print_row_num = false);
    virtual void print_val_by_rows(ostream &out, string space = "",
                                   bool print_decl_p = true,
                                   bool print_row_numbers = true);
    virtual void print_val(ostream &out, string space = "",
                           bool print_decl_p = true);
 
    virtual void dump(ostream &strm) const ;
};
 
} // namespace libdap
 
#endif //_sequence_h