refinable_poset.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 REFINABLE_POSET_H
#define REFINABLE_POSET_H

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

#ifndef POSET_H
#include "SheafSystem/poset.h"
#endif

namespace sheaf
{
  
class namespace_poset;

class SHEAF_DLL_SPEC refinable_poset : public poset
{

  friend class abstract_poset_member;
  friend class block_poset_builder;
  friend class namespace_poset;
  friend class poset_component;
  friend class poset_orderer;
  friend class poset_traverser;
  friend class storage_agent;

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

public:

  static refinable_poset& new_table(namespace_type& xhost, 
                    const poset_path& xpath, 
                    const poset_path& xschema_path,
                    bool xauto_access);

  void put_version(int xversion);

  subposet& coarsest_common_refinement();

  const subposet& coarsest_common_refinement() const;

  subposet& coarsest_common_refinement_jims();

  const subposet& coarsest_common_refinement_jims() const;

  virtual void begin_refine_mode(bool xauto_access = true);

  virtual void end_refine_mode(bool xensure_lattice_invariant = true,
                               bool xauto_access = true);

protected:

  refinable_poset();

  virtual ~refinable_poset();

  refinable_poset(const refinable_poset& xother) { };

  refinable_poset& operator=(const poset_state_handle& xother)
  {
    return const_cast<refinable_poset&>(*this);
  };

private:

  void new_version(int xversion);



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

public:

protected:

private:

  static bool make_prototype();



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

public:

  virtual poset_type type_id() const;

  virtual const char* class_name() const;

  // Need to redefine the protected new_member.
  // Need to put using declaration here as opposed to with
  // redeclaration so it won't make the inherited public
  // new_member functions protected.


  //  using poset::new_member;

  virtual pod_index_type new_member(bool xis_jim, pod_index_type xdof_tuple_id);

  void new_member(bool xis_jim, const scoped_index& xdof_tuple_id, scoped_index& result)
  {
    poset::new_member(xis_jim, xdof_tuple_id, result);
  }

  pod_index_type new_member(bool xis_jim, poset_dof_map* xdof_map = 0, bool xcopy_dof_map = false)
  {
    return poset::new_member(xis_jim, xdof_map, xcopy_dof_map);
  };

  void new_member(bool xis_jim, poset_dof_map* xdof_map,
          bool xcopy_dof_map, scoped_index& result)
  {
    poset::new_member(xis_jim, xdof_map, xcopy_dof_map, result);
  }

  // Need to redefine the protected new_member_interval.
  // Need to put using declaration here as opposed to with
  // redeclaration so it won't make the inherited public
  // new_member_interval functions protected.


  //  using poset::new_member_interval;

  virtual pod_index_type new_member_interval(const std::string& xinterval_type,
                         size_type xsize,
                         const block<pod_index_type>& xdof_tuple_ids,
                         const block<pod_index_type>& xdata)
  {
    return poset::new_member_interval(xinterval_type, xsize, xdof_tuple_ids, xdata);
  };

  void new_member_interval(const std::string& xinterval_type, size_type xsize,
               const block<pod_index_type>& xdof_tuple_ids,
               const block<pod_index_type>& xdata,
               scoped_index& result)
  {
    poset::new_member_interval(xinterval_type, xsize, xdof_tuple_ids, xdata, result);
  }

protected:

  // see description of using declaration hack above.

  virtual void new_member(const scoped_index& xindex, 
              bool xis_jim, 
              const scoped_index& xdof_tuple_id);

  void new_member(const scoped_index& xindex, 
          bool xis_jim, 
          poset_dof_map* xdof_map = 0, 
          bool xcopy_dof_map = false)
  {
    poset::new_member(xindex.hub_pod(), xis_jim, xdof_map, xcopy_dof_map);
  };

  // Using declaration for new_member_interval in public scope above.

  virtual pod_index_type new_member_interval(const std::string& xinterval_type, size_type xsize);

  virtual void new_member_interval(const scoped_index& xindex,
                   const std::string& xinterval_type, 
                   size_type xsize);

private:



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

public:

  virtual bool is_ancestor_of(const any* other) const;

  virtual refinable_poset* clone() const;

  virtual bool invariant() const;

protected:

private:

};
 
} // namespace sheaf

#endif // REFINABLE_POSET_H