read_write_monitor.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 READ_WRITE_MONITOR


#ifndef READ_WRITE_MONITOR_H
#define READ_WRITE_MONITOR_H

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


#ifdef _PTHREADS

// hash map only used with threads
// unordered_map.h includes hashtable.h includes stl_alloc.h includes time.h
// causes conflict in declaration of timespec in thread_condition_variable.h
// if unordered_map.h included when not _PTHREADS
#ifndef STD_UNORDERED_MAP_H
#include "SheafSystem/std_unordered_map.h"
#endif

#include "SheafSystem/pthread.h"
#endif

#include "SheafSystem/any.h"

#ifndef STD_UTILITY_H
#include "SheafSystem/std_utility.h"
#endif

namespace sheaf
{
  
class SHEAF_DLL_SPEC read_write_monitor : public any
{
  friend class read_write_monitor_handle;

public:
  // ===========================================================
  // ===========================================================

public:
 
  // Constructors:

  read_write_monitor();

  virtual ~read_write_monitor();

protected:

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.
  //   /// 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();

protected:

private:

  static bool& private_access_control_disabled();  

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

public:

  bool is_read_accessible() const;

  bool is_not_read_accessible() const;

  bool is_read_write_accessible() const;

  bool is_not_read_write_accessible() const;

  bool is_read_only_accessible() const;

  bool is_not_read_only_accessible() const;

  int access_request_depth() const;

  void get_read_access() const;

  void get_read_write_access(bool xrelease_read_only_access = false);

  void release_access(bool xall = false) const;

protected:

  bool access_guards_disabled() const;

  void disable_access_guards();

  void enable_access_guards();

private:

  bool uncontrolled_is_read_write_accessible() const;

  bool uncontrolled_is_read_only_accessible() const;

  bool _access_guards_disabled;

  mutable int _ro_ct;

  mutable int _rw_ct;

  // Strictly speaking, we don't need _ro_ct and _rw_ct in
  // the unthreaded case, but we use them anyway to make the
  // threaded and unthreaded implementations more similar.

  struct SHEAF_DLL_SPEC thread_state_t
  {
    int  _access_mode;

    size_t _switch_depth;

    bool _is_modified;
  };


#ifdef _PTHREADS

  mutable unordered::unordered_map<pthread_t, thread_state_t> _thread_state;

  mutable pthread_cond_t lock_free;

  mutable pthread_mutex_t read_write_monitor_mutex;

#else

  mutable thread_state_t _thread_state;

#endif


  void initialize_thread_state();

  bool contains_thread_state() const;

  thread_state_t& thread_state() const;

  int& access_mode() const;

  size_t& switch_depth() const;

  void request_read_only_access() const;

  void request_read_write_access() const;

  void release_read_only_access() const;

  void release_read_write_access() const;

private:


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

public:

  bool is_modified() const;

  void clear_is_modified();


protected:

private:

 

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

public:

  bool  is_mode_locked() const;

  int   mode_lock_ct() const;

  void  get_mode_lock();

  void  release_mode_lock();

protected:

private:

  int _mode_lock_ct;

 

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

public:

  virtual bool is_ancestor_of(const any* xother) const;


  virtual read_write_monitor* clone() const;


  virtual bool invariant() const;

protected:

private:

 

};

} // namespace sheaf

#endif // ifndef READ_WRITE_MONITOR_H