Member functions::GeoConstraint::reorder_data_longitude_axis (libdap::Array &a, libdap::Array::Dim_iter lon_dim)

Fix this code so that it works with latitude as the rightmost map

Member libdap::AISResources::get_resource (const string &primary)

Make this return an empty ResourceVector is no matching resources are found. Clients would not need to call has_resource() which would save some time.

Member libdap::Array::Array (const string &n, const string &d, BaseType *v, bool is_dap4=false)

Force the Array::add_var() method to be used to add v. This version of add_var() calls Vector::add_var().

Member libdap::Array::Array (const string &n, BaseType *v, bool is_dap4=false)

Force the Array::add_var() method to be used to add v. This version of add_var() calls Vector::add_var().

Member libdap::BaseType::add_var (BaseType *bt, Part part=nil)

We should get rid of the Part parameter and adopt the convention that the first variable is the Array and all subsequent ones are Maps (when dealing with a Grid, the only time Part matters). This would enable several methods to migrate from Structure, Sequence and Grid to Constructor.

Member libdap::BaseType::length () const

change the return type to int64_t

Member libdap::BaseType::read ()

Modify the D4 serialize code so that it supports the true/false behavior of read() for arrays.

Modify all of the stock handlers so they conform to this!

Member libdap::BaseType::set_length (int)

change param type to int64_t

Member libdap::BaseType::set_read_p (bool state)

Look at making synthesized variables easier to implement and at making them more integrated into the overall CE evaluation process. Maybe the code that computes the synthesized var's value should be in the that variable's read() method? This might provide a way to get rid of the awkward 'projection functions' by replacing them with real children of BaseType. It would also provide a way to clean up the way the synthesized_p prop intrudes on the read_p prop.

Member libdap::Constructor::is_linear ()

Change the name to is_flattenable or something like that. 05/16/03 jhrg

Member libdap::Constructor::serialize (D4StreamMarshaller &m, DMR &dmr, bool filter=false)

See notebook for 8/21/14

Class libdap::D4Enum

Note the hack to remove the union...

Member libdap::D4Group::transform_to_dap2 (AttrTable *parent_attr_table)

Fix the comment.

Member libdap::D4RValue::value (DMR &dmr)

Could move the operation that wraps a constant in a BaseType to this method while providing other ways to access the value(s) (methods to determine if the rvalue is a constant and what DAP type it is, e.g.). This would provide an optimization for the filter evaluator which may access the values many times. We might also modify the server side functions so they could access constant values more efficiently.

Member libdap::DAPCache3::purge_file (const string &file)

This is a new feature; add to BESCache3

Member libdap::DDS::mark (const string &name, bool state)

These methods that use the btp_stack to keep track of the path from the top of a dataset to a particular variable can be rewritten to use the parent field instead.

All the methods that use names to identify variables should have counterparts that take BaseType pointers.

Class libdap::DODSFilter

Add a test to make sure that the required arguments are given.

We need to rethink the ancillary file/directory stuff. I don't think it's ever been used...

Member libdap::DODSFilter::DODSFilter ()

Add methods to provide a way to set all of the parameters this class contains. They can currently only be set using the argc/argv command line parameters.

Member libdap::DODSFilter::establish_timeout (FILE *stream) const

When the alarm handler is called, two CRLF pairs are dumped to the stream and then an Error object is sent. No attempt is made to write the 'correct' MIME headers for an Error object. Instead, a savvy client will know that when an exception is thrown during a deserialize operation, it should scan ahead in the input stream for an Error object. Add this, or a sensible variant once libdap++ supports reliable error delivery. Dumb clients will never get the Error object...

Class libdap::fdostream

Generalize this so that it can take a FILE * as well and then make two classes file_istream and file_ostream that can be initialized with either a file descriptor or a FILE pointer.

Class libdap::Grid

Move, in some sense, the d_map_vars up to Constructor. Look at using Constructor's _var field for these.

Along the same lines as the previous item, consider removing the Part enum and adopting the convention that the first variable added is the array and any subsequent variables are maps.

Class libdap::HTTPCache

Update documentation: get_cache_response() now also serves as is_url_in_cache() and is_url_valid() should only be called after a locked cached response is accessed using get_cahced_response(). These lock the cache for reading. The methods cache_response() and update_response() lock an entry for writing.

Check that the lock-for-write and lock-for-read work together since it's possible that an entry in use might have a stream of readers and never free the 'read-lock' thus blocking a writer.

Class libdap::HTTPResponse

Maybe refactor so that the header parsing code is here and not in HTTPConnect?

Member libdap::HTTPResponse::HTTPResponse (std::fstream *s, int status, std::vector< std::string > *h, const std::string &temp_file)

Decide on how the temp files fit into DAP4

Class libdap::Response

If the code that parses the MIME headers was moved from Connect and HTTPConnect to this class and its children, it would be easier to build a FileConnect class (or maybe the specifics of the connection type could be held in the Response object and HTTPConnect and the to-be-written FileConnect would not be needed).

Class libdap::Sequence

Add an isEmpty() method which returns true if the Sequence is empty. This should work before and after calling deserialize().

Member libdap::Sequence::read_row (int row, DDS &dds, ConstraintEvaluator &eval, bool ce_eval=true)

This code ignores the main reason for nesting the sequences, that if the outer Sequence's current instance fails the CE, there's no need to look at the values of the inner Sequence. But in the code that calls this method (serialize() and intern_data()) the CE is not evaluated until the inner-most Sequence (i.e., the leaf Sequence) is read. That means that each instance of the inner Sequence is read and the CE evaluated for each of those reads. To fix this, and the overall problem of complexity here, we need to re-think Sequences and how they behave. 11/13/2007 jhrg