King_DuckZ/incredis
1
0
Fork 0
mirror of https://github.com/KingDuckZ/incredis synced 2024-11-27 00:43:50 +00:00
Code Issues Releases Wiki Activity

Replace string_ref with string_view.

Browse source
This commit is contained in:
King_DuckZ 2017-06-06 21:06:22 +01:00
parent 2c324ae647
commit ff802e975a
17 changed files with 103 additions and 104 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
include/incredis/arg_to_bin_safe.hpp
View file

@ -20,7 +20,7 @@
#include "duckhandy/compatibility.h" #include "duckhandy/compatibility.h"
#include <cstddef> #include <cstddef>
#include <boost/utility/string_ref.hpp> #include <boost/utility/string_view.hpp>
#include <string> #include <string>
namespace redis { namespace redis {
@ -45,8 +45,8 @@ namespace redis {
}; };
template<> template<>
struct MakeCharInfo<boost::string_ref> { struct MakeCharInfo<boost::string_view> {
MakeCharInfo ( const boost::string_ref& parData ) : m_data(parData.data()), m_size(parData.size()) {} MakeCharInfo ( const boost::string_view& parData ) : m_data(parData.data()), m_size(parData.size()) {}
const char* data ( void ) const { return m_data; } const char* data ( void ) const { return m_data; }
std::size_t size ( void ) const { return m_size; } std::size_t size ( void ) const { return m_size; }
@ -73,7 +73,7 @@ namespace redis {
std::size_t size ( void ) const { return m_data.size(); } std::size_t size ( void ) const { return m_data.size(); }
private: private:
boost::string_ref m_data; boost::string_view m_data;
}; };
template <typename T> template <typename T>

6
include/incredis/batch.hpp
View file

@ -75,12 +75,12 @@ namespace redis {
using implem::arg_to_bin_safe_char; using implem::arg_to_bin_safe_char;
using implem::arg_to_bin_safe_length; using implem::arg_to_bin_safe_length;
using implem::MakeCharInfo; using implem::MakeCharInfo;
using boost::string_ref; using boost::string_view;
this->run_pvt( this->run_pvt(
static_cast<int>(arg_count), static_cast<int>(arg_count),
CharPointerArray{ (arg_to_bin_safe_char(string_ref(parCommand))), MakeCharInfo<typename std::remove_const<typename std::remove_reference<Args>::type>::type>(std::forward<Args>(parArgs)).data()... }.data(), CharPointerArray{ (arg_to_bin_safe_char(string_view(parCommand))), MakeCharInfo<typename std::remove_const<typename std::remove_reference<Args>::type>::type>(std::forward<Args>(parArgs)).data()... }.data(),
LengthArray{ arg_to_bin_safe_length(string_ref(parCommand)), arg_to_bin_safe_length(std::forward<Args>(parArgs))... }.data() LengthArray{ arg_to_bin_safe_length(string_view(parCommand)), arg_to_bin_safe_length(std::forward<Args>(parArgs))... }.data()
); );
return *this; return *this;

4
include/incredis/command.hpp
View file

@ -28,7 +28,7 @@
#include <cassert> #include <cassert>
#include <vector> #include <vector>
#include <utility> #include <utility>
#include <boost/utility/string_ref.hpp> #include <boost/utility/string_view.hpp>
#include <boost/range/iterator_range_core.hpp> #include <boost/range/iterator_range_core.hpp>
#include <ciso646> #include <ciso646>
#include <stdexcept> #include <stdexcept>
@ -47,7 +47,7 @@ namespace redis {
void wait_for_disconnect ( void ); void wait_for_disconnect ( void );
bool is_connected ( void ) const; bool is_connected ( void ) const;
boost::string_ref connection_error ( void ) const; boost::string_view connection_error ( void ) const;
Batch make_batch ( void ); Batch make_batch ( void );
Script make_script ( const std::string& parScript ); Script make_script ( const std::string& parScript );

38
include/incredis/incredis.hpp
View file

@ -23,7 +23,7 @@
#include "scan_iterator.hpp" #include "scan_iterator.hpp"
#include <boost/optional.hpp> #include <boost/optional.hpp>
#include <string> #include <string>
#include <boost/utility/string_ref.hpp> #include <boost/utility/string_view.hpp>
#include <vector> #include <vector>
#include <boost/range/iterator_range_core.hpp> #include <boost/range/iterator_range_core.hpp>
#include <boost/range/empty.hpp> #include <boost/range/empty.hpp>
@ -61,26 +61,26 @@ namespace redis {
const Command& command ( void ) const { return m_command; } const Command& command ( void ) const { return m_command; }
//Scan //Scan
scan_range scan ( boost::string_ref parPattern=boost::string_ref() ); scan_range scan ( boost::string_view parPattern=boost::string_view() );
hscan_range hscan ( boost::string_ref parKey, boost::string_ref parPattern=boost::string_ref() ); hscan_range hscan ( boost::string_view parKey, boost::string_view parPattern=boost::string_view() );
sscan_range sscan ( boost::string_ref parKey, boost::string_ref parPattern=boost::string_ref() ); sscan_range sscan ( boost::string_view parKey, boost::string_view parPattern=boost::string_view() );
zscan_range zscan ( boost::string_ref parKey, boost::string_ref parPattern=boost::string_ref() ); zscan_range zscan ( boost::string_view parKey, boost::string_view parPattern=boost::string_view() );
//Hash //Hash
opt_string hget ( boost::string_ref parKey, boost::string_ref parField ); opt_string hget ( boost::string_view parKey, boost::string_view parField );
template <typename... Args> template <typename... Args>
opt_string_list hmget ( boost::string_ref parKey, Args&&... parArgs ); opt_string_list hmget ( boost::string_view parKey, Args&&... parArgs );
template <typename... Args> template <typename... Args>
bool hmset ( boost::string_ref parKey, Args&&... parArgs ); bool hmset ( boost::string_view parKey, Args&&... parArgs );
int hincrby ( boost::string_ref parKey, boost::string_ref parField, int parInc ); int hincrby ( boost::string_view parKey, boost::string_view parField, int parInc );
//Set //Set
opt_string_list srandmember ( boost::string_ref parKey, int parCount ); opt_string_list srandmember ( boost::string_view parKey, int parCount );
opt_string srandmember ( boost::string_ref parKey ); opt_string srandmember ( boost::string_view parKey );
opt_string_list smembers ( boost::string_ref parKey ); opt_string_list smembers ( boost::string_view parKey );
//Sorted set //Sorted set
opt_string_list zrangebyscore ( boost::string_ref parKey, double parMin, bool parMinIncl, double parMax, bool parMaxIncl, bool parWithScores ); opt_string_list zrangebyscore ( boost::string_view parKey, double parMin, bool parMinIncl, double parMax, bool parMaxIncl, bool parWithScores );
//Script //Script
bool script_flush ( void ); bool script_flush ( void );
@ -88,12 +88,12 @@ namespace redis {
//Misc //Misc
bool flushdb ( void ); bool flushdb ( void );
RedisInt dbsize ( void ); RedisInt dbsize ( void );
bool expire ( boost::string_ref parKey, RedisInt parTTL ); bool expire ( boost::string_view parKey, RedisInt parTTL );
//String //String
opt_string get ( boost::string_ref parKey ); opt_string get ( boost::string_view parKey );
bool set ( boost::string_ref parKey, boost::string_ref parField ); bool set ( boost::string_view parKey, boost::string_view parField );
RedisInt incr ( boost::string_ref parKey ); RedisInt incr ( boost::string_view parKey );
private: private:
static opt_string_list reply_to_string_list ( const Reply& parReply ); static opt_string_list reply_to_string_list ( const Reply& parReply );
@ -102,13 +102,13 @@ namespace redis {
}; };
template <typename... Args> template <typename... Args>
auto IncRedis::hmget (boost::string_ref parKey, Args&&... parArgs) -> opt_string_list { auto IncRedis::hmget (boost::string_view parKey, Args&&... parArgs) -> opt_string_list {
static_assert(sizeof...(Args) > 0, "No fields specified"); static_assert(sizeof...(Args) > 0, "No fields specified");
return reply_to_string_list(m_command.run("HMGET", parKey, std::forward<Args>(parArgs)...)); return reply_to_string_list(m_command.run("HMGET", parKey, std::forward<Args>(parArgs)...));
} }
template <typename... Args> template <typename... Args>
bool IncRedis::hmset (boost::string_ref parKey, Args&&... parArgs) { bool IncRedis::hmset (boost::string_view parKey, Args&&... parArgs) {
static_assert(sizeof...(Args) > 0, "No fields specified"); static_assert(sizeof...(Args) > 0, "No fields specified");
static_assert(sizeof...(Args) % 2 == 0, "Uneven number of parameters received"); static_assert(sizeof...(Args) % 2 == 0, "Uneven number of parameters received");
const auto ret = redis::get<StatusString>(m_command.run("HMSET", parKey, std::forward<Args>(parArgs)...)); const auto ret = redis::get<StatusString>(m_command.run("HMSET", parKey, std::forward<Args>(parArgs)...));

36
include/incredis/incredis_batch.hpp
View file

@ -20,7 +20,7 @@
#include "batch.hpp" #include "batch.hpp"
#include "duckhandy/sequence_bt.hpp" #include "duckhandy/sequence_bt.hpp"
#include <boost/utility/string_ref.hpp> #include <boost/utility/string_view.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <type_traits> #include <type_traits>
@ -54,33 +54,33 @@ namespace redis {
//Misc //Misc
IncRedisBatch& select ( int parIndex ); IncRedisBatch& select ( int parIndex );
IncRedisBatch& client_setname ( boost::string_ref parName ); IncRedisBatch& client_setname ( boost::string_view parName );
template <typename... Args> template <typename... Args>
IncRedisBatch& del ( Args&&... parArgs ); IncRedisBatch& del ( Args&&... parArgs );
//String //String
IncRedisBatch& set ( boost::string_ref parKey, boost::string_ref parField, ADD_Mode parMode ); IncRedisBatch& set ( boost::string_view parKey, boost::string_view parField, ADD_Mode parMode );
template <typename... Args> template <typename... Args>
IncRedisBatch& set ( boost::string_ref parKey, boost::string_ref parField, ADD_Mode parMode, Args&&... parArgs ); IncRedisBatch& set ( boost::string_view parKey, boost::string_view parField, ADD_Mode parMode, Args&&... parArgs );
//Hash //Hash
IncRedisBatch& hget ( boost::string_ref parKey, boost::string_ref parField ); IncRedisBatch& hget ( boost::string_view parKey, boost::string_view parField );
template <typename... Args> template <typename... Args>
IncRedisBatch& hmget ( boost::string_ref parKey, Args&&... parArgs ); IncRedisBatch& hmget ( boost::string_view parKey, Args&&... parArgs );
template <typename... Args> template <typename... Args>
IncRedisBatch& hmset ( boost::string_ref parKey, Args&&... parArgs ); IncRedisBatch& hmset ( boost::string_view parKey, Args&&... parArgs );
IncRedisBatch& hincrby ( boost::string_ref parKey, boost::string_ref parField, int parInc ); IncRedisBatch& hincrby ( boost::string_view parKey, boost::string_view parField, int parInc );
//Set //Set
IncRedisBatch& srandmember ( boost::string_ref parKey, int parCount ); IncRedisBatch& srandmember ( boost::string_view parKey, int parCount );
IncRedisBatch& srandmember ( boost::string_ref parKey ); IncRedisBatch& srandmember ( boost::string_view parKey );
template <typename... Args> template <typename... Args>
IncRedisBatch& sadd ( boost::string_ref parKey, Args&&... parArgs ); IncRedisBatch& sadd ( boost::string_view parKey, Args&&... parArgs );
//Sorted set //Sorted set
template <typename... Args> template <typename... Args>
IncRedisBatch& zadd ( boost::string_ref parKey, ZADD_Mode parMode, bool parChange, Args&&... parArgs ); IncRedisBatch& zadd ( boost::string_view parKey, ZADD_Mode parMode, bool parChange, Args&&... parArgs );
IncRedisBatch& zrangebyscore ( boost::string_ref parKey, double parMin, bool parMinIncl, double parMax, bool parMaxIncl, bool parWithScores ); IncRedisBatch& zrangebyscore ( boost::string_view parKey, double parMin, bool parMinIncl, double parMax, bool parMaxIncl, bool parWithScores );
//Script //Script
IncRedisBatch& script_flush ( void ); IncRedisBatch& script_flush ( void );
@ -95,14 +95,14 @@ namespace redis {
} //namespace implem } //namespace implem
template <typename... Args> template <typename... Args>
IncRedisBatch& IncRedisBatch::hmget (boost::string_ref parKey, Args&&... parArgs) { IncRedisBatch& IncRedisBatch::hmget (boost::string_view parKey, Args&&... parArgs) {
static_assert(sizeof...(Args) > 0, "No fields specified"); static_assert(sizeof...(Args) > 0, "No fields specified");
m_batch.run("HMGET", parKey, std::forward<Args>(parArgs)...); m_batch.run("HMGET", parKey, std::forward<Args>(parArgs)...);
return *this; return *this;
} }
template <typename... Args> template <typename... Args>
IncRedisBatch& IncRedisBatch::hmset (boost::string_ref parKey, Args&&... parArgs) { IncRedisBatch& IncRedisBatch::hmset (boost::string_view parKey, Args&&... parArgs) {
static_assert(sizeof...(Args) >= 1, "No parameters specified"); static_assert(sizeof...(Args) >= 1, "No parameters specified");
static_assert(sizeof...(Args) % 2 == 0, "Uneven number of parameters received"); static_assert(sizeof...(Args) % 2 == 0, "Uneven number of parameters received");
m_batch.run("HMSET", parKey, std::forward<Args>(parArgs)...); m_batch.run("HMSET", parKey, std::forward<Args>(parArgs)...);
@ -110,7 +110,7 @@ namespace redis {
} }
template <typename... Args> template <typename... Args>
IncRedisBatch& IncRedisBatch::sadd (boost::string_ref parKey, Args&&... parArgs) { IncRedisBatch& IncRedisBatch::sadd (boost::string_view parKey, Args&&... parArgs) {
static_assert(sizeof...(Args) > 0, "No members specified"); static_assert(sizeof...(Args) > 0, "No members specified");
m_batch.run("SADD", parKey, std::forward<Args>(parArgs)...); m_batch.run("SADD", parKey, std::forward<Args>(parArgs)...);
return *this; return *this;
@ -124,7 +124,7 @@ namespace redis {
} }
template <typename... Args> template <typename... Args>
IncRedisBatch& IncRedisBatch::zadd (boost::string_ref parKey, ZADD_Mode parMode, bool parChange, Args&&... parArgs) { IncRedisBatch& IncRedisBatch::zadd (boost::string_view parKey, ZADD_Mode parMode, bool parChange, Args&&... parArgs) {
static_assert(sizeof...(Args) >= 1, "No score/value pairs specified"); static_assert(sizeof...(Args) >= 1, "No score/value pairs specified");
static_assert(sizeof...(Args) % 2 == 0, "Uneven number of parameters received"); static_assert(sizeof...(Args) % 2 == 0, "Uneven number of parameters received");
@ -150,7 +150,7 @@ namespace redis {
} }
template <typename... Args> template <typename... Args>
IncRedisBatch& IncRedisBatch::set (boost::string_ref parKey, boost::string_ref parField, ADD_Mode parMode, Args&&... parArgs) { IncRedisBatch& IncRedisBatch::set (boost::string_view parKey, boost::string_view parField, ADD_Mode parMode, Args&&... parArgs) {
using dhandy::bt::index_range; using dhandy::bt::index_range;
switch(parMode) { switch(parMode) {

24
include/incredis/scan_iterator.hpp
View file

@ -25,7 +25,7 @@
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <cstddef> #include <cstddef>
#include <boost/utility/string_ref.hpp> #include <boost/utility/string_view.hpp>
namespace redis { namespace redis {
template <typename ValueFetch> template <typename ValueFetch>
@ -40,18 +40,18 @@ namespace redis {
class ScanIteratorBaseClass { class ScanIteratorBaseClass {
protected: protected:
explicit ScanIteratorBaseClass ( Command* parCommand ); explicit ScanIteratorBaseClass ( Command* parCommand );
ScanIteratorBaseClass ( Command* parCommand, boost::string_ref parMatchPattern ); ScanIteratorBaseClass ( Command* parCommand, boost::string_view parMatchPattern );
~ScanIteratorBaseClass ( void ) noexcept = default; ~ScanIteratorBaseClass ( void ) noexcept = default;
bool is_connected ( void ) const; bool is_connected ( void ) const;
Reply run ( const char* parCommand, RedisInt parScanContext, std::size_t parCount ); Reply run ( const char* parCommand, RedisInt parScanContext, std::size_t parCount );
Reply run ( const char* parCommand, const boost::string_ref& parParameter, RedisInt parScanContext, std::size_t parCount ); Reply run ( const char* parCommand, const boost::string_view& parParameter, RedisInt parScanContext, std::size_t parCount );
bool is_equal ( const ScanIteratorBaseClass& parOther ) const { return m_command == parOther.m_command; } bool is_equal ( const ScanIteratorBaseClass& parOther ) const { return m_command == parOther.m_command; }
private: private:
Command* m_command; Command* m_command;
boost::string_ref m_match_pattern; boost::string_view m_match_pattern;
}; };
} //namespace implem } //namespace implem
@ -72,9 +72,9 @@ namespace redis {
typedef typename base_iterator::iterator_category iterator_category; typedef typename base_iterator::iterator_category iterator_category;
template <typename Dummy=ValueFetch, typename=typename std::enable_if<not HasScanTargetMethod<Dummy>::value>::type> template <typename Dummy=ValueFetch, typename=typename std::enable_if<not HasScanTargetMethod<Dummy>::value>::type>
ScanIterator ( Command* parCommand, bool parEnd, boost::string_ref parMatchPattern=boost::string_ref() ); ScanIterator ( Command* parCommand, bool parEnd, boost::string_view parMatchPattern=boost::string_view() );
template <typename Dummy=ValueFetch, typename=typename std::enable_if<HasScanTargetMethod<Dummy>::value>::type> template <typename Dummy=ValueFetch, typename=typename std::enable_if<HasScanTargetMethod<Dummy>::value>::type>
ScanIterator ( Command* parCommand, boost::string_ref parKey, bool parEnd, boost::string_ref parMatchPattern=boost::string_ref() ); ScanIterator ( Command* parCommand, boost::string_view parKey, bool parEnd, boost::string_view parMatchPattern=boost::string_view() );
private: private:
template <typename T> template <typename T>
@ -107,17 +107,17 @@ namespace redis {
struct ScanSingleValuesInKey { struct ScanSingleValuesInKey {
typedef T value_type; typedef T value_type;
explicit ScanSingleValuesInKey ( boost::string_ref parScanTarget ) : m_scan_target(parScanTarget) {} explicit ScanSingleValuesInKey ( boost::string_view parScanTarget ) : m_scan_target(parScanTarget) {}
static constexpr const char* command ( void ) { return "SSCAN"; } static constexpr const char* command ( void ) { return "SSCAN"; }
static constexpr const std::size_t step = 1; static constexpr const std::size_t step = 1;
static constexpr const std::size_t work_count = 10; static constexpr const std::size_t work_count = 10;
static const T& make_value ( const Reply* parItem ); static const T& make_value ( const Reply* parItem );
boost::string_ref scan_target ( void ) const { return m_scan_target; } boost::string_view scan_target ( void ) const { return m_scan_target; }
private: private:
boost::string_ref m_scan_target; boost::string_view m_scan_target;
}; };
template <typename P, char Command, typename A=decltype(P().first), typename B=decltype(P().second)> template <typename P, char Command, typename A=decltype(P().first), typename B=decltype(P().second)>
@ -125,17 +125,17 @@ namespace redis {
static_assert(Command == ScanCommands::HSCAN or Command == ScanCommands::ZSCAN, "Invalid scan command chosen"); static_assert(Command == ScanCommands::HSCAN or Command == ScanCommands::ZSCAN, "Invalid scan command chosen");
typedef P value_type; typedef P value_type;
explicit ScanPairs ( boost::string_ref parScanTarget ) : m_scan_target(parScanTarget) {} explicit ScanPairs ( boost::string_view parScanTarget ) : m_scan_target(parScanTarget) {}
static constexpr const char* command ( void ) { return ScanCommands::_from_integral(Command)._to_string(); } static constexpr const char* command ( void ) { return ScanCommands::_from_integral(Command)._to_string(); }
static constexpr const std::size_t step = 2; static constexpr const std::size_t step = 2;
static constexpr const std::size_t work_count = 10; static constexpr const std::size_t work_count = 10;
static value_type make_value ( const Reply* parItem ); static value_type make_value ( const Reply* parItem );
boost::string_ref scan_target ( void ) const { return m_scan_target; } boost::string_view scan_target ( void ) const { return m_scan_target; }
private: private:
boost::string_ref m_scan_target; boost::string_view m_scan_target;
}; };
} //namespace redis } //namespace redis

4
include/incredis/scan_iterator.inl
View file

@ -25,7 +25,7 @@ namespace redis {
template <typename ValueFetch> template <typename ValueFetch>
template <typename Dummy, typename> template <typename Dummy, typename>
ScanIterator<ValueFetch>::ScanIterator (Command* parCommand, bool parEnd, boost::string_ref parMatchPattern) : ScanIterator<ValueFetch>::ScanIterator (Command* parCommand, bool parEnd, boost::string_view parMatchPattern) :
implem::ScanIteratorBaseClass(parCommand, parMatchPattern), implem::ScanIteratorBaseClass(parCommand, parMatchPattern),
implem::ScanIteratorBaseIterator<ValueFetch>(), implem::ScanIteratorBaseIterator<ValueFetch>(),
ValueFetch(), ValueFetch(),
@ -45,7 +45,7 @@ namespace redis {
template <typename ValueFetch> template <typename ValueFetch>
template <typename Dummy, typename> template <typename Dummy, typename>
ScanIterator<ValueFetch>::ScanIterator (Command* parCommand, boost::string_ref parKey, bool parEnd, boost::string_ref parMatchPattern) : ScanIterator<ValueFetch>::ScanIterator (Command* parCommand, boost::string_view parKey, bool parEnd, boost::string_view parMatchPattern) :
implem::ScanIteratorBaseClass(parCommand, parMatchPattern), implem::ScanIteratorBaseClass(parCommand, parMatchPattern),
implem::ScanIteratorBaseIterator<ValueFetch>(), implem::ScanIteratorBaseIterator<ValueFetch>(),
ValueFetch(parKey), ValueFetch(parKey),

6
include/incredis/script.hpp
View file

@ -21,7 +21,7 @@
#include "batch.hpp" #include "batch.hpp"
#include "duckhandy/lexical_cast.hpp" #include "duckhandy/lexical_cast.hpp"
#include "duckhandy/sequence_bt.hpp" #include "duckhandy/sequence_bt.hpp"
#include <boost/utility/string_ref.hpp> #include <boost/utility/string_view.hpp>
#include <tuple> #include <tuple>
#include <cassert> #include <cassert>
#include <ciso646> #include <ciso646>
@ -33,7 +33,7 @@ namespace redis {
public: public:
Script ( void ); Script ( void );
Script ( Script&& ) = default; Script ( Script&& ) = default;
Script ( boost::string_ref parSha1, ScriptManager& parManager ); Script ( boost::string_view parSha1, ScriptManager& parManager );
~Script ( void ) noexcept = default; ~Script ( void ) noexcept = default;
template <typename... Keys, typename... Values> template <typename... Keys, typename... Values>
@ -45,7 +45,7 @@ namespace redis {
template <typename... Keys, typename... Values, std::size_t... KeyIndices, std::size_t... ValueIndices> template <typename... Keys, typename... Values, std::size_t... KeyIndices, std::size_t... ValueIndices>
void run_with_indices ( Batch& parBatch, const std::tuple<Keys...>& parKeys, const std::tuple<Values...>& parValues, dhandy::bt::index_seq<KeyIndices...>, dhandy::bt::index_seq<ValueIndices...> ); void run_with_indices ( Batch& parBatch, const std::tuple<Keys...>& parKeys, const std::tuple<Values...>& parValues, dhandy::bt::index_seq<KeyIndices...>, dhandy::bt::index_seq<ValueIndices...> );
boost::string_ref m_sha1; boost::string_view m_sha1;
ScriptManager* m_manager; ScriptManager* m_manager;
}; };

9
include/incredis/script_manager.hpp
View file

@ -22,7 +22,7 @@
#if defined(WITH_CRYPTOPP) #if defined(WITH_CRYPTOPP)
# define MAKE_SHA1_WITH_CRYPTOPP # define MAKE_SHA1_WITH_CRYPTOPP
#endif #endif
#include <boost/utility/string_ref.hpp> #include <boost/utility/string_view.hpp>
#if defined(MAKE_SHA1_WITH_CRYPTOPP) #if defined(MAKE_SHA1_WITH_CRYPTOPP)
# include <set> # include <set>
#else #else
@ -30,7 +30,6 @@
#endif #endif
#include <string> #include <string>
#include <array> #include <array>
#include <boost/utility/string_ref.hpp>
namespace redis { namespace redis {
class Command; class Command;
@ -39,12 +38,12 @@ namespace redis {
public: public:
explicit ScriptManager ( Command* parCommand ); explicit ScriptManager ( Command* parCommand );
boost::string_ref submit_lua_script ( const std::string& parScript ); boost::string_view submit_lua_script ( const std::string& parScript );
private: private:
using Sha1Array = std::array<char, 40>; using Sha1Array = std::array<char, 40>;
boost::string_ref add_lua_script_ifn ( const std::string& parScript ); boost::string_view add_lua_script_ifn ( const std::string& parScript );
Command* const m_command; Command* const m_command;
#if defined(MAKE_SHA1_WITH_CRYPTOPP) #if defined(MAKE_SHA1_WITH_CRYPTOPP)
@ -54,7 +53,7 @@ namespace redis {
#endif #endif
}; };
inline boost::string_ref ScriptManager::submit_lua_script (const std::string& parScript) { inline boost::string_view ScriptManager::submit_lua_script (const std::string& parScript) {
return add_lua_script_ifn(parScript); return add_lua_script_ifn(parScript);
} }
} //namespace redis } //namespace redis

2
src/async_connection.cpp
View file

@ -199,7 +199,7 @@ namespace redis {
return connected; return connected;
} }
boost::string_ref AsyncConnection::connection_error() const { boost::string_view AsyncConnection::connection_error() const {
return m_local_data->connect_err_msg; return m_local_data->connect_err_msg;
} }

4
src/async_connection.hpp
View file

@ -21,7 +21,7 @@
#include <memory> #include <memory>
#include <string> #include <string>
#include <cstdint> #include <cstdint>
#include <boost/utility/string_ref.hpp> #include <boost/utility/string_view.hpp>
struct redisAsyncContext; struct redisAsyncContext;
struct ev_loop; struct ev_loop;
@ -44,7 +44,7 @@ namespace redis {
void wait_for_disconnect ( void ); void wait_for_disconnect ( void );
bool is_connected ( void ) const; bool is_connected ( void ) const;
boost::string_ref connection_error ( void ) const; boost::string_view connection_error ( void ) const;
void wakeup_event_thread ( void ); void wakeup_event_thread ( void );
std::mutex& event_mutex ( void ); std::mutex& event_mutex ( void );
redisAsyncContext* connection ( void ); redisAsyncContext* connection ( void );

2
src/command.cpp
View file

@ -77,7 +77,7 @@ namespace redis {
return m_local_data->async_connection.is_connected(); return m_local_data->async_connection.is_connected();
} }
boost::string_ref Command::connection_error() const { boost::string_view Command::connection_error() const {
return m_local_data->async_connection.connection_error(); return m_local_data->async_connection.connection_error();
} }

28
src/incredis.cpp
View file

@ -81,45 +81,45 @@ namespace redis {
return m_command.make_batch(); return m_command.make_batch();
} }
auto IncRedis::scan (boost::string_ref parPattern) -> scan_range { auto IncRedis::scan (boost::string_view parPattern) -> scan_range {
return scan_range(scan_iterator(&m_command, false, parPattern), scan_iterator(&m_command, true)); return scan_range(scan_iterator(&m_command, false, parPattern), scan_iterator(&m_command, true));
} }
auto IncRedis::hscan (boost::string_ref parKey, boost::string_ref parPattern) -> hscan_range { auto IncRedis::hscan (boost::string_view parKey, boost::string_view parPattern) -> hscan_range {
return hscan_range(hscan_iterator(&m_command, parKey, false, parPattern), hscan_iterator(&m_command, parKey, true)); return hscan_range(hscan_iterator(&m_command, parKey, false, parPattern), hscan_iterator(&m_command, parKey, true));
} }
auto IncRedis::sscan (boost::string_ref parKey, boost::string_ref parPattern) -> sscan_range { auto IncRedis::sscan (boost::string_view parKey, boost::string_view parPattern) -> sscan_range {
return sscan_range(sscan_iterator(&m_command, parKey, false, parPattern), sscan_iterator(&m_command, parKey, true)); return sscan_range(sscan_iterator(&m_command, parKey, false, parPattern), sscan_iterator(&m_command, parKey, true));
} }
auto IncRedis::zscan (boost::string_ref parKey, boost::string_ref parPattern) -> zscan_range { auto IncRedis::zscan (boost::string_view parKey, boost::string_view parPattern) -> zscan_range {
return zscan_range(zscan_iterator(&m_command, parKey, false, parPattern), zscan_iterator(&m_command, parKey, true)); return zscan_range(zscan_iterator(&m_command, parKey, false, parPattern), zscan_iterator(&m_command, parKey, true));
} }
auto IncRedis::hget (boost::string_ref parKey, boost::string_ref parField) -> opt_string { auto IncRedis::hget (boost::string_view parKey, boost::string_view parField) -> opt_string {
return optional_string(m_command.run("HGET", parKey, parField)); return optional_string(m_command.run("HGET", parKey, parField));
} }
int IncRedis::hincrby (boost::string_ref parKey, boost::string_ref parField, int parInc) { int IncRedis::hincrby (boost::string_view parKey, boost::string_view parField, int parInc) {
const auto inc = dhandy::lexical_cast<std::string>(parInc); const auto inc = dhandy::lexical_cast<std::string>(parInc);
auto reply = m_command.run("HINCRBY", parKey, parField, inc); auto reply = m_command.run("HINCRBY", parKey, parField, inc);
return get_integer(reply); return get_integer(reply);
} }
auto IncRedis::srandmember (boost::string_ref parKey, int parCount) -> opt_string_list { auto IncRedis::srandmember (boost::string_view parKey, int parCount) -> opt_string_list {
return optional_string_list(m_command.run("SRANDMEMBER", parKey, dhandy::lexical_cast<std::string>(parCount))); return optional_string_list(m_command.run("SRANDMEMBER", parKey, dhandy::lexical_cast<std::string>(parCount)));
} }
auto IncRedis::srandmember (boost::string_ref parKey) -> opt_string { auto IncRedis::srandmember (boost::string_view parKey) -> opt_string {
return optional_string(m_command.run("SRANDMEMBER", parKey)); return optional_string(m_command.run("SRANDMEMBER", parKey));
} }
auto IncRedis::smembers (boost::string_ref parKey) -> opt_string_list { auto IncRedis::smembers (boost::string_view parKey) -> opt_string_list {
return optional_string_list(m_command.run("SMEMBERS", parKey)); return optional_string_list(m_command.run("SMEMBERS", parKey));
} }
auto IncRedis::zrangebyscore (boost::string_ref parKey, double parMin, bool parMinIncl, double parMax, bool parMaxIncl, bool parWithScores) -> opt_string_list { auto IncRedis::zrangebyscore (boost::string_view parKey, double parMin, bool parMinIncl, double parMax, bool parMaxIncl, bool parWithScores) -> opt_string_list {
auto batch = make_batch(); auto batch = make_batch();
batch.zrangebyscore(parKey, parMin, parMinIncl, parMax, parMaxIncl, parWithScores); batch.zrangebyscore(parKey, parMin, parMinIncl, parMax, parMaxIncl, parWithScores);
assert(batch.replies().size() == 1); assert(batch.replies().size() == 1);
@ -141,7 +141,7 @@ namespace redis {
return ret; return ret;
} }
bool IncRedis::expire (boost::string_ref parKey, RedisInt parTTL) { bool IncRedis::expire (boost::string_view parKey, RedisInt parTTL) {
const auto ret = redis::get<RedisInt>(m_command.run("EXPIRE", parKey, dhandy::lexical_cast<std::string>(parTTL))); const auto ret = redis::get<RedisInt>(m_command.run("EXPIRE", parKey, dhandy::lexical_cast<std::string>(parTTL)));
return (ret == 1 ? true : false); return (ret == 1 ? true : false);
} }
@ -150,11 +150,11 @@ namespace redis {
return optional_string_list(parReply); return optional_string_list(parReply);
} }
auto IncRedis::get (boost::string_ref parKey) -> opt_string { auto IncRedis::get (boost::string_view parKey) -> opt_string {
return optional_string(m_command.run("GET", parKey)); return optional_string(m_command.run("GET", parKey));
} }
bool IncRedis::set (boost::string_ref parKey, boost::string_ref parField) { bool IncRedis::set (boost::string_view parKey, boost::string_view parField) {
auto batch = make_batch(); auto batch = make_batch();
batch.set(parKey, parField, IncRedisBatch::ADD_None); batch.set(parKey, parField, IncRedisBatch::ADD_None);
assert(batch.replies().size() == 1); assert(batch.replies().size() == 1);
@ -162,7 +162,7 @@ namespace redis {
return ret.is_ok(); return ret.is_ok();
} }
RedisInt IncRedis::incr (boost::string_ref parKey) { RedisInt IncRedis::incr (boost::string_view parKey) {
const auto ret = redis::get<RedisInt>(m_command.run("INCR", parKey)); const auto ret = redis::get<RedisInt>(m_command.run("INCR", parKey));
return ret; return ret;
} }

14
src/incredis_batch.cpp
View file

@ -49,32 +49,32 @@ namespace redis {
return *this; return *this;
} }
IncRedisBatch& IncRedisBatch::client_setname (boost::string_ref parName) { IncRedisBatch& IncRedisBatch::client_setname (boost::string_view parName) {
m_batch.run("CLIENT", "SETNAME", parName); m_batch.run("CLIENT", "SETNAME", parName);
return *this; return *this;
} }
IncRedisBatch& IncRedisBatch::hget (boost::string_ref parKey, boost::string_ref parField) { IncRedisBatch& IncRedisBatch::hget (boost::string_view parKey, boost::string_view parField) {
m_batch.run("HGET", parKey, parField); m_batch.run("HGET", parKey, parField);
return *this; return *this;
} }
IncRedisBatch& IncRedisBatch::hincrby (boost::string_ref parKey, boost::string_ref parField, int parInc) { IncRedisBatch& IncRedisBatch::hincrby (boost::string_view parKey, boost::string_view parField, int parInc) {
m_batch.run("HINCRBY", parKey, parField, dhandy::lexical_cast<std::string>(parInc)); m_batch.run("HINCRBY", parKey, parField, dhandy::lexical_cast<std::string>(parInc));
return *this; return *this;
} }
IncRedisBatch& IncRedisBatch::srandmember (boost::string_ref parKey, int parCount) { IncRedisBatch& IncRedisBatch::srandmember (boost::string_view parKey, int parCount) {
m_batch.run("SRANDMEMBER", parKey, dhandy::lexical_cast<std::string>(parCount)); m_batch.run("SRANDMEMBER", parKey, dhandy::lexical_cast<std::string>(parCount));
return *this; return *this;
} }
IncRedisBatch& IncRedisBatch::srandmember (boost::string_ref parKey) { IncRedisBatch& IncRedisBatch::srandmember (boost::string_view parKey) {
m_batch.run("SRANDMEMBER", parKey); m_batch.run("SRANDMEMBER", parKey);
return *this; return *this;
} }
IncRedisBatch& IncRedisBatch::set (boost::string_ref parKey, boost::string_ref parField, ADD_Mode parMode) { IncRedisBatch& IncRedisBatch::set (boost::string_view parKey, boost::string_view parField, ADD_Mode parMode) {
switch(parMode) { switch(parMode) {
case ADD_None: case ADD_None:
m_batch.run("SET", parKey, parField); m_batch.run("SET", parKey, parField);
@ -89,7 +89,7 @@ namespace redis {
return *this; return *this;
} }
IncRedisBatch& IncRedisBatch::zrangebyscore (boost::string_ref parKey, double parMin, bool parMinIncl, double parMax, bool parMaxIncl, bool parWithScores) { IncRedisBatch& IncRedisBatch::zrangebyscore (boost::string_view parKey, double parMin, bool parMinIncl, double parMax, bool parMaxIncl, bool parWithScores) {
auto lower_bound = make_boundary(parMin, not parMinIncl); auto lower_bound = make_boundary(parMin, not parMinIncl);
auto upper_bound = make_boundary(parMax, not parMaxIncl); auto upper_bound = make_boundary(parMax, not parMaxIncl);

6
src/scan_iterator.cpp
View file

@ -25,11 +25,11 @@
namespace redis { namespace redis {
namespace implem { namespace implem {
ScanIteratorBaseClass::ScanIteratorBaseClass (Command* parCommand) : ScanIteratorBaseClass::ScanIteratorBaseClass (Command* parCommand) :
ScanIteratorBaseClass(parCommand, boost::string_ref()) ScanIteratorBaseClass(parCommand, boost::string_view())
{ {
} }
ScanIteratorBaseClass::ScanIteratorBaseClass (Command* parCommand, boost::string_ref parMatchPattern) : ScanIteratorBaseClass::ScanIteratorBaseClass (Command* parCommand, boost::string_view parMatchPattern) :
m_command(parCommand), m_command(parCommand),
m_match_pattern(parMatchPattern) m_match_pattern(parMatchPattern)
{ {
@ -50,7 +50,7 @@ namespace redis {
return m_command->run(parCommand, scan_context, "MATCH", m_match_pattern, "COUNT", count_hint); return m_command->run(parCommand, scan_context, "MATCH", m_match_pattern, "COUNT", count_hint);
} }
Reply ScanIteratorBaseClass::run (const char* parCommand, const boost::string_ref& parParameter, RedisInt parScanContext, std::size_t parCount) { Reply ScanIteratorBaseClass::run (const char* parCommand, const boost::string_view& parParameter, RedisInt parScanContext, std::size_t parCount) {
const auto scan_context = dhandy::lexical_cast<std::string>(parScanContext); const auto scan_context = dhandy::lexical_cast<std::string>(parScanContext);
const auto count_hint = dhandy::lexical_cast<std::string>(parCount); const auto count_hint = dhandy::lexical_cast<std::string>(parCount);
if (m_match_pattern.empty()) if (m_match_pattern.empty())

2
src/script.cpp
View file

@ -24,7 +24,7 @@ namespace redis {
{ {
} }
Script::Script (boost::string_ref parSha1, ScriptManager& parManager) : Script::Script (boost::string_view parSha1, ScriptManager& parManager) :
m_sha1(parSha1), m_sha1(parSha1),
m_manager(&parManager) m_manager(&parManager)
{ {

14
src/script_manager.cpp
View file

@ -45,11 +45,11 @@ namespace redis {
} }
#if defined(MAKE_SHA1_WITH_CRYPTOPP) #if defined(MAKE_SHA1_WITH_CRYPTOPP)
boost::string_ref ScriptManager::add_lua_script_ifn (const std::string& parScript) { boost::string_view ScriptManager::add_lua_script_ifn (const std::string& parScript) {
assert(m_command->is_connected()); assert(m_command->is_connected());
if (parScript.empty()) if (parScript.empty())
return boost::string_ref(); return boost::string_view();
using dhandy::lexical_cast; using dhandy::lexical_cast;
@ -75,7 +75,7 @@ namespace redis {
auto it_found = m_known_hashes.find(sha1_array); auto it_found = m_known_hashes.find(sha1_array);
const bool was_present = (m_known_hashes.end() != it_found); const bool was_present = (m_known_hashes.end() != it_found);
if (was_present) { if (was_present) {
return boost::string_ref(it_found->data(), it_found->size()); return boost::string_view(it_found->data(), it_found->size());
} }
auto reply = m_command->run("SCRIPT", "LOAD", parScript); auto reply = m_command->run("SCRIPT", "LOAD", parScript);
@ -85,16 +85,16 @@ namespace redis {
const auto it_inserted = m_known_hashes.insert(it_found, sha1_array); const auto it_inserted = m_known_hashes.insert(it_found, sha1_array);
(void)reply; (void)reply;
return boost::string_ref(it_inserted->data(), it_inserted->size()); return boost::string_view(it_inserted->data(), it_inserted->size());
} }
#else #else
boost::string_ref ScriptManager::add_lua_script_ifn (const std::string& parScript) { boost::string_view ScriptManager::add_lua_script_ifn (const std::string& parScript) {
assert(m_command->is_connected()); assert(m_command->is_connected());
auto it_found = m_known_scripts.find(parScript); auto it_found = m_known_scripts.find(parScript);
const bool was_present = (m_known_scripts.end() != it_found); const bool was_present = (m_known_scripts.end() != it_found);
if (was_present) { if (was_present) {
return boost::string_ref(it_found->second.data(), it_found->second.size()); return boost::string_view(it_found->second.data(), it_found->second.size());
} }
auto reply = m_command->run("SCRIPT", "LOAD", parScript); auto reply = m_command->run("SCRIPT", "LOAD", parScript);
@ -105,7 +105,7 @@ namespace redis {
std::copy(sha1_str.begin(), sha1_str.end(), sha1_array.begin()); std::copy(sha1_str.begin(), sha1_str.end(), sha1_array.begin());
auto it_inserted = m_known_scripts.insert(it_found, std::make_pair(parScript, sha1_array)); auto it_inserted = m_known_scripts.insert(it_found, std::make_pair(parScript, sha1_array));
return boost::string_ref(it_inserted->second.data(), it_inserted->second.size()); return boost::string_view(it_inserted->second.data(), it_inserted->second.size());
} }
#endif #endif
} //namespace redis } //namespace redis