poset_component.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_COMPONENT_H
#define POSET_COMPONENT_H

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

#ifndef POSET_STATE_H
#include "SheafSystem/poset_state.h"
#endif

#ifndef READ_WRITE_MONITOR_HANDLE_H
#include "SheafSystem/read_write_monitor_handle.h"
#endif

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

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

namespace sheaf
{

  class namespace_poset;
  class poset;
  class poset_crg_state;
  class poset_dof_map;
  class poset_path;
  class poset_powerset_state;
  class poset_state;
  class poset_state_handle;
  class subposet_state;

class SHEAF_DLL_SPEC poset_component : public read_write_monitor_handle
{

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

public:

  virtual ~poset_component();

protected:

  poset_component();

  poset_state* state_obj() const;

  poset_powerset_state* powerset() const;

  poset_crg_state* crg() const;

  virtual subposet_state* powerset_member(const scoped_index& xindex) const;

  poset_dof_map* row_dof_tuple(const scoped_index& xindex) const;

  virtual void init_handle_data_members();

  virtual void attach_handle_data_members();

  poset_state_handle* _host;

  scoped_index _index;

  int _version;

private:



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

public:

  const scoped_index& index() const;

  virtual bool is_valid_index(const poset_state_handle* xhost,
                              pod_index_type xhub_id,
                              int xversion = CURRENT_HOST_VERSION) const = 0;

  bool is_valid_index(const poset_state_handle* xhost,
              const scoped_index& xid,
              int xversion = CURRENT_HOST_VERSION) const;

  virtual const hub_index_space_handle& hub_id_space() const = 0;  

  virtual const scoped_index& hub_id() const = 0;

  virtual scoped_index hub_id(pod_index_type xid) const = 0;

  virtual pod_index_type get_index_from_name(const poset_state_handle* xhost,
                         const std::string& xname) const = 0;

  virtual void get_index_from_name(const poset_state_handle* xhost,
                   const std::string& xname,
                   scoped_index& result) const = 0;

  int version(bool xunalias = true) const;

  virtual void put_version(int xversion, bool xunalias = false);

  int unaliased_version(int xversion) const;

  pod_index_type version_index() const;

  void version_index(scoped_index& result) const;

  std::string version_name() const;

  bool has_version(int xversion) const;

protected:

private:



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

public:

  std::string name() const;

  virtual std::string name(bool xauto_access) const = 0;

  virtual void all_names(block<std::string>& xresult, bool xauto_access = false) const = 0;

  virtual size_type name_ct(bool xauto_access) const = 0;

  virtual bool has_name(const std::string& xname, bool xauto_access = false) const = 0;

  virtual void put_name(const std::string& xname, bool xunique, bool xauto_access) = 0;

  virtual void delete_name(const std::string& xname, bool xauto_access = false) = 0;

  virtual void delete_all_names(bool xauto_access = false) = 0;

  bool is_valid_name(const poset_state_handle* xhost, const std::string& xname) const;

  poset_path path(bool xauto_access = true) const;

  bool has_path(const poset_path& xpath, bool xauto_access) const;

protected:

private:



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

public:

  poset_state_handle* host() const;

  virtual bool host_is_ancestor_of(const poset_state_handle* xther) const;

  bool has_same_host(const poset_component* xother) const;

  inline bool in_same_space(const poset_component* xother) const
  {
    return has_same_host(xother);
  };

protected:

private:



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

public:

  virtual namespace_poset* name_space() const;

  virtual bool namespace_is_ancestor_of(const namespace_poset* xother) const;

  bool same_namespace(const poset_component* xother) const;

  bool same_namespace(const poset_state_handle* xother) const;

protected:

private:



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

public:

  void attach_to_state(const poset_state_handle* xhost, pod_index_type xhub_id);

  void attach_to_state(const poset_state_handle* xhost, const scoped_index& xid);

  void attach_to_state(const poset_state_handle* xhost, const std::string& xname);

  // Not included in generated documentation; would just be confusing.
  inline void attach_to_state(const namespace_poset* xhost, const std::string& xname)
  {
    // This routine needed to resolve ambiguity between the preceeding
    // routine and attach_to_state(namespace_poset*, const poset_path&),
    // when called with signature (namespace_poset*, const std::string&).
    // Compiler can't choose between conversion of namespace_poset* to
    // poset_state_handle* versus conversion of const std::string& to const poset_path&.

    attach_to_state(reinterpret_cast<const poset_state_handle*>(xhost), xname);
  };

  void attach_to_state(const std::string&);

  void attach_to_state(pod_index_type xhub_id);

  void attach_to_state(const scoped_index& xid);

  void attach_to_state(const poset_component* xother);

  void attach_to_state(const poset_component* xother, bool xauto_access);

  virtual void detach_from_state();

  virtual void delete_state(bool xauto_access = false) = 0;

  virtual bool is_attached() const;

  bool is_same_state(const poset_state_handle* xhost,
                     pod_index_type xhub_id) const;

  bool is_same_state(const poset_state_handle* xhost,
                     const scoped_index& xid) const;

  bool is_same_state(const poset_component* xother) const;

protected:

private:



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

public:

  virtual void get_read_access() const;

  virtual void get_read_write_access(bool xrelease_read_only_access = false);

  virtual void release_access(bool xall = false) const;

protected:

private:



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

public:

  virtual bool is_ancestor_of(const any* other) const;

  virtual poset_component* clone() const = 0;

  virtual bool invariant() const;

protected:

private:

};

// ===========================================================
// NON-MEMBER FUNCTIONS
// ===========================================================


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

 } // namespace sheaf

#endif // ifndef POSET_COMPONENT_H