poset_dof_map.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 poset_dof_map;
// map from client dof id to dof value

#ifndef POSET_DOF_MAP_H
#define POSET_DOF_MAP_H

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

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

#ifndef DOF_TUPLE_TYPE_H
#include "SheafSystem/dof_tuple_type.h"
#endif

#ifndef PRIMITIVE_VALUE_H
#include "SheafSystem/primitive_value.h"
#endif

#ifndef SCOPED_INDEX_H
#include "SheafSystem/scoped_index.h"
#endif

#ifndef STD_STRING_H
#include "SheafSystem/std_string.h"
#endif 

namespace sheaf
{

class poset_state_handle;
class schema_poset_member;
class arg_list;
class dof_map_factory;

class SHEAF_DLL_SPEC poset_dof_map : public any
{

  friend class poset_table_state;
  friend class poset_state_handle;
  friend SHEAF_DLL_SPEC size_t deep_size(const poset_dof_map& xp, bool xinclude_shallow);

public:

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

  static const std::string& static_class_name();

  static poset_dof_map*
  new_dof_map(const std::string& xclass_name, dof_tuple_type xsheaf_base_class_id);

  // CANONICAL MEMBERS

  virtual poset_dof_map* clone() const = 0;

  virtual poset_dof_map* copy() const = 0;

  poset_dof_map& operator=(const poset_dof_map& xother);

  virtual ~poset_dof_map();

  virtual bool invariant() const;


  // MAP INTERFACE

  virtual void init_row_dof_map(const poset_state_handle* xhost,
                                pod_index_type xschema_mbr_id,
                                int xschema_version);

  void init_row_dof_map(const poset_state_handle* xhost,
            const scoped_index& xschema_mbr_id,
            int xschema_version);

  virtual dof_tuple_type type_id() const = 0;

  bool is_initialized() const;

  virtual poset_state_handle* host() const;

  const scoped_index& index() const;

  // $$SCRIBBLE: there's no need for schema() to be virtual.
  // It's only overridden in one place, section_dof_map, and
  // the over ride only does a down cast on the return type.
  // Should be non-virtual and inline and section_dof_map
  // should just hide poset_dof_map; more efficient.

  virtual schema_poset_member& schema();

  virtual const schema_poset_member& schema() const;

  bool is_table_dof_map() const;

  int dof_ct() const;

  // ===========================================================
  //  NEW DOF ACCESS FACET
  // ===========================================================
 
  primitive_value dof(pod_index_type xdof_id) const;

  primitive_value dof(const scoped_index& xdof_id) const;

  primitive_value dof(const std::string& xname) const;

  void put_dof(pod_index_type xdof_id, const primitive_value& xdof);

  void put_dof(const scoped_index& xdof_id, const primitive_value& xdof);

  void put_dof(const std::string& xname, const primitive_value& xdof);

  virtual void get_dof(pod_index_type xdof_id, void* xdof, size_type xdof_size) const;

  void get_dof(const scoped_index& xdof_id, void* xdof, size_type xdof_size) const;

  virtual void put_dof(pod_index_type xdof_id, const void* xdof, size_type xdof_size);

  void put_dof(const scoped_index& xdof_id, const void* xdof, size_type xdof_size);
  
  
  // ===========================================================
  //  END NEW DOF ACCESS FACET
  // ===========================================================

  size_t dof_tuple_ub() const;

  virtual void* dof_tuple() = 0;

  virtual const void* dof_tuple() const = 0;

  virtual void get_dof_tuple(void* xbuf, size_t xbuflen) const = 0;

  virtual void put_dof_tuple(const void* xbuf, size_t xbuflen) = 0;

  void get_dof_tuple(arg_list& xargs) const;

  void put_dof_tuple(const arg_list& xargs);

  void copy_dof_tuple(const poset_dof_map& xother);

  virtual void put_defaults();

  unsigned int ref_ct() const;

  void inc_ref_ct();

  void dec_ref_ct();

  int version() const;

  virtual const index_space_handle& client_id_space() const;

  std::string to_string(const schema_poset_member& xschema) const;

  std::string to_string() const;

  // ===========================================================
  // I/O SUPPORT FACET
  // ===========================================================

  virtual bool supports_xfr_opt() const;

protected:

  static dof_map_factory& factory();

  // CANONICAL MEMBERS

  poset_dof_map();

  poset_dof_map(const poset_dof_map& xother);

  // OTHER CONSTRUCTORS

  poset_dof_map(const poset_state_handle* xhost, bool xis_table_dof_map);

  poset_dof_map(const schema_poset_member* xschema, bool xis_table_dof_map);

  // MAP INTERFACE

  virtual void put_host(const poset_state_handle* xhost);

  void put_index(const scoped_index& xindex);

  void put_dof_ct(int xdof_ct);

  void put_dof_tuple_ub(size_t xub);

  void put_ref_ct(int xref_ct);

  poset_state_handle* _host;

  scoped_index _index;

  schema_poset_member* _schema;

  bool _is_table_dof_map;

  int _dof_ct;

  size_t _dof_tuple_ub;

  unsigned int _ref_ct;

  virtual void allocate_dofs() = 0;

};

// ===========================================================
// NONMEMBER FUNCTIONS
// ===========================================================

SHEAF_DLL_SPEC
std::ostream& operator << (std::ostream &os, const poset_dof_map& p);

SHEAF_DLL_SPEC
size_t deep_size(const poset_dof_map& xp, bool xinclude_shallow = true);

} // namespace sheaf

#endif // ifndef POSET_DOF_MAP_H