field_vd.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 FIELD_VD_H
#define FIELD_VD_H

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

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

#ifndef FIELDS_H
#include "SheafSystem/fields.h"
#endif

namespace sheaf
{
class name_multimap;
class namespace_poset;
class poset_path;
class subposet;
}

namespace fiber_bundle
{
class base_space_member;
class sec_ed;
class sec_vd;
class sec_at0;
class vd;
class vd_lite;
}

namespace geometry
{
class sec_ed_invertible;
}

namespace fields
{
class discretization_push_action;
class property_disc_iterator;
class put_property_dofs_action;


class SHEAF_DLL_SPEC field_vd : public any
{
  //===========================================================================
  //===========================================================================

public:

  field_vd();

  field_vd(const field_vd& xother, bool xauto_access);

  field_vd(const sec_ed& xcoordinates, const sec_vd& xproperty,
           bool xauto_access);

  field_vd(namespace_poset& xns,
           const poset_path& xcoordinates_path,
           const poset_path& xproperty_path,
           bool xauto_access);

  virtual ~field_vd();

  int dc() const;

  int dp() const;

  int db() const;

  namespace_poset& name_space() const;

  sec_ed_invertible& coordinates() const;

  sec_vd& property() const;

  base_space_member& base_space() const;

  property_disc_iterator* new_property_disc_iterator() const;

  typedef void (*property_dof_function_type)
    (block<sec_vd_value_type>& xglobal_coords,
     block<sec_vd_dof_type>& xproperty_dofs);

  static void property_dof_function_example(
    block<sec_vd_value_type>& xglobal_coords,
    block<sec_vd_dof_type>& xproperty_dofs);


  void put_property_dofs(property_dof_function_type xproperty_dofs_fcn,
                         bool xauto_access);


  static void put_property_dofs(const sec_vd& xcoordinates,
                                sec_vd& xproperty,
                                property_dof_function_type xproperty_dofs_fcn,
                                bool xauto_access);

  void put_property_dofs(put_property_dofs_action& xproperty_dofs_action,
                         bool xauto_access);

  static void put_property_dofs(const sec_vd& xcoordinates,
                                sec_vd& xproperty,
                                put_property_dofs_action& xproperty_dofs_action,
                                bool xauto_access);

  void print_property_dofs(std::ostream& xos,
                           property_dof_function_type xproperty_dofs_fcn,
                           const std::string& xtitle_text,
                           bool xzero_specified,
                           bool xauto_access) const;

  bool same_property_fiber_schema(const field_vd& xother,
                                  bool xauto_access) const;

  bool same_evaluation() const;

  bool same_discretization() const;

  void property_at_coordinates(const vd_lite& xcoord, vd_lite& xprop) const;

  void property_at_coordinates(const block<sec_vd_value_type>& xcoord,
                               block<sec_vd_value_type>& xprop) const;

  void property_at_coordinates(sec_vd_value_type xcoord_base[],
                               int xcoord_ct,
                               sec_vd_value_type xprop_base[],
                               int xprop_ub) const;

  subposet* embed_property(const std::string& xresult_name,
                           name_multimap& xresult_member_names,
                           bool xauto_access);

  static void delete_field_spaces(field_vd* xfield,
                                  bool xdelete_coord_fiber,
                                  bool xdelete_prop_fiber);

protected:

  field_vd(sec_vd* xproperty,
           sec_ed_invertible* xcoordinates,
           base_space_member* xbase_space); 

//private:


  sec_vd* _property;

  sec_ed_invertible* _coordinates;

  base_space_member* _base_space;

private:


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

public:


  static bool access_control_disabled();

  //   ///
  //   /// Disables access control.
  //   /// Disabled (true) is equivalent to having read-write access
  //   /// at all times, irrespective of any access control requests.
  //   /// Synonym for read_write_monitor::disable_access_control().
  //   /// Should only be invoked once at beginning of a program, before any
  //   /// other SheafSystem calls. Once disabled, access control can not be re-enabled.
  //   ///
  //   static void disable_access_control();

  static void enable_access_control();

  virtual bool is_attached() const;

  bool state_is_read_only_accessible() const;

  bool state_is_not_read_only_accessible() const;

  bool state_is_read_accessible() const;

  bool state_is_not_read_accessible() const;

  bool state_is_read_write_accessible(bool xbase_access = false) const;

  bool state_is_not_read_write_accessible(bool xbase_access = false) const;

  int access_request_depth() const;

  virtual void get_read_access() const;

  virtual void get_read_write_access(bool xbase_access,
                                     bool xrelease_read_only_access);

  virtual void release_access(bool xall = false) const;

  bool state_is_modified() const;

  void clear_state_is_modified();


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

public:

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

  static const std::string& static_class_name();

  virtual bool is_ancestor_of(const any* xother) const;

  virtual field_vd* clone() const;

  virtual field_vd& operator=(const field_vd& xother);

  field_vd& operator=(const sec_vd& xsection);

  field_vd& operator=(const vd& xfiber);

  field_vd& operator=(const vd_lite& xfiber);

  virtual bool invariant() const;


};

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

SHEAF_DLL_SPEC
void push(const field_vd& xsrc, field_vd& xdst, bool xauto_access);

SHEAF_DLL_SPEC
field_vd& operator>>(const field_vd& xsrc, field_vd& xdst);

SHEAF_DLL_SPEC
std::ostream& operator<<(std::ostream& xos, const field_vd& xfield);

} // namespace fields


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


#include "SheafSystem/field_vd_funcs.h"


#endif // ifndef FIELD_VD_H