poset_scaffold.h

Go to the documentation of this file.

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


#ifndef POSET_SCAFFOLD_H
#define POSET_SCAFFOLD_H

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

#ifndef ANY_H
#include "SheafSystem/any.h"
#endif

#ifndef ARG_LIST_H
#include "SheafSystem/arg_list.h"
#endif

#ifndef AUTO_BLOCK_H
#include "SheafSystem/auto_block.h"
#endif

#ifndef INTERVAL_INDEX_SPACE_HANDLE_H
#include "SheafSystem/interval_index_space_handle.h"
#endif

#ifndef NAME_MULTIMAP_H
#include "SheafSystem/name_multimap.h"
#endif

#ifndef RECORD_MAP_H
#include "SheafSystem/record_map.h"
#endif

#ifndef POSET_STATE_HANDLE_H
#include "SheafSystem/poset_state_handle.h"
#endif

#ifndef POSET_DATA_TYPE_MAP_H
#include "SheafSystem/poset_data_type_map.h"
#endif

#ifndef RECORD_QUEUE_H
#include "SheafSystem/record_queue.h"
#endif

#ifndef SCHEMA_POSET_MEMBER_H
#include "SheafSystem/schema_poset_member.h"
#endif

#ifndef STD_UNORDERED_MAP_H
#include "SheafSystem/std_unordered_map.h"
#endif

#ifndef STD_VECTOR_H
#include "SheafSystem/std_vector.h"
#endif

#ifndef STORAGE_AGENT_H
#include "SheafSystem/storage_agent.h"
#endif

namespace sheaf
{

class poset_bounds;
class subposet;  
class namespace_poset;

class SHEAF_DLL_SPEC poset_scaffold : public any
{

  // ===========================================================
  // ===========================================================

public:

  poset_scaffold(const poset_scaffold& xother);

  virtual ~poset_scaffold();

  poset_scaffold(const poset_state_handle& xposet,
         const storage_agent::transaction& xtrans,
         data_type_map& xtype_map,
         const std::string& xfile_id_space_name,
         bool xis_write_transaction);

  poset_state_handle& structure();

  const poset_state_handle& structure() const;

  poset_powerset_state& powerset();

  const poset_powerset_state& powerset() const;

  poset_table_state& table();  

  const poset_table_state& table() const;  

  bool is_write_transaction() const;

  poset_bounds& row_bounds();

  const poset_bounds& row_bounds() const;

  poset_bounds& col_bounds();

  const poset_bounds& col_bounds() const;

  const poset_bounds& toc_bounds() const;

  void update_toc_bounds(const poset_bounds_descriptor& xdesc);

  void evaluate_toc_alias();

  subposet& resident();

  const subposet& resident() const;

  namespace_poset* name_space() const;

  bool structure_is_namespace() const;

  scoped_index index() const;

  std::string name() const;

  schema_poset_member& internal_schema();

  const schema_poset_member& internal_schema() const;

  schema_poset_member& transfer_schema();

  const schema_poset_member& transfer_schema() const;

  schema_poset_member& external_schema();

  const schema_poset_member& external_schema() const;

  poset_data_type_map& type_map();

  const poset_data_type_map& type_map() const;

  const std::string& file_id_space_name() const;

  bool& is_versioned();

  const bool& is_versioned() const;

  void initialize_schema_for_read(schema_poset_member* xext_schema,
                                  int xschema_version);

  void initialize_transfer_schema_for_read(const scoped_index& xindex);

  void insert_id_name_pair(pod_index_type xid, const std::string& xname, block<char>& xbuf);

  void extract_id_name_pair(pod_index_type& xid, std::string& xname, char*& xbuf);

  void get_member_names_from_poset();
  
  void put_member_names_to_poset();
  
protected:

private:


  poset_state_handle& _structure;

  bool _is_write_transaction;

  poset_bounds* _row_bounds;

  poset_bounds* _col_bounds;

  poset_bounds* _toc_bounds;

  subposet _resident;

  schema_poset_member* _internal_schema;

  schema_poset_member* _transfer_schema;

  schema_poset_member* _external_schema;

  void initialize_schema_for_write();

  poset_data_type_map _type_map;

  std::string _file_id_space_name;

  bool _is_versioned;



  // ===========================================================
  // ===========================================================

public:

  typedef interval_index_space_handle member_index_space_type;

  typedef name_multimap member_name_map_type;

  // The following features are logically members
  // of class member_record, but are placed here so they
  // will only be initialized once per poset, rather than
  // once per member record.

  void put_member_record_type_aliases(int xtoc_index,
                                      int xdof_tuple_id_index,
                                      int xoffset_index);

  void initialize_member_id_space();

  bool member_id_space_initialized() const;

  scoped_index member_ext_id(const scoped_index& xid) const;

  scoped_index member_ext_id(pod_index_type xid) const;

  member_index_space_type& member_id_space();

  const member_index_space_type& member_id_space() const;

  member_name_map_type& member_name_map();

  const member_name_map_type& member_name_map() const;

  typedef unordered::unordered_map<pod_index_type, std::pair<std::string, size_type> > member_class_names_type;

  member_class_names_type& member_class_names();

  const member_class_names_type& member_class_names() const;

  void convert_member_id_to_record_id(void *buf);

  void convert_record_id_to_member_id(void *buf);

protected:

private:

  member_index_space_type _member_id_space;

  member_name_map_type _member_name_map;

  member_class_names_type _member_class_names;



  // ===========================================================
  // ===========================================================

public:

  typedef interval_index_space_handle subposet_index_space_type;

  void initialize_subposet_id_space();

  bool subposet_id_space_initialized() const;

  scoped_index subposet_ext_id(const scoped_index& xid) const;

  scoped_index subposet_ext_id(pod_index_type xid) const;

  subposet_index_space_type& subposet_id_space();

  const subposet_index_space_type& subposet_id_space() const;

  std::vector<subposet*>& subposets();

  const std::vector<subposet*>& subposets() const;

  void convert_subposet_id_to_record_id(void* xbuf);

  void convert_record_id_to_subposet_id(void* xbuf);

protected:

private:

  subposet_index_space_type _subposet_id_space;

  std::vector<subposet*> _subposets;

  void initialize_subposets();



  // ===========================================================
  // ===========================================================

public:

  typedef interval_index_space_handle dof_tuple_index_space_type;

  void initialize_dof_tuple_id_space();

  bool dof_tuple_id_space_initialized() const;

  scoped_index dof_tuple_ext_id(const scoped_index& xid) const;

  scoped_index dof_tuple_ext_id(pod_index_type xid) const;

  dof_tuple_index_space_type& dof_tuple_id_space();

  const dof_tuple_index_space_type& dof_tuple_id_space() const;

  pod_index_type dof_tuple_scratch_id() const;

  void put_dof_tuple_scratch_id(pod_index_type xid);

  typedef unordered::unordered_map<pod_index_type, dof_tuple_type> dof_tuple_types_type;

  dof_tuple_types_type& dof_tuple_types();

  const dof_tuple_types_type& dof_tuple_types() const;

  typedef unordered::unordered_map<pod_index_type, std::string> dof_tuple_class_names_type;

  dof_tuple_class_names_type& dof_tuple_class_names();

  const dof_tuple_class_names_type& dof_tuple_class_names() const;

  typedef unordered::unordered_map<pod_index_type, int> dof_tuple_schema_versions_type;

  dof_tuple_schema_versions_type& dof_tuple_schema_versions();

  const dof_tuple_schema_versions_type& dof_tuple_schema_versions() const;

  bool dof_tuple_schema_versions_contains(pod_index_type xdof_tuple_ext_id) const;

  int dof_tuple_schema_version(pod_index_type xext_id) const;

  typedef unordered::unordered_map<pod_index_type, pod_index_type> dof_tuple_schema_ids_type;

  dof_tuple_schema_ids_type& dof_tuple_schema_ids();

  const dof_tuple_schema_ids_type& dof_tuple_schema_ids() const;

  bool dof_tuple_schema_ids_contains(pod_index_type xdof_tuple_ext_id) const;

  pod_index_type dof_tuple_schema_id(pod_index_type xdof_tuple_ext_id) const;

  pod_index_type dof_tuple_schema_int_id(pod_index_type xdof_tuple_ext_id) const;

  typedef unordered::unordered_map<pod_index_type, poset_bounds_descriptor>
    dof_tuple_col_bounds_type;

  dof_tuple_col_bounds_type& dof_tuple_col_bounds();

  const dof_tuple_col_bounds_type& dof_tuple_col_bounds() const;

  bool dof_tuple_col_bounds_contains(pod_index_type xdof_tuple_ext_id) const;

  const poset_bounds_descriptor& dof_tuple_col_bound(pod_index_type xdof_tuple_ext_id) const;

  void put_dof_tuple_col_bound(pod_index_type xdof_tuple_ext_id);

  void translate_dof_tuple_col_bounds();

  // Note: dof_tuple_domain_offsets uses map rather than unordered_map
  // because there is no default hash function for pairs.
  // Best case performance is not as good as unordered_map, but
  // should be adequate.

  typedef std::map<std::pair<pod_index_type, pod_index_type>, pod_index_type>
    dof_tuple_domain_offsets_type;

  dof_tuple_domain_offsets_type& dof_tuple_domain_offsets();

  const dof_tuple_domain_offsets_type& dof_tuple_domain_offsets() const;

  bool dof_tuple_domain_offsets_contains(pod_index_type xdof_tuple_ext_id,
                                         pod_index_type xdomain_key) const;
  pod_index_type dof_tuple_domain_offset(pod_index_type xdof_tuple_ext_id,
                     pod_index_type xdomain_key) const;

protected:

private:

  dof_tuple_index_space_type _dof_tuple_id_space;

  pod_index_type _dof_tuple_scratch_id;

  dof_tuple_types_type _dof_tuple_types;

  dof_tuple_class_names_type _dof_tuple_class_names;

  dof_tuple_schema_versions_type _dof_tuple_schema_versions;

  dof_tuple_schema_ids_type _dof_tuple_schema_ids;

  dof_tuple_col_bounds_type _dof_tuple_col_bounds;

  dof_tuple_domain_offsets_type _dof_tuple_domain_offsets;



  // ===========================================================
  // ===========================================================

public:

  typedef zero_block_initialization_policy<scattered_insertion_index_space_handle*> init_type;

  typedef auto_block<scattered_insertion_index_space_handle*, init_type> id_spaces_type;

  id_spaces_type& id_spaces();

  const id_spaces_type& id_spaces() const;

protected:

private:

  id_spaces_type _id_spaces;



  // ===========================================================
  // ===========================================================

public:

  virtual poset_scaffold* clone() const;

  virtual bool invariant() const;

  virtual bool is_ancestor_of(const any* other) const;

protected:

private:


};

} // namespace sheaf

#endif // ifndef POSET_SCAFFOLD_H