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

#ifndef SEC_REP_DESCRIPTOR_H
#define SEC_REP_DESCRIPTOR_H

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

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

#ifndef TOTAL_POSET_MEMBER
#include "SheafSystem/total_poset_member.h"
#endif

#ifndef ARRAY_POSET_DOF_MAP
#include "SheafSystem/array_poset_dof_map.h"
#endif

namespace sheaf
{
class any;
class namespace_poset;
class poset;
class poset_state_handle;
}

namespace fiber_bundle
{

using namespace sheaf;
  
class eval_family;
class fiber_bundles_namespace;
class sec_rep_descriptor_poset;
class sec_rep_space;

class SHEAF_DLL_SPEC sec_rep_descriptor: public total_poset_member
{

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

public:

  typedef fiber_bundles_namespace namespace_type;

  typedef sec_rep_descriptor_poset host_type;

  static const poset_path& standard_schema_path();

  static void make_standard_schema(namespace_poset& xns);

  static const poset_path& standard_host_path();

  static host_type& new_host(namespace_type& xns, 
                 const poset_path& xhost_path, 
                 const poset_path& xschema_path,
                             const poset_path& xprototypes_path,
                 bool xauto_access);

  static host_type& standard_host(namespace_type& xns, bool xauto_access);

protected:

private:


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

public: 

  virtual sec_rep_descriptor& operator=(const abstract_poset_member& xother);

  sec_rep_descriptor& operator=(const sec_rep_descriptor& xother);

  // CANONICAL MEMBERS

  sec_rep_descriptor();

  sec_rep_descriptor(const sec_rep_descriptor& xother, bool xnew_jem);

  virtual sec_rep_descriptor* clone() const;

  inline sec_rep_descriptor* clone(bool xnew_state, bool xauto_access = true) const
  {
    return static_cast<sec_rep_descriptor*>(total_poset_member::clone(xnew_state, xauto_access));
  }

  virtual ~sec_rep_descriptor();

  virtual bool invariant() const;

  virtual bool is_ancestor_of(const any* other) const;

  // NEW HANDLE, NEW STATE CONSTRUCTORS

  sec_rep_descriptor(poset *xhost,
                     const std::string& xdiscretization_subposet_name,
                     const std::string& xmultivalued_subposet_name,
                     const std::string& xevaluation_subposet_name,
                     const std::string& xevaluation_method_name,
                     const std::string& xurl,
                     int xmultiplicity,
                     bool xeval_is_above_disc,
                     bool xauto_access);

  // NEW HANDLE, EXISTING STATE CONSTRUCTORS

  sec_rep_descriptor(const poset *xhost, pod_index_type xindex);

  sec_rep_descriptor(const poset *xhost, const scoped_index& xindex);

  sec_rep_descriptor(const poset *xhost, const std::string& xname);

  sec_rep_descriptor(const namespace_poset* xns,
                     const poset_path& xpath,
                     bool xauto_access = true);

  sec_rep_descriptor(const namespace_poset* xnamespace,
                     pod_index_type xposet_id,
                     pod_index_type xmember_id,
                     bool xauto_access = true);

  sec_rep_descriptor(const namespace_poset* xnamespace,
                     const scoped_index& xposet_id,
                     const scoped_index& xmember_id,
                     bool xauto_access = true);


  // EXISTING HANDLE, NEW STATE "CONSTRUCTORS"

  using total_poset_member::new_jim_state;

  virtual void new_jim_state(poset_dof_map* xdof_map = 0,
                             bool xcopy_dof_map = false,
                             bool xauto_access = true);

  virtual void new_jim_state(poset_state_handle* xhost,
                             poset_dof_map* xdof_map = 0,
                             bool xcopy_dof_map = false,
                             bool xauto_access = true);


  void new_jim_state(poset *xhost,
                     const std::string& xdiscretization_subposet_name,
                     const std::string& xmultivalued_subposet_name,
                     const std::string& xevaluation_subposet_name,
                     const std::string& xevaluation_method_name,
                     const std::string& xurl,
                     int xmultiplicity,
                     bool xeval_is_above_disc,
                     bool xauto_access);

  // DEGREE OF FREEDOM (DOF) TUPLE INTERFACE

  virtual array_poset_dof_map& dof_map(bool xrequire_write_access = false);

  virtual const array_poset_dof_map& dof_map(bool xrequire_write_access = false) const;

  virtual bool dof_map_is_ancestor_of(const poset_dof_map* xdof_map) const;

  // SEC_REP_DESCRIPTOR FACET

  std::string discretization_subposet_name() const;

  void put_discretization_subposet_name(const std::string& xname);

  std::string multivalued_subposet_name() const;

  void put_multivalued_subposet_name(const std::string& xname);

  std::string evaluation_subposet_name() const;

  void put_evaluation_subposet_name(const std::string& xname);

  std::string evaluator_family_name() const;

  void put_evaluator_family_name(const std::string& xname);

  std::string url() const;

  void put_url(const std::string& xurl);

  int multiplicity() const;

  void put_multiplicity(int xmultiplicity);

  bool eval_is_above_disc() const;

  void put_eval_is_above_disc(bool xvalue);

  eval_family* evaluators() const;

protected:

  virtual void attach_handle_data_members();

private:
  class SHEAF_DLL_SPEC row_dof_tuple
  {
  public:

    char* discretization_subposet_name;

    char* multivalued_subposet_name;

    char* evaluation_subposet_name;

    char* evaluator_family_name;

    char* url;

    int multiplicity;

    size_type eval_is_above_disc;

    row_dof_tuple(const std::string& xdiscretization_subposet_name,
                  const std::string& xmultivalued_subposet_name,
                  const std::string& xevaluation_subposet_name,
                  const std::string& xevaluator_family_name,
                  const std::string& xurl,
                  int xmultiplicity,
                  size_type xeval_is_above_disc);

    static void copy_string_dof(char*& xdof, const std::string& xdof_value);

  };

  inline const row_dof_tuple* row_dof_tuple_ptr() const
  {
    return reinterpret_cast<const row_dof_tuple*>(dof_map(false).dof_tuple());
  };

  inline row_dof_tuple* row_dof_tuple_ptr()
  {
    return reinterpret_cast<row_dof_tuple*>(dof_map(true).dof_tuple());
  };

  eval_family* _evaluators;


};

} // namespace fiber_bundle

#endif // ifndef SEC_REP_DESCRIPTOR_H