dof_tuple_record_set.h

//
// Copyright (c) 2014 Limit Point Systems, Inc.
//
// 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.
//

// Interface for class dof_tuple_record_set

#ifndef DOF_TUPLE_RECORD_SET_H
#define DOF_TUPLE_RECORD_SET_H

#ifndef SHEAF_DLL_SPEC_H
#include "SheafSystem/sheaf_dll_spec.h"
#endif

#ifndef RECORD_SET_H
#include "SheafSystem/record_set.h"
#endif

#ifdef ZN_TO_BOOL_H
#include "SheafSystem/zn_to_bool.h"
#endif

namespace sheaf
 {
  
class SHEAF_DLL_SPEC dof_tuple_record_set : public record_set
{

public:

  // CANONICAL MEMBERS

  dof_tuple_record_set(const dof_tuple_record_set& xother);

  virtual dof_tuple_record_set* clone() const;

  virtual ~dof_tuple_record_set();

  virtual bool invariant() const;

  virtual bool is_ancestor_of(const any* other) const;

  // DOF_TUPLE_RECORD_SET INTERFACE

  dof_tuple_record_set(const sheaf_file& xfile,
                       size_t xrecord_size,
                       int xrecord_buffer_ub,
                       const poset_scaffold& xscaffold);

  virtual const std::string& suffix() const;

  virtual void open();

  void internalize();

  void externalize();

  void externalize_domain(const scoped_index& xtuple_ext_id,
                          const scoped_index& xschema_id);

  size_type record_size() const;

  record_queue& queue();

  const record_queue& queue() const;

  pod_index_type compute_ext_id(const scoped_index& xtuple_id);  

  size_type compute_ext_domain_size(const poset_dof_map& xdof_map,
                                 const schema_poset_member& xschema) const;

protected:

  virtual hid_t create_dataset();

  virtual void create_int_data_type();

  void read_records();

  void read_selection();

  void write_selection();

  void schematize();

  size_type _record_size;


  hsize_t (*_hdf_int_selection)[1];

  hsize_t (*_hdf_ext_selection)[1];

  int _hdf_selection_ub;

  int _hdf_selection_ct;

  char* _hdf_buf;

  size_t _hdf_buf_ub;


  pod_index_type _next_record_pod;

  zn_to_bool _record_is_full;

  record_map<pod_index_type, pod_index_type> _hdf_buf_record_map;

  char* _hdf_scratch_buf;

  size_t _hdf_scratch_buf_ub;

  record_queue _record_queue;

  bool _writing;

  void externalize_all_dofs(schema_poset_member& xxfr_schema,
                            const poset_dof_map& xint_dof_map,
                            char*& xbuf,
                            size_t& xbuf_remainder);

  void internalize_all_dofs(schema_poset_member& xxfr_schema,
                            poset_dof_map& xext_dof_map,
                            char* xbuf,
                            size_t xbuf_remainder);

  void populate_internal_dof_map(const poset_dof_map& xext_dof_map,
                                 poset_dof_map& xint_dof_map);

  char* get_next_record(char* xbuf);


  char* get_first_record(pod_index_type xext_pod);

  pod_index_type get_internal_record(pod_index_type xext_rec_pod);

  pod_index_type advance_to_start_of_record(pod_index_type xext_pod);

  void externalize_one_domain(const scoped_index& xtuple_id,
                              const scoped_index& xschema_id);

  void attach_transfer_schema(schema_poset_member& xdof_map_schema,
                              const scoped_index& xdomain_schema_id);
};

 } // namespace sheaf

#endif // ifndef DOF_TUPLE_RECORD_SET_H