auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/lib/cpp/src/concurrency/Monitor.cpp

@@ -1,137 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you 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.
- */
-
-#include "Monitor.h"
-#include "Exception.h"
-#include "Util.h"
-
-#include <assert.h>
-#include <errno.h>
-
-#include <iostream>
-
-#include <pthread.h>
-
-namespace apache { namespace thrift { namespace concurrency {
-
-/**
- * Monitor implementation using the POSIX pthread library
- *
- * @version $Id:$
- */
-class Monitor::Impl {
-
- public:
-
-  Impl() :
-    mutexInitialized_(false),
-    condInitialized_(false) {
-
-    if (pthread_mutex_init(&pthread_mutex_, NULL) == 0) {
-      mutexInitialized_ = true;
-
-      if (pthread_cond_init(&pthread_cond_, NULL) == 0) {
-        condInitialized_ = true;
-      }
-    }
-
-    if (!mutexInitialized_ || !condInitialized_) {
-      cleanup();
-      throw SystemResourceException();
-    }
-  }
-
-  ~Impl() { cleanup(); }
-
-  void lock() const { pthread_mutex_lock(&pthread_mutex_); }
-
-  void unlock() const { pthread_mutex_unlock(&pthread_mutex_); }
-
-  void wait(int64_t timeout) const {
-
-    // XXX Need to assert that caller owns mutex
-    assert(timeout >= 0LL);
-    if (timeout == 0LL) {
-      int iret = pthread_cond_wait(&pthread_cond_, &pthread_mutex_);
-      assert(iret == 0);
-    } else {
-      struct timespec abstime;
-      int64_t now = Util::currentTime();
-      Util::toTimespec(abstime, now + timeout);
-      int result = pthread_cond_timedwait(&pthread_cond_,
-                                          &pthread_mutex_,
-                                          &abstime);
-      if (result == ETIMEDOUT) {
-        // pthread_cond_timedwait has been observed to return early on
-        // various platforms, so comment out this assert.
-        //assert(Util::currentTime() >= (now + timeout));
-        throw TimedOutException();
-      }
-    }
-  }
-
-  void notify() {
-    // XXX Need to assert that caller owns mutex
-    int iret = pthread_cond_signal(&pthread_cond_);
-    assert(iret == 0);
-  }
-
-  void notifyAll() {
-    // XXX Need to assert that caller owns mutex
-    int iret = pthread_cond_broadcast(&pthread_cond_);
-    assert(iret == 0);
-  }
-
- private:
-
-  void cleanup() {
-    if (mutexInitialized_) {
-      mutexInitialized_ = false;
-      int iret = pthread_mutex_destroy(&pthread_mutex_);
-      assert(iret == 0);
-    }
-
-    if (condInitialized_) {
-      condInitialized_ = false;
-      int iret = pthread_cond_destroy(&pthread_cond_);
-      assert(iret == 0);
-    }
-  }
-
-  mutable pthread_mutex_t pthread_mutex_;
-  mutable bool mutexInitialized_;
-  mutable pthread_cond_t pthread_cond_;
-  mutable bool condInitialized_;
-};
-
-Monitor::Monitor() : impl_(new Monitor::Impl()) {}
-
-Monitor::~Monitor() { delete impl_; }
-
-void Monitor::lock() const { impl_->lock(); }
-
-void Monitor::unlock() const { impl_->unlock(); }
-
-void Monitor::wait(int64_t timeout) const { impl_->wait(timeout); }
-
-void Monitor::notify() const { impl_->notify(); }
-
-void Monitor::notifyAll() const { impl_->notifyAll(); }
-
-}}} // apache::thrift::concurrency

data/vendor/gems/thrift/lib/cpp/src/concurrency/Monitor.h

@@ -1,84 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you 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 _THRIFT_CONCURRENCY_MONITOR_H_
-#define _THRIFT_CONCURRENCY_MONITOR_H_ 1
-
-#include "Exception.h"
-
-namespace apache { namespace thrift { namespace concurrency {
-
-/**
- * A monitor is a combination mutex and condition-event.  Waiting and
- * notifying condition events requires that the caller own the mutex.  Mutex
- * lock and unlock operations can be performed independently of condition
- * events.  This is more or less analogous to java.lang.Object multi-thread
- * operations
- *
- * Note that all methods are const.  Monitors implement logical constness, not
- * bit constness.  This allows const methods to call monitor methods without
- * needing to cast away constness or change to non-const signatures.
- *
- * @version $Id:$
- */
-class Monitor {
-
- public:
-
-  Monitor();
-
-  virtual ~Monitor();
-
-  virtual void lock() const;
-
-  virtual void unlock() const;
-
-  virtual void wait(int64_t timeout=0LL) const;
-
-  virtual void notify() const;
-
-  virtual void notifyAll() const;
-
- private:
-
-  class Impl;
-
-  Impl* impl_;
-};
-
-class Synchronized {
- public:
-
- Synchronized(const Monitor& value) :
-   monitor_(value) {
-   monitor_.lock();
-  }
-
-  ~Synchronized() {
-    monitor_.unlock();
-  }
-
- private:
-  const Monitor& monitor_;
-};
-
-
-}}} // apache::thrift::concurrency
-
-#endif // #ifndef _THRIFT_CONCURRENCY_MONITOR_H_

data/vendor/gems/thrift/lib/cpp/src/concurrency/Mutex.cpp

@@ -1,160 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you 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.
- */
-
-#include "Mutex.h"
-
-#include <assert.h>
-#include <pthread.h>
-
-using boost::shared_ptr;
-
-namespace apache { namespace thrift { namespace concurrency {
-
-/**
- * Implementation of Mutex class using POSIX mutex
- *
- * @version $Id:$
- */
-class Mutex::impl {
- public:
-  impl(Initializer init) : initialized_(false) {
-    init(&pthread_mutex_);
-    initialized_ = true;
-  }
-
-  ~impl() {
-    if (initialized_) {
-      initialized_ = false;
-      int ret = pthread_mutex_destroy(&pthread_mutex_);
-      assert(ret == 0);
-    }
-  }
-
-  void lock() const { pthread_mutex_lock(&pthread_mutex_); }
-
-  bool trylock() const { return (0 == pthread_mutex_trylock(&pthread_mutex_)); }
-
-  void unlock() const { pthread_mutex_unlock(&pthread_mutex_); }
-
- private:
-  mutable pthread_mutex_t pthread_mutex_;
-  mutable bool initialized_;
-};
-
-Mutex::Mutex(Initializer init) : impl_(new Mutex::impl(init)) {}
-
-void Mutex::lock() const { impl_->lock(); }
-
-bool Mutex::trylock() const { return impl_->trylock(); }
-
-void Mutex::unlock() const { impl_->unlock(); }
-
-void Mutex::DEFAULT_INITIALIZER(void* arg) {
-  pthread_mutex_t* pthread_mutex = (pthread_mutex_t*)arg;
-  int ret = pthread_mutex_init(pthread_mutex, NULL);
-  assert(ret == 0);
-}
-
-static void init_with_kind(pthread_mutex_t* mutex, int kind) {
-  pthread_mutexattr_t mutexattr;
-  int ret = pthread_mutexattr_init(&mutexattr);
-  assert(ret == 0);
-
-  // Apparently, this can fail.  Should we really be aborting?
-  ret = pthread_mutexattr_settype(&mutexattr, kind);
-  assert(ret == 0);
-
-  ret = pthread_mutex_init(mutex, &mutexattr);
-  assert(ret == 0);
-
-  ret = pthread_mutexattr_destroy(&mutexattr);
-  assert(ret == 0);
-}
-
-#ifdef PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP
-void Mutex::ADAPTIVE_INITIALIZER(void* arg) {
-  // From mysql source: mysys/my_thr_init.c
-  // Set mutex type to "fast" a.k.a "adaptive"
-  //
-  // In this case the thread may steal the mutex from some other thread
-  // that is waiting for the same mutex. This will save us some
-  // context switches but may cause a thread to 'starve forever' while
-  // waiting for the mutex (not likely if the code within the mutex is
-  // short).
-  init_with_kind((pthread_mutex_t*)arg, PTHREAD_MUTEX_ADAPTIVE_NP);
-}
-#endif
-
-#ifdef PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
-void Mutex::RECURSIVE_INITIALIZER(void* arg) {
-  init_with_kind((pthread_mutex_t*)arg, PTHREAD_MUTEX_RECURSIVE_NP);
-}
-#endif
-
-
-/**
- * Implementation of ReadWriteMutex class using POSIX rw lock
- *
- * @version $Id:$
- */
-class ReadWriteMutex::impl {
-public:
-  impl() : initialized_(false) {
-    int ret = pthread_rwlock_init(&rw_lock_, NULL);
-    assert(ret == 0);
-    initialized_ = true;
-  }
-
-  ~impl() {
-    if(initialized_) {
-      initialized_ = false;
-      int ret = pthread_rwlock_destroy(&rw_lock_);
-      assert(ret == 0);
-    }
-  }
-
-  void acquireRead() const { pthread_rwlock_rdlock(&rw_lock_); }
-
-  void acquireWrite() const { pthread_rwlock_wrlock(&rw_lock_); }
-
-  bool attemptRead() const { return pthread_rwlock_tryrdlock(&rw_lock_); }
-
-  bool attemptWrite() const { return pthread_rwlock_trywrlock(&rw_lock_); }
-
-  void release() const { pthread_rwlock_unlock(&rw_lock_); }
-
-private:
-  mutable pthread_rwlock_t rw_lock_;
-  mutable bool initialized_;
-};
-
-ReadWriteMutex::ReadWriteMutex() : impl_(new ReadWriteMutex::impl()) {}
-
-void ReadWriteMutex::acquireRead() const { impl_->acquireRead(); }
-
-void ReadWriteMutex::acquireWrite() const { impl_->acquireWrite(); }
-
-bool ReadWriteMutex::attemptRead() const { return impl_->attemptRead(); }
-
-bool ReadWriteMutex::attemptWrite() const { return impl_->attemptWrite(); }
-
-void ReadWriteMutex::release() const { impl_->release(); }
-
-}}} // apache::thrift::concurrency
-

data/vendor/gems/thrift/lib/cpp/src/concurrency/Mutex.h

@@ -1,114 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you 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 _THRIFT_CONCURRENCY_MUTEX_H_
-#define _THRIFT_CONCURRENCY_MUTEX_H_ 1
-
-#include <boost/shared_ptr.hpp>
-
-namespace apache { namespace thrift { namespace concurrency {
-
-/**
- * A simple mutex class
- *
- * @version $Id:$
- */
-class Mutex {
- public:
-  typedef void (*Initializer)(void*);
-
-  Mutex(Initializer init = DEFAULT_INITIALIZER);
-  virtual ~Mutex() {}
-  virtual void lock() const;
-  virtual bool trylock() const;
-  virtual void unlock() const;
-
-  static void DEFAULT_INITIALIZER(void*);
-  static void ADAPTIVE_INITIALIZER(void*);
-  static void RECURSIVE_INITIALIZER(void*);
-
- private:
-
-  class impl;
-  boost::shared_ptr<impl> impl_;
-};
-
-class ReadWriteMutex {
-public:
-  ReadWriteMutex();
-  virtual ~ReadWriteMutex() {}
-
-  // these get the lock and block until it is done successfully
-  virtual void acquireRead() const;
-  virtual void acquireWrite() const;
-
-  // these attempt to get the lock, returning false immediately if they fail
-  virtual bool attemptRead() const;
-  virtual bool attemptWrite() const;
-
-  // this releases both read and write locks
-  virtual void release() const;
-
-private:
-
-  class impl;
-  boost::shared_ptr<impl> impl_;
-};
-
-class Guard {
- public:
-  Guard(const Mutex& value) : mutex_(value) {
-    mutex_.lock();
-  }
-  ~Guard() {
-    mutex_.unlock();
-  }
-
- private:
-  const Mutex& mutex_;
-};
-
-class RWGuard {
-  public:
-    RWGuard(const ReadWriteMutex& value, bool write = 0) : rw_mutex_(value) {
-      if (write) {
-        rw_mutex_.acquireWrite();
-      } else {
-        rw_mutex_.acquireRead();
-      }
-    }
-    ~RWGuard() {
-      rw_mutex_.release();
-    }
-  private:
-    const ReadWriteMutex& rw_mutex_;
-};
-
-
-// A little hack to prevent someone from trying to do "Guard(m);"
-// Such a use is invalid because the temporary Guard object is
-// destoryed at the end of the line, releasing the lock.
-// Sorry for polluting the global namespace, but I think it's worth it.
-#define Guard(m) incorrect_use_of_Guard(m)
-#define RWGuard(m) incorrect_use_of_RWGuard(m)
-
-
-}}} // apache::thrift::concurrency
-
-#endif // #ifndef _THRIFT_CONCURRENCY_MUTEX_H_