thread_system.h

Go to the documentation of this file.

/*
 * Copyright 2011 Google 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 PAGESPEED_KERNEL_BASE_THREAD_SYSTEM_H_
#define PAGESPEED_KERNEL_BASE_THREAD_SYSTEM_H_

#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/thread_annotations.h"

namespace net_instaweb {

class Timer;

class ThreadSystem {
 public:
  class Condvar;
  class Thread;
  class ThreadImpl;

  class LOCKABLE CondvarCapableMutex : public AbstractMutex {
   public:
    CondvarCapableMutex() { }
    virtual ~CondvarCapableMutex();

    virtual Condvar* NewCondvar() = 0;

   private:
    
  };

  class LOCKABLE RWLock : public AbstractMutex {
   public:
    RWLock() {}
    virtual ~RWLock();

    virtual bool ReaderTryLock() SHARED_TRYLOCK_FUNCTION(true) = 0;
    virtual void ReaderLock() SHARED_LOCK_FUNCTION() = 0;
    virtual void ReaderUnlock() UNLOCK_FUNCTION() = 0;

    virtual void DCheckReaderLocked();

   private:
    
  };

  class SCOPED_LOCKABLE ScopedReader {
   public:
    explicit ScopedReader(RWLock* lock) SHARED_LOCK_FUNCTION(lock)
        : lock_(lock) {
      lock_->ReaderLock();
    }

    void Release() UNLOCK_FUNCTION() {
      if (lock_ != NULL) {
        lock_->ReaderUnlock();
        lock_ = NULL;
      }
    }

    ~ScopedReader() UNLOCK_FUNCTION() { Release(); }

   private:
    RWLock* lock_;

    
  };

  class ThreadId {
   public:
    ThreadId() {}
    virtual ~ThreadId();
    virtual bool IsEqual(const ThreadId& that) const = 0;
    virtual bool IsCurrentThread() const = 0;

   private:
    
  };

  enum ThreadFlags {
    kDetached = 0,
    kJoinable = 1
  };

  virtual ~ThreadSystem();
  ThreadSystem() {}

  virtual CondvarCapableMutex* NewMutex() = 0;

  virtual RWLock* NewRWLock() = 0;

  virtual Timer* NewTimer() = 0;

  virtual ThreadId* GetThreadId() const = 0;

 private:
  friend class Thread;
  friend class MockThreadSystem;
  friend class CheckingThreadSystem;
  virtual ThreadImpl* NewThreadImpl(Thread* wrapper, ThreadFlags flags) = 0;

  
};

class ThreadSystem::ThreadImpl {
 public:
  virtual bool StartImpl() = 0;
  virtual void JoinImpl() = 0;
  virtual ~ThreadImpl();

 protected:
  ThreadImpl() {}

 private:
  
};

#define ScopedReader(x) COMPILE_ASSERT(0, mutex_lock_decl_missing_var_name)

}  

#endif