member_record.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 member_record

#ifndef MEMBER_RECORD_H
#define MEMBER_RECORD_H

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

#ifndef BLOCK_H
#include "SheafSystem/block.h"
#endif

#ifndef STD_BITSET_H
#include "SheafSystem/std_bitset.h"
#endif

#ifndef STD_LIMITS_H
#include "SheafSystem/std_limits.h"
#endif

#ifndef VARIABLE_LENGTH_RECORD_H
#include "SheafSystem/variable_length_record.h"
#endif

namespace sheaf
{

class member_record_set;
class poset_dof_iterator;
  
class SHEAF_DLL_SPEC member_record : public variable_length_record
{
  // ===========================================================
  // MEMBER_RECORD FACET
  // ===========================================================

public:

  member_record(member_record_set& xhost);

  member_record(const member_record& xother);

  virtual ~member_record();

  implicit_crg_interval* interval() const;

  bool is_resident() const;

protected:

  // Default constructor.
  // Default construction prohibited because scaffold must be initialized
  // inline member_record() {} ;

private:

  typedef std::bitset<std::numeric_limits<pod_index_type>::digits> toc_type;

  enum toc_bit_field_type
  {

    FIRST_BIT, // Not used.
    IS_JIM,
    HAS_NAMES,
    IS_INTERVAL,
    HAS_PRIVATE_DATA,
    HAS_DOF_TUPLE_IDS,
    HAS_LOWER_COVER,
    HAS_UPPER_COVER,
    HAS_TOC_SUBPOSET_IDS,
    HAS_SUBPOSET_IDS,
    HAS_EQV_IDS,

    // Use the remaining bits to store subposet membership.

    SUBPOSET_BITS_BEGIN,
    SUBPOSET_BITS_END = std::numeric_limits<pod_index_type>::digits - 1,
    LAST_BIT = SUBPOSET_BITS_END // Not used.
  };

  // Internal buffer

  toc_type _toc;
  block<pod_index_type> _private_data;
  block<pod_index_type> _dof_tuple_ids;
  block<pod_index_type> _lower_cover;
  block<pod_index_type> _upper_cover;
  block<pod_index_type> _subposet_ids;
  block<pod_index_type> _eqv_ids;
  block<std::string> _names;


  // External buffer layout:
  //  table of contents
  //  private data count
  //  private data
  //  dof tuple id count
  //  dof tuple ids
  //  lower cover count
  //  lower cover
  //  upper cover count
  //  upper cover
  //  subposet_ids count
  //  subposet_ids
  //  eqv_ids

  // Offsets into external buffer

  size_t _end_offset;

  scoped_index _mbr_id;
  
  record_index _ext_id;

  poset_state_handle* _poset;

  implicit_crg_interval* _interval;

  bool _is_resident;  

  member_record_set& _host;

  member_record_set& host();

  const member_record_set& host() const;

  // ===========================================================
  // EQUIVALENCE ITERATOR FACET
  // ===========================================================

public:

  void new_equivalence_iterator();

  void delete_equivalence_iterator();

  bool has_equivalence_iterator() const;

protected:

private:

  index_equivalence_iterator* _eqv_itr;

  index_equivalence_iterator& equivalence_iterator(const scoped_index& xrep_id);

  // ===========================================================
  // EXTERNAL SIZE FACET
  // ===========================================================

public:
 
  size_type external_size(const scoped_index& xmbr_id);

protected:
private:

  size_type private_data_external_size();

  //   ///
  //   /// External size of id map field.
  //   ///
  //   size_type id_map_data_external_size();

  size_type dof_tuple_ids_external_size();

  size_type lower_cover_external_size();

  size_type upper_cover_external_size();

  size_type subposet_ids_external_size();

  size_type eqv_ids_external_size();

  size_type toc_external_size();

  // ===========================================================
  // WRITE FACET
  // ===========================================================

public:

  void externalize(const scoped_index& xmbr_id, hvl_t* xhdf_buffer);

private:

  void transfer_member_to_internal_buffer(const scoped_index& xmbr_id);

  void clear_internal_buffer();

  void transfer_member_to_toc(const scoped_index& xmbr_id);

  void transfer_interval_to_private_data(const scoped_index& xmbr_id);

  void transfer_member_to_dof_tuple_ids(const scoped_index& xmbr_id);

  void transfer_interval_to_dof_tuple_ids(const scoped_index& xmbr_id);

  void transfer_member_to_lower_cover(const scoped_index& xmbr_id);

  void transfer_member_to_upper_cover(const scoped_index& xmbr_id);

  void transfer_member_to_subposet_ids(const scoped_index& xmbr_id);

  void transfer_member_to_eqv_ids(const scoped_index& xmbr_id);

  void transfer_member_to_names(const scoped_index& xmbr_id);

  void transfer_interval_to_class_names(const scoped_index& xmbr_id);

  void convert_internal_buffer_to_external_buffer();

  virtual void initialize_external_buffer();

  void externalize_toc(size_t& xnext_field_offset);

  void externalize_private_data_ct(size_t& xnext_field_offset);

  void externalize_private_data(size_t& xnext_field_offset);

  void externalize_dof_tuple_ids_ct(size_t& xnext_field_offset);

  void externalize_dof_tuple_ids(size_t& xnext_field_offset);

  void externalize_lower_cover_ct(size_t& xnext_field_offset);

  void externalize_lower_cover(size_t& xnext_field_offset);

  void externalize_upper_cover_ct(size_t& xnext_field_offset);

  void externalize_upper_cover(size_t& xnext_field_offset);

  void externalize_subposet_ids_ct(size_t& xnext_field_offset);

  void externalize_subposet_ids(size_t& xnext_field_offset);

  void externalize_eqv_ids(size_t& xnext_field_offset);

  void transfer_external_buffer_to_HDF(hvl_t* xbuf);

  // ===========================================================
  // READ FACET
  // ===========================================================

public:

  void internalize(hvl_t* xhdf_buffer, const scoped_index& xmbr_id);

private:

  void transfer_HDF_to_external_buffer(hvl_t* xbuf);

  void convert_external_buffer_to_internal_buffer();

  void internalize_toc(size_t& xnext_field_offset);

  void internalize_private_data_ct(size_t& xnext_field_offset);

  void internalize_private_data(size_t& xnext_field_offset);

  void internalize_dof_tuple_ids_ct(size_t& xnext_field_offset);

  void internalize_dof_tuple_ids(size_t& xnext_field_offset);

  void internalize_lower_cover_ct(size_t& xnext_field_offset);

  void internalize_lower_cover(size_t& xnext_field_offset);

  void internalize_upper_cover_ct(size_t& xnext_field_offset);

  void internalize_upper_cover(size_t& xnext_field_offset);

  void internalize_subposet_ids_ct(size_t& xnext_field_offset);

  void internalize_subposet_ids(size_t& xnext_field_offset);

  void internalize_eqv_ids(size_t& xnext_field_offset);

  void transfer_internal_buffer_to_member(const scoped_index& xmbr_id);

  void transfer_toc_to_member(const scoped_index& xmbr_id);

  void transfer_private_data_to_interval(const scoped_index& xmbr_id);

  void transfer_dof_tuple_ids_to_interval(const scoped_index& xmbr_id);

  void transfer_dof_tuple_ids_to_member(const scoped_index& xmbr_id);

  const scoped_index& new_row_dof_tuple(pod_index_type xext_dof_tuple_pod);

  void transfer_lower_cover_to_member(const scoped_index& xmbr_id);

  void transfer_upper_cover_to_member(const scoped_index& xmbr_id);

  void new_member(pod_index_type xmbr_id);

  void transfer_subposet_ids_to_member(const scoped_index& xmbr_id);

  void transfer_eqv_ids_to_member(const scoped_index& xmbr_id);

  void transfer_names_to_member(const scoped_index& xmbr_id);

  // ===========================================================
  // VARIABLE_LENGTH_RECORD FACET
  // ===========================================================

  inline pod_index_type* int_buf()
  {
    return reinterpret_cast<pod_index_type*>(buf());
  };

  // ===========================================================
  // RECORD FACET
  // ===========================================================

  // ===========================================================
  // ANY FACET
  // ===========================================================

public:

  virtual member_record* clone() const;

  virtual bool invariant() const;

  virtual bool is_ancestor_of(const any* other) const;

};
 
} // namespace sheaf

#endif // ifndef MEMBER_RECORD_H