vim/YouCompleteMe
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Removing Concurrent* & Future classes

Browse Source 
They're not needed anymore.
This commit is contained in:
Strahinja Val Markovic 2013-10-01 10:01:01 -07:00
parent 46360219f8
commit 531e564a88
8 changed files with 1 additions and 254 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
cpp/ycm/ClangCompleter/ClangCompleter.h
View File

@ -18,7 +18,6 @@
#ifndef CLANGCOMPLETE_H_WLKDU0ZV #ifndef CLANGCOMPLETE_H_WLKDU0ZV
#define CLANGCOMPLETE_H_WLKDU0ZV #define CLANGCOMPLETE_H_WLKDU0ZV
#include "Future.h"
#include "UnsavedFile.h" #include "UnsavedFile.h"
#include "Diagnostic.h" #include "Diagnostic.h"
#include "TranslationUnitStore.h" #include "TranslationUnitStore.h"

3
cpp/ycm/ClangCompleter/CompilationDatabase.h
View File

@ -18,9 +18,6 @@
#ifndef COMPILATIONDATABASE_H_ZT7MQXPG #ifndef COMPILATIONDATABASE_H_ZT7MQXPG
#define COMPILATIONDATABASE_H_ZT7MQXPG #define COMPILATIONDATABASE_H_ZT7MQXPG
#include "Future.h"
#include "ConcurrentStack.h"
#include <vector> #include <vector>
#include <string> #include <string>
#include <boost/utility.hpp> #include <boost/utility.hpp>

1
cpp/ycm/ClangCompleter/TranslationUnit.h
View File

@ -18,7 +18,6 @@
#ifndef TRANSLATIONUNIT_H_XQ7I6SVA #ifndef TRANSLATIONUNIT_H_XQ7I6SVA
#define TRANSLATIONUNIT_H_XQ7I6SVA #define TRANSLATIONUNIT_H_XQ7I6SVA
#include "Future.h"
#include "UnsavedFile.h" #include "UnsavedFile.h"
#include "Diagnostic.h" #include "Diagnostic.h"
#include "Location.h" #include "Location.h"

1
cpp/ycm/ClangCompleter/TranslationUnitStore.cpp
View File

@ -21,6 +21,7 @@
#include "exceptions.h" #include "exceptions.h"
#include <boost/thread/locks.hpp> #include <boost/thread/locks.hpp>
#include <boost/make_shared.hpp>
#include <boost/functional/hash.hpp> #include <boost/functional/hash.hpp>
using boost::lock_guard; using boost::lock_guard;

79
cpp/ycm/ConcurrentLatestValue.h
View File

@ -1,79 +0,0 @@
// Copyright (C) 2011, 2012 Strahinja Val Markovic <val@markovic.io>
//
// This file is part of YouCompleteMe.
//
// YouCompleteMe is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// YouCompleteMe is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
#ifndef CONCURRENTLATESTVALUE_H_SYF1JPPG
#define CONCURRENTLATESTVALUE_H_SYF1JPPG
#include <boost/thread.hpp>
#include <boost/utility.hpp>
namespace YouCompleteMe {
// This is is basically a multi-consumer single-producer queue, only with the
// twist that we only care about the latest value set. So the GUI thread is the
// setter, and the worker threads are the workers. The workers wait in line on
// the condition variable and when the setter sets a value, a worker is chosen
// to consume it.
//
// The point is that we always want to have one "fresh" worker thread ready to
// work on our latest value. If a newer value is set, then we don't care what
// happens to the old values.
//
// This implementation is mutex-based and is not lock-free. Normally using a
// lock-free data structure makes more sense, but since the GUI thread goes
// through VimL and Python on every keystroke, there's really no point. Those 5
// nanoseconds it takes to lock a mutex are laughably negligible compared to the
// VimL/Python overhead.
template <typename T>
class ConcurrentLatestValue : boost::noncopyable {
public:
ConcurrentLatestValue() : empty_( true ) {}
void Set( const T &data ) {
{
boost::unique_lock< boost::mutex > lock( mutex_ );
latest_ = data;
empty_ = false;
}
condition_variable_.notify_one();
}
T Get() {
boost::unique_lock< boost::mutex > lock( mutex_ );
while ( empty_ ) {
condition_variable_.wait( lock );
}
empty_ = true;
return latest_;
}
private:
T latest_;
bool empty_;
boost::mutex mutex_;
boost::condition_variable condition_variable_;
};
} // namespace YouCompleteMe
#endif /* end of include guard: CONCURRENTLATESTVALUE_H_SYF1JPPG */

89
cpp/ycm/ConcurrentStack.h
View File

@ -1,89 +0,0 @@
// Copyright (C) 2011, 2012 Strahinja Val Markovic <val@markovic.io>
//
// This file is part of YouCompleteMe.
//
// YouCompleteMe is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// YouCompleteMe is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
#ifndef CONCURRENTSTACK_H_TGI0GOR6
#define CONCURRENTSTACK_H_TGI0GOR6
#include <boost/thread.hpp>
#include <boost/utility.hpp>
#include <stack>
namespace YouCompleteMe {
template <typename T>
class ConcurrentStack : boost::noncopyable {
public:
void Push( const T &data ) {
{
boost::unique_lock< boost::mutex > lock( mutex_ );
stack_.push( data );
}
condition_variable_.notify_one();
}
T Pop() {
boost::unique_lock< boost::mutex > lock( mutex_ );
while ( stack_.empty() ) {
condition_variable_.wait( lock );
}
T top = stack_.top();
stack_.pop();
return top;
}
// Gets all the items from the stack and appends them to the input vector.
// Does not wait for the stack to get items; if the stack is empty, returns
// false and does not touch the input vector.
bool PopAllNoWait( std::vector< T > &items ) {
boost::unique_lock< boost::mutex > lock( mutex_ );
if ( stack_.empty() )
return false;
int num_items = stack_.size();
items.reserve( num_items + items.size() );
for ( int i = 0; i < num_items; ++i ) {
items.push_back( stack_.top() );
stack_.pop();
}
return true;
}
bool Empty() {
boost::unique_lock< boost::mutex > lock( mutex_ );
return stack_.empty();
}
private:
std::stack< T > stack_;
boost::mutex mutex_;
boost::condition_variable condition_variable_;
};
} // namespace YouCompleteMe
#endif /* end of include guard: CONCURRENTSTACK_H_TGI0GOR6 */

78
cpp/ycm/Future.h
View File

@ -1,78 +0,0 @@
// Copyright (C) 2011, 2012 Strahinja Val Markovic <val@markovic.io>
//
// This file is part of YouCompleteMe.
//
// YouCompleteMe is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// YouCompleteMe is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with YouCompleteMe. If not, see <http://www.gnu.org/licenses/>.
#ifndef FUTURE_H_NR1U6MZS
#define FUTURE_H_NR1U6MZS
#include <boost/thread.hpp>
#include <boost/make_shared.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
namespace YouCompleteMe {
class Result;
typedef boost::shared_ptr< boost::packaged_task< void > > VoidTask;
template< typename T >
boost::shared_ptr< T > ReturnValueAsShared(
boost::function< T() > func ) {
return boost::make_shared< T >( func() );
}
template< typename T >
class Future {
public:
Future() {};
Future( boost::shared_future< T > future )
: future_( boost::move( future ) ) {}
bool ResultsReady() {
// It's OK to return true since GetResults will just return a
// default-constructed value if the future_ is uninitialized. If we don't
// return true for this case, any loop waiting on ResultsReady will wait
// forever.
if ( future_.get_state() == boost::future_state::uninitialized )
return true;
return future_.is_ready();
}
void Wait() {
future_.wait();
}
T GetResults() {
try {
return future_.get();
} catch ( boost::future_uninitialized & ) {
// Do nothing and return a T()
}
return T();
}
private:
boost::shared_future< T > future_;
};
} // namespace YouCompleteMe
#endif /* end of include guard: FUTURE_H_NR1U6MZS */

3
cpp/ycm/IdentifierCompleter.h
View File

@ -18,10 +18,7 @@
#ifndef COMPLETER_H_7AR4UGXE #ifndef COMPLETER_H_7AR4UGXE
#define COMPLETER_H_7AR4UGXE #define COMPLETER_H_7AR4UGXE
#include "ConcurrentLatestValue.h"
#include "ConcurrentStack.h"
#include "IdentifierDatabase.h" #include "IdentifierDatabase.h"
#include "Future.h"
#include <boost/utility.hpp> #include <boost/utility.hpp>
#include <boost/unordered_map.hpp> #include <boost/unordered_map.hpp>