SYMBOL INDEX (1581 symbols across 123 files)

FILE: cassandra-protocol/src/authenticators.rs
  type SaslAuthenticator (line 15) | pub trait SaslAuthenticator {
    method initial_response (line 16) | fn initial_response(&self) -> CBytes;
    method evaluate_challenge (line 18) | fn evaluate_challenge(&self, challenge: CBytes) -> Result<CBytes>;
    method handle_success (line 20) | fn handle_success(&self, data: CBytes) -> Result<()>;
    method initial_response (line 46) | fn initial_response(&self) -> CBytes {
    method evaluate_challenge (line 55) | fn evaluate_challenge(&self, _challenge: CBytes) -> Result<CBytes> {
    method handle_success (line 59) | fn handle_success(&self, _data: CBytes) -> Result<()> {
    method initial_response (line 97) | fn initial_response(&self) -> CBytes {
    method evaluate_challenge (line 101) | fn evaluate_challenge(&self, _challenge: CBytes) -> Result<CBytes> {
    method handle_success (line 105) | fn handle_success(&self, _data: CBytes) -> Result<()> {
  type SaslAuthenticatorProvider (line 24) | pub trait SaslAuthenticatorProvider {
    method name (line 25) | fn name(&self) -> Option<&str>;
    method create_authenticator (line 27) | fn create_authenticator(&self) -> Box<dyn SaslAuthenticator + Send>;
    method name (line 72) | fn name(&self) -> Option<&str> {
    method create_authenticator (line 76) | fn create_authenticator(&self) -> Box<dyn SaslAuthenticator + Send> {
    method name (line 115) | fn name(&self) -> Option<&str> {
    method create_authenticator (line 119) | fn create_authenticator(&self) -> Box<dyn SaslAuthenticator + Send> {
  type StaticPasswordAuthenticator (line 31) | pub struct StaticPasswordAuthenticator {
    method new (line 37) | pub fn new<S: ToString>(username: S, password: S) -> StaticPasswordAut...
  type StaticPasswordAuthenticatorProvider (line 66) | pub struct StaticPasswordAuthenticatorProvider {
    method new (line 85) | pub fn new<S: ToString>(username: S, password: S) -> Self {
  type NoneAuthenticator (line 94) | pub struct NoneAuthenticator;
  type NoneAuthenticatorProvider (line 112) | pub struct NoneAuthenticatorProvider;
  function test_static_password_authenticator_new (line 129) | fn test_static_password_authenticator_new() {
  function test_static_password_authenticator_cassandra_name (line 134) | fn test_static_password_authenticator_cassandra_name() {
  function test_authenticator_none_cassandra_name (line 143) | fn test_authenticator_none_cassandra_name() {

FILE: cassandra-protocol/src/compression.rs
  type Result (line 18) | type Result<T> = result::Result<T, CompressionError>;
  constant LZ4 (line 20) | pub const LZ4: &str = "lz4";
  constant SNAPPY (line 21) | pub const SNAPPY: &str = "snappy";
  type CompressionError (line 26) | pub enum CompressionError {
    method fmt (line 34) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  method source (line 43) | fn source(&self) -> Option<&(dyn Error + 'static)> {
  method clone (line 52) | fn clone(&self) -> Self {
  type Compression (line 68) | pub enum Compression {
    method encode (line 91) | pub fn encode(&self, bytes: &[u8]) -> Result<Vec<u8>> {
    method is_compressed (line 101) | pub fn is_compressed(self) -> bool {
    method decode (line 106) | pub fn decode(&self, bytes: Vec<u8>) -> Result<Vec<u8>> {
    method as_str (line 115) | pub fn as_str(&self) -> Option<&'static str> {
    method encode_snappy (line 123) | fn encode_snappy(bytes: &[u8]) -> Result<Vec<u8>> {
    method decode_snappy (line 130) | fn decode_snappy(bytes: Vec<u8>) -> Result<Vec<u8>> {
    method encode_lz4 (line 137) | fn encode_lz4(bytes: &[u8]) -> Result<Vec<u8>> {
    method decode_lz4 (line 153) | fn decode_lz4(bytes: Vec<u8>) -> Result<Vec<u8>> {
    method from (line 188) | fn from(compression_string: String) -> Compression {
    method to_protocol_string (line 196) | pub fn to_protocol_string(self) -> String {
    method from_protocol_string (line 204) | pub fn from_protocol_string(protocol_string: &str) -> std::result::Res...
    method from (line 217) | fn from(compression_str: &'a str) -> Compression {
  function test_compression_to_protocol_string (line 231) | fn test_compression_to_protocol_string() {
  function test_compression_from_protocol_str (line 243) | fn test_compression_from_protocol_str() {
  function test_compression_from_string (line 282) | fn test_compression_from_string() {
  function test_compression_encode_snappy (line 292) | fn test_compression_encode_snappy() {
  function test_compression_decode_snappy (line 301) | fn test_compression_decode_snappy() {
  function test_compression_encode_lz4 (line 309) | fn test_compression_encode_lz4() {
  function test_compression_decode_lz4 (line 318) | fn test_compression_decode_lz4() {
  function test_compression_encode_none (line 326) | fn test_compression_encode_none() {
  function test_compression_decode_none (line 335) | fn test_compression_decode_none() {
  function test_compression_decode_lz4_with_invalid_input (line 343) | fn test_compression_decode_lz4_with_invalid_input() {
  function test_compression_decode_lz4_short_input_is_error_not_panic (line 350) | fn test_compression_decode_lz4_short_input_is_error_not_panic() {
  function test_compression_decode_lz4_negative_size_is_error_not_oom (line 360) | fn test_compression_decode_lz4_negative_size_is_error_not_oom() {
  function test_compression_encode_snappy_with_non_utf8 (line 371) | fn test_compression_encode_snappy_with_non_utf8() {

FILE: cassandra-protocol/src/consistency.rs
  type Consistency (line 17) | pub enum Consistency {
    type Error (line 112) | type Error = error::Error;
    method try_from (line 114) | fn try_from(value: CIntShort) -> Result<Self, Self::Error> {
    method is_dc_local (line 167) | pub fn is_dc_local(self) -> bool {
  type Err (line 78) | type Err = error::Error;
  method from_str (line 80) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method serialize (line 105) | fn serialize(&self, cursor: &mut io::Cursor<&mut Vec<u8>>, version: Vers...
  method from (line 133) | fn from(value: Consistency) -> Self {
  method from_bytes (line 151) | fn from_bytes(bytes: &[u8]) -> error::Result<Consistency> {
  method from_cursor (line 159) | fn from_cursor(cursor: &mut io::Cursor<&[u8]>, version: Version) -> erro...
  function test_consistency_serialize (line 182) | fn test_consistency_serialize() {
  function test_consistency_from (line 209) | fn test_consistency_from() {
  function test_consistency_from_bytes (line 224) | fn test_consistency_from_bytes() {
  function test_consistency_from_cursor (line 261) | fn test_consistency_from_cursor() {

FILE: cassandra-protocol/src/crc.rs
  constant CRC24_POLY (line 3) | const CRC24_POLY: i32 = 0x1974f0b;
  constant CRC24_INIT (line 4) | const CRC24_INIT: i32 = 0x875060;
  function crc24 (line 7) | pub fn crc24(bytes: &[u8]) -> i32 {
  function crc32 (line 23) | pub fn crc32(bytes: &[u8]) -> u32 {

FILE: cassandra-protocol/src/error.rs
  type Result (line 14) | pub type Result<T> = result::Result<T, Error>;
  type Error (line 23) | pub enum Error {
    method from (line 105) | fn from(err: String) -> Error {
    method from (line 111) | fn from(err: &str) -> Error {
  function column_is_empty_err (line 100) | pub fn column_is_empty_err<T: Display>(column_name: T) -> Error {
  method clone (line 117) | fn clone(&self) -> Self {

FILE: cassandra-protocol/src/events.rs
  type ServerEvent (line 7) | pub type ServerEvent = MessageServerEvent;
  type SimpleServerEvent (line 11) | pub type SimpleServerEvent = MessageSimpleServerEvent;
  type SchemaChange (line 14) | pub type SchemaChange = MessageSchemaChange;

FILE: cassandra-protocol/src/frame.rs
  constant ENVELOPE_HEADER_LEN (line 17) | const ENVELOPE_HEADER_LEN: usize = 9;
  constant STREAM_LEN (line 19) | pub const STREAM_LEN: usize = 2;
  constant LENGTH_LEN (line 21) | pub const LENGTH_LEN: usize = 4;
  constant EVENT_STREAM_ID (line 48) | pub const EVENT_STREAM_ID: i16 = -1;
  function const_max (line 50) | const fn const_max(a: usize, b: usize) -> usize {
  constant PAYLOAD_SIZE_LIMIT (line 59) | pub const PAYLOAD_SIZE_LIMIT: usize = 1 << 17;
  constant UNCOMPRESSED_FRAME_HEADER_LENGTH (line 61) | const UNCOMPRESSED_FRAME_HEADER_LENGTH: usize = 6;
  constant COMPRESSED_FRAME_HEADER_LENGTH (line 62) | const COMPRESSED_FRAME_HEADER_LENGTH: usize = 8;
  constant FRAME_TRAILER_LENGTH (line 63) | const FRAME_TRAILER_LENGTH: usize = 4;
  constant MAX_FRAME_SIZE (line 66) | pub const MAX_FRAME_SIZE: usize = PAYLOAD_SIZE_LIMIT
  type StreamId (line 74) | pub type StreamId = i16;
  type ParsedEnvelope (line 77) | pub struct ParsedEnvelope {
  type Envelope (line 86) | pub struct Envelope {
    method new (line 101) | pub fn new(
    method request_body (line 124) | pub fn request_body(&self) -> error::Result<RequestBody> {
    method response_body (line 129) | pub fn response_body(&self) -> error::Result<ResponseBody> {
    method tracing_id (line 134) | pub fn tracing_id(&self) -> &Option<Uuid> {
    method warnings (line 139) | pub fn warnings(&self) -> &[String] {
    method from_buffer (line 149) | pub fn from_buffer(
    method check_envelope_size (line 221) | pub fn check_envelope_size(data: &[u8]) -> Result<usize, CheckEnvelope...
    method encode_with (line 237) | pub fn encode_with(&self, compressor: Compression) -> error::Result<Ve...
  type CheckEnvelopeSizeError (line 317) | pub enum CheckEnvelopeSizeError {
  type ParseEnvelopeError (line 328) | pub enum ParseEnvelopeError {
  type Version (line 348) | pub enum Version {
    type Error (line 365) | type Error = error::Error;
    method try_from (line 367) | fn try_from(version: u8) -> Result<Self, Self::Error> {
    constant BYTE_LENGTH (line 381) | pub const BYTE_LENGTH: usize = 1;
  function from (line 355) | fn from(value: Version) -> Self {
  type Direction (line 385) | pub enum Direction {
    method from (line 400) | fn from(value: u8) -> Self {
  function from (line 391) | fn from(value: Direction) -> u8 {
  method default (line 422) | fn default() -> Self {
  constant BYTE_LENGTH (line 429) | pub const BYTE_LENGTH: usize = 1;
  type Opcode (line 434) | pub enum Opcode {
    constant BYTE_LENGTH (line 455) | pub const BYTE_LENGTH: usize = 1;
    type Error (line 482) | type Error = error::Error;
    method try_from (line 484) | fn try_from(value: u8) -> Result<Self, <Opcode as TryFrom<u8>>::Error> {
  function from (line 459) | fn from(value: Opcode) -> Self {
  function test_encode_decode_roundtrip_response (line 511) | pub fn test_encode_decode_roundtrip_response(
  function test_encode_decode_roundtrip_request (line 542) | pub fn test_encode_decode_roundtrip_request(
  function test_encode_decode_roundtrip_nondeterministic_request (line 574) | pub fn test_encode_decode_roundtrip_nondeterministic_request(
  function test_frame_version_as_byte (line 608) | fn test_frame_version_as_byte() {
  function test_frame_version_from (line 618) | fn test_frame_version_from() {
  function test_opcode_as_byte (line 635) | fn test_opcode_as_byte() {
  function test_opcode_from (line 655) | fn test_opcode_from() {
  function test_ready (line 675) | fn test_ready() {
  function test_query_minimal (line 692) | fn test_query_minimal() {
  function test_query_simple_values (line 724) | fn test_query_simple_values() {
  function test_query_named_values (line 763) | fn test_query_named_values() {
  function test_result_prepared_statement (line 800) | fn test_result_prepared_statement() {
  function create_small_envelope_data (line 910) | fn create_small_envelope_data() -> (Envelope, Vec<u8>) {
  function create_large_envelope_data (line 932) | fn create_large_envelope_data() -> (Envelope, Vec<u8>) {
  function should_encode_and_decode_legacy_frames (line 953) | fn should_encode_and_decode_legacy_frames() {
  function should_encode_and_decode_uncompressed_self_contained_frames (line 976) | fn should_encode_and_decode_uncompressed_self_contained_frames() {
  function should_encode_and_decode_uncompressed_non_self_contained_frames (line 1004) | fn should_encode_and_decode_uncompressed_non_self_contained_frames() {
  function should_encode_and_decode_compressed_self_contained_frames (line 1040) | fn should_encode_and_decode_compressed_self_contained_frames() {
  function should_encode_and_decode_compressed_non_self_contained_frames (line 1068) | fn should_encode_and_decode_compressed_non_self_contained_frames() {
  function test_tracing_id_request (line 1113) | fn test_tracing_id_request() {
  function test_tracing_id_response (line 1151) | fn test_tracing_id_response() {
  function test_warnings_response (line 1180) | fn test_warnings_response() {

FILE: cassandra-protocol/src/frame/events.rs
  constant TOPOLOGY_CHANGE (line 12) | const TOPOLOGY_CHANGE: &str = "TOPOLOGY_CHANGE";
  constant STATUS_CHANGE (line 13) | const STATUS_CHANGE: &str = "STATUS_CHANGE";
  constant SCHEMA_CHANGE (line 14) | const SCHEMA_CHANGE: &str = "SCHEMA_CHANGE";
  constant NEW_NODE (line 17) | const NEW_NODE: &str = "NEW_NODE";
  constant REMOVED_NODE (line 18) | const REMOVED_NODE: &str = "REMOVED_NODE";
  constant UP (line 21) | const UP: &str = "UP";
  constant DOWN (line 22) | const DOWN: &str = "DOWN";
  constant CREATED (line 25) | const CREATED: &str = "CREATED";
  constant UPDATED (line 26) | const UPDATED: &str = "UPDATED";
  constant DROPPED (line 27) | const DROPPED: &str = "DROPPED";
  constant KEYSPACE (line 30) | const KEYSPACE: &str = "KEYSPACE";
  constant TABLE (line 31) | const TABLE: &str = "TABLE";
  constant TYPE (line 32) | const TYPE: &str = "TYPE";
  constant FUNCTION (line 33) | const FUNCTION: &str = "FUNCTION";
  constant AGGREGATE (line 34) | const AGGREGATE: &str = "AGGREGATE";
  type SimpleServerEvent (line 41) | pub enum SimpleServerEvent {
    method as_str (line 48) | pub fn as_str(&self) -> &'static str {
    method from (line 58) | fn from(event: ServerEvent) -> SimpleServerEvent {
    method from (line 68) | fn from(event: &'a ServerEvent) -> SimpleServerEvent {
    type Error (line 78) | type Error = error::Error;
    method try_from (line 80) | fn try_from(value: &str) -> Result<Self, Self::Error> {
    method eq (line 91) | fn eq(&self, full_event: &ServerEvent) -> bool {
  type ServerEvent (line 99) | pub enum ServerEvent {
    method eq (line 128) | fn eq(&self, event: &SimpleServerEvent) -> bool {
  method serialize (line 109) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 134) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type TopologyChange (line 153) | pub struct TopologyChange {
  method serialize (line 160) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 167) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type TopologyChangeType (line 177) | pub enum TopologyChangeType {
  method serialize (line 183) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 192) | fn from_cursor(
  type StatusChange (line 206) | pub struct StatusChange {
  method serialize (line 213) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 220) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type StatusChangeType (line 230) | pub enum StatusChangeType {
  method serialize (line 236) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 245) | fn from_cursor(
  type SchemaChange (line 259) | pub struct SchemaChange {
  method serialize (line 266) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 274) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type SchemaChangeType (line 290) | pub enum SchemaChangeType {
  method serialize (line 297) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 307) | fn from_cursor(
  type SchemaChangeTarget (line 323) | pub enum SchemaChangeTarget {
  method serialize (line 332) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 344) | fn from_cursor(
  type SchemaChangeOptions (line 362) | pub enum SchemaChangeOptions {
    method from_cursor_and_target (line 397) | fn from_cursor_and_target(
    method from_cursor_keyspace (line 412) | fn from_cursor_keyspace(cursor: &mut Cursor<&[u8]>) -> error::Result<S...
    method from_cursor_table_type (line 418) | fn from_cursor_table_type(cursor: &mut Cursor<&[u8]>) -> error::Result...
    method from_cursor_function_aggregate (line 424) | fn from_cursor_function_aggregate(
  method serialize (line 375) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  function test_encode_decode (line 437) | fn test_encode_decode(bytes: &[u8], expected: ServerEvent) {
  function from_cursor (line 455) | fn from_cursor() {
  function serialize (line 472) | fn serialize() {
  function from_cursor_wrong (line 494) | fn from_cursor_wrong() {
  function from_cursor (line 508) | fn from_cursor() {
  function serialize (line 525) | fn serialize() {
  function from_cursor_wrong (line 546) | fn from_cursor_wrong() {
  function from_cursor (line 562) | fn from_cursor() {
  function serialize (line 586) | fn serialize() {
  function from_cursor_wrong (line 616) | fn from_cursor_wrong() {
  function schema_change_target (line 631) | fn schema_change_target() {
  function serialize (line 671) | fn serialize() {
  function from_cursor_wrong (line 720) | fn from_cursor_wrong() {
  function topology_change_new_node (line 732) | fn topology_change_new_node() {
  function topology_change_removed_node (line 749) | fn topology_change_removed_node() {
  function status_change_up (line 767) | fn status_change_up() {
  function status_change_down (line 784) | fn status_change_down() {
  function schema_change_created (line 801) | fn schema_change_created() {
  function schema_change_updated (line 910) | fn schema_change_updated() {
  function schema_change_dropped (line 1018) | fn schema_change_dropped() {

FILE: cassandra-protocol/src/frame/frame_decoder.rs
  function create_unexpected_self_contained_error (line 13) | fn create_unexpected_self_contained_error() -> Error {
  function create_header_crc_mismatch_error (line 18) | fn create_header_crc_mismatch_error(computed_crc: i32, header_crc24: i32...
  function create_payload_crc_mismatch_error (line 23) | fn create_payload_crc_mismatch_error(computed_crc: u32, payload_crc32: u...
  function extract_envelopes (line 27) | fn extract_envelopes(buffer: &[u8], compression: Compression) -> Result<...
  function try_decode_envelopes_with_spare_data (line 45) | fn try_decode_envelopes_with_spare_data(
  function try_decode_envelopes_without_spare_data (line 53) | fn try_decode_envelopes_without_spare_data(buffer: &[u8]) -> Result<Vec<...
  type FrameDecoder (line 60) | pub trait FrameDecoder {
    method consume (line 64) | fn consume(&mut self, data: &mut Vec<u8>, compression: Compression) ->...
    method consume (line 82) | fn consume(&mut self, data: &mut Vec<u8>, compression: Compression) ->...
    method consume (line 112) | fn consume(&mut self, data: &mut Vec<u8>, _compression: Compression) -...
    method consume (line 191) | fn consume(&mut self, data: &mut Vec<u8>, _compression: Compression) -...
  type LegacyFrameDecoder (line 69) | pub struct LegacyFrameDecoder {
  method default (line 74) | fn default() -> Self {
  type Lz4FrameDecoder (line 105) | pub struct Lz4FrameDecoder {
    method try_decode_frame (line 118) | fn try_decode_frame(buffer: &mut Vec<u8>) -> Result<Option<(bool, Vec<...
  type UncompressedFrameDecoder (line 184) | pub struct UncompressedFrameDecoder {
    method try_decode_frame (line 197) | fn try_decode_frame(buffer: &mut Vec<u8>) -> Result<Option<(bool, Vec<...
  type GenericFrameDecoder (line 252) | struct GenericFrameDecoder {
    method extract_non_self_contained_envelopes (line 269) | fn extract_non_self_contained_envelopes(&mut self) -> Result<Vec<Envel...
    method extract_expected_payload_len (line 310) | fn extract_expected_payload_len(&self) -> Option<usize> {
    method handle_frame (line 318) | fn handle_frame(
    method consume (line 338) | fn consume(
  method default (line 259) | fn default() -> Self {
  function make_envelope (line 382) | fn make_envelope(stream_id: i16, fill: u8, body_size: usize) -> Vec<u8> {
  function encode_as_non_self_contained (line 400) | fn encode_as_non_self_contained(envelope: &[u8]) -> Vec<u8> {
  function decoder_recovers_two_consecutive_non_self_contained_envelopes (line 414) | fn decoder_recovers_two_consecutive_non_self_contained_envelopes() {
  function decoder_preserves_trailing_bytes_across_non_self_contained_frames (line 451) | fn decoder_preserves_trailing_bytes_across_non_self_contained_frames() {

FILE: cassandra-protocol/src/frame/frame_encoder.rs
  function put3b (line 10) | fn put3b(buffer: &mut [u8], value: i32) {
  function add_trailer (line 18) | fn add_trailer(buffer: &mut Vec<u8>, payload_start: usize) {
  type FrameEncoder (line 40) | pub trait FrameEncoder {
    method can_fit (line 42) | fn can_fit(&self, len: usize) -> bool;
    method reset (line 45) | fn reset(&mut self);
    method add_envelope (line 48) | fn add_envelope(&mut self, envelope: Vec<u8>);
    method finalize_self_contained (line 51) | fn finalize_self_contained(&mut self) -> &[u8];
    method finalize_non_self_contained (line 55) | fn finalize_non_self_contained(&mut self, envelope: &[u8]) -> (usize, ...
    method has_envelopes (line 58) | fn has_envelopes(&self) -> bool;
    method can_fit (line 69) | fn can_fit(&self, _len: usize) -> bool {
    method reset (line 75) | fn reset(&mut self) {
    method add_envelope (line 80) | fn add_envelope(&mut self, envelope: Vec<u8>) {
    method finalize_self_contained (line 85) | fn finalize_self_contained(&mut self) -> &[u8] {
    method finalize_non_self_contained (line 90) | fn finalize_non_self_contained(&mut self, envelope: &[u8]) -> (usize, ...
    method has_envelopes (line 102) | fn has_envelopes(&self) -> bool {
    method can_fit (line 115) | fn can_fit(&self, len: usize) -> bool {
    method reset (line 121) | fn reset(&mut self) {
    method add_envelope (line 126) | fn add_envelope(&mut self, mut envelope: Vec<u8>) {
    method finalize_self_contained (line 130) | fn finalize_self_contained(&mut self) -> &[u8] {
    method finalize_non_self_contained (line 137) | fn finalize_non_self_contained(&mut self, envelope: &[u8]) -> (usize, ...
    method has_envelopes (line 150) | fn has_envelopes(&self) -> bool {
    method can_fit (line 190) | fn can_fit(&self, len: usize) -> bool {
    method reset (line 199) | fn reset(&mut self) {
    method add_envelope (line 204) | fn add_envelope(&mut self, mut envelope: Vec<u8>) {
    method finalize_self_contained (line 208) | fn finalize_self_contained(&mut self) -> &[u8] {
    method finalize_non_self_contained (line 221) | fn finalize_non_self_contained(&mut self, envelope: &[u8]) -> (usize, ...
    method has_envelopes (line 259) | fn has_envelopes(&self) -> bool {
  type LegacyFrameEncoder (line 63) | pub struct LegacyFrameEncoder {
  type UncompressedFrameEncoder (line 109) | pub struct UncompressedFrameEncoder {
    method write_header (line 163) | fn write_header(&mut self, self_contained: bool) {
  method default (line 156) | fn default() -> Self {
  type Lz4FrameEncoder (line 184) | pub struct Lz4FrameEncoder {
    method write_header (line 272) | fn write_header(&mut self, uncompressed_size: usize, self_contained: b...
  method default (line 265) | fn default() -> Self {

FILE: cassandra-protocol/src/frame/message_auth_challenge.rs
  type BodyResAuthChallenge (line 9) | pub struct BodyResAuthChallenge {
  method serialize (line 14) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 20) | fn from_cursor(
  function body_res_auth_challenge_from_cursor (line 35) | fn body_res_auth_challenge_from_cursor() {

FILE: cassandra-protocol/src/frame/message_auth_response.rs
  type BodyReqAuthResponse (line 8) | pub struct BodyReqAuthResponse {
  method serialize (line 14) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 20) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  method new_req_auth_response (line 27) | pub fn new_req_auth_response(token_bytes: CBytes, version: Version) -> E...
  function body_req_auth_response (line 51) | fn body_req_auth_response() {
  function frame_body_req_auth_response (line 61) | fn frame_body_req_auth_response() {

FILE: cassandra-protocol/src/frame/message_auth_success.rs
  type BodyReqAuthSuccess (line 9) | pub struct BodyReqAuthSuccess {
  method serialize (line 14) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 20) | fn from_cursor(
  function body_req_auth_success (line 35) | fn body_req_auth_success() {

FILE: cassandra-protocol/src/frame/message_authenticate.rs
  type BodyResAuthenticate (line 9) | pub struct BodyResAuthenticate {
  method serialize (line 14) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 20) | fn from_cursor(
  function body_res_authenticate (line 38) | fn body_res_authenticate() {

FILE: cassandra-protocol/src/frame/message_batch.rs
  type BodyReqBatch (line 16) | pub struct BodyReqBatch {
  method serialize (line 27) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 80) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type BatchType (line 134) | pub enum BatchType {
    type Error (line 146) | type Error = Error;
    method try_from (line 148) | fn try_from(value: u8) -> Result<Self, Self::Error> {
  function from (line 159) | fn from(value: BatchType) -> Self {
  type BatchQuerySubj (line 170) | pub enum BatchQuerySubj {
  type BatchQuery (line 177) | pub struct BatchQuery {
  method serialize (line 189) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 209) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  method new_req_batch (line 235) | pub fn new_req_batch(query: BodyReqBatch, flags: Flags, version: Version...
  function should_deserialize_query (line 263) | fn should_deserialize_query() {
  function should_deserialize_body (line 273) | fn should_deserialize_body() {
  function should_support_keyspace (line 286) | fn should_support_keyspace() {
  function should_support_now_in_seconds (line 305) | fn should_support_now_in_seconds() {

FILE: cassandra-protocol/src/frame/message_error.rs
  type ErrorBody (line 18) | pub struct ErrorBody {
    method is_bad_protocol (line 46) | pub fn is_bad_protocol(&self) -> bool {
  method serialize (line 26) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 34) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type FailureInfo (line 60) | pub enum FailureInfo {
  method serialize (line 68) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 85) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type ErrorType (line 108) | pub enum ErrorType {
    method from_cursor_with_code (line 148) | pub fn from_cursor_with_code(
    method to_error_code (line 180) | pub fn to_error_code(&self) -> CInt {
  method serialize (line 130) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  type UnavailableError (line 207) | pub struct UnavailableError {
  method serialize (line 217) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 225) | fn from_cursor(
  type WriteTimeoutError (line 243) | pub struct WriteTimeoutError {
  method serialize (line 258) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 271) | fn from_cursor(
  type ReadTimeoutError (line 297) | pub struct ReadTimeoutError {
    method replica_has_responded (line 319) | pub fn replica_has_responded(&self) -> bool {
  method serialize (line 308) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 325) | fn from_cursor(
  type ReadFailureError (line 349) | pub struct ReadFailureError {
    method replica_has_responded (line 374) | pub fn replica_has_responded(&self) -> bool {
  method serialize (line 362) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 380) | fn from_cursor(
  type FunctionFailureError (line 406) | pub struct FunctionFailureError {
  method serialize (line 416) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 424) | fn from_cursor(
  type WriteFailureError (line 442) | pub struct WriteFailureError {
  method serialize (line 456) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 466) | fn from_cursor(
  type WriteType (line 490) | pub enum WriteType {
  method serialize (line 516) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 532) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> error::...
  type AlreadyExistsError (line 550) | pub struct AlreadyExistsError {
  method serialize (line 559) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 566) | fn from_cursor(
  type UnpreparedError (line 581) | pub struct UnpreparedError {
  method serialize (line 587) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 593) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  function test_encode_decode (line 601) | fn test_encode_decode(bytes: &[u8], expected: ErrorBody) {
  function server (line 621) | fn server() {
  function protocol (line 634) | fn protocol() {
  function authentication (line 647) | fn authentication() {
  function unavailable (line 660) | fn unavailable() {
  function overloaded (line 682) | fn overloaded() {
  function is_bootstrapping (line 695) | fn is_bootstrapping() {
  function truncate (line 708) | fn truncate() {
  function write_timeout (line 721) | fn write_timeout() {
  function read_timeout (line 746) | fn read_timeout() {
  function read_failure (line 770) | fn read_failure() {
  function syntax (line 796) | fn syntax() {
  function unauthorized (line 809) | fn unauthorized() {
  function invalid (line 822) | fn invalid() {
  function config (line 835) | fn config() {

FILE: cassandra-protocol/src/frame/message_event.rs
  type BodyResEvent (line 8) | pub struct BodyResEvent {
  method serialize (line 13) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 19) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  function body_res_event (line 33) | fn body_res_event() {

FILE: cassandra-protocol/src/frame/message_execute.rs
  type BodyReqExecute (line 10) | pub struct BodyReqExecute<'a> {
  method serialize (line 17) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method serialize_to_vec (line 28) | fn serialize_to_vec(&self, version: Version) -> Vec<u8> {
  type BodyReqExecuteOwned (line 44) | pub struct BodyReqExecuteOwned {
  method from_cursor (line 51) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  method serialize (line 71) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method new_req_execute (line 82) | pub fn new_req_execute(
  function should_deserialize_body (line 118) | fn should_deserialize_body() {
  function should_support_result_metadata_id (line 128) | fn should_support_result_metadata_id() {

FILE: cassandra-protocol/src/frame/message_options.rs
  type BodyReqOptions (line 7) | pub struct BodyReqOptions;
  method serialize (line 11) | fn serialize(&self, _cursor: &mut Cursor<&mut Vec<u8>>, _version: Versio...
  method from_cursor (line 16) | fn from_cursor(_cursor: &mut Cursor<&[u8]>, _version: Version) -> error:...
  method new_req_options (line 23) | pub fn new_req_options(version: Version) -> Envelope {
  function test_frame_options (line 46) | fn test_frame_options() {

FILE: cassandra-protocol/src/frame/message_prepare.rs
  type BodyReqPrepare (line 11) | pub struct BodyReqPrepare {
    method new (line 19) | pub fn new(query: String, keyspace: Option<String>) -> BodyReqPrepare {
  method serialize (line 26) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method serialize_to_vec (line 40) | fn serialize_to_vec(&self, version: Version) -> Vec<u8> {
  method from_cursor (line 62) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  method new_req_prepare (line 84) | pub fn new_req_prepare(
  function should_deserialize_body (line 114) | fn should_deserialize_body() {
  function should_support_keyspace (line 123) | fn should_support_keyspace() {

FILE: cassandra-protocol/src/frame/message_query.rs
  type BodyReqQuery (line 11) | pub struct BodyReqQuery {
    method new (line 20) | fn new(
  method from_cursor (line 50) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  method serialize (line 63) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method serialize_to_vec (line 69) | fn serialize_to_vec(&self, version: Version) -> Vec<u8> {
  method new_req_query (line 79) | pub fn new_req_query(
  method new_query (line 121) | pub fn new_query(query: BodyReqQuery, flags: Flags, version: Version) ->...

FILE: cassandra-protocol/src/frame/message_ready.rs
  type BodyResReady (line 6) | pub struct BodyResReady;
  method serialize (line 10) | fn serialize(&self, _cursor: &mut Cursor<&mut Vec<u8>>, _version: Versio...
  method from_cursor (line 15) | fn from_cursor(_cursor: &mut Cursor<&[u8]>, _version: Version) -> error:...
  function body_res_ready_new (line 25) | fn body_res_ready_new() {
  function body_res_ready_serialize (line 31) | fn body_res_ready_serialize() {

FILE: cassandra-protocol/src/frame/message_register.rs
  type BodyReqRegister (line 12) | pub struct BodyReqRegister {
  method serialize (line 17) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 24) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> error::...
  method new_req_register (line 36) | pub fn new_req_register(events: Vec<SimpleServerEvent>, version: Version...
  function should_deserialize_body (line 62) | fn should_deserialize_body() {

FILE: cassandra-protocol/src/frame/message_request.rs
  type RequestBody (line 17) | pub enum RequestBody {
    method try_from (line 44) | pub fn try_from(
  method serialize (line 29) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {

FILE: cassandra-protocol/src/frame/message_response.rs
  type ResponseBody (line 18) | pub enum ResponseBody {
    method try_from (line 63) | pub fn try_from(
    method into_rows (line 92) | pub fn into_rows(self) -> Option<Vec<Row>> {
    method as_rows_metadata (line 99) | pub fn as_rows_metadata(&self) -> Option<&RowsMetadata> {
    method as_cols (line 106) | pub fn as_cols(&self) -> Option<&BodyResResultRows> {
    method into_prepared (line 115) | pub fn into_prepared(self) -> Option<BodyResResultPrepared> {
    method into_set_keyspace (line 124) | pub fn into_set_keyspace(self) -> Option<BodyResResultSetKeyspace> {
    method into_server_event (line 132) | pub fn into_server_event(self) -> Option<BodyResEvent> {
    method authenticator (line 139) | pub fn authenticator(&self) -> Option<&str> {
    method into_error (line 146) | pub fn into_error(self) -> Option<ErrorBody> {
  method serialize (line 34) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {

FILE: cassandra-protocol/src/frame/message_result.rs
  type ResultKind (line 18) | pub enum ResultKind {
    type Error (line 59) | type Error = Error;
    method try_from (line 61) | fn try_from(value: CInt) -> Result<Self, Self::Error> {
  method serialize (line 33) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_bytes (line 39) | fn from_bytes(bytes: &[u8]) -> error::Result<ResultKind> {
  method from (line 47) | fn from(value: ResultKind) -> Self {
  method from_cursor (line 74) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> error::...
  type ResResultBody (line 87) | pub enum ResResultBody {
    method parse_body_from_cursor (line 129) | fn parse_body_from_cursor(
    method into_rows (line 152) | pub fn into_rows(self) -> Option<Vec<Row>> {
    method as_rows_metadata (line 160) | pub fn as_rows_metadata(&self) -> Option<&RowsMetadata> {
    method into_prepared (line 169) | pub fn into_prepared(self) -> Option<BodyResResultPrepared> {
    method into_set_keyspace (line 178) | pub fn into_set_keyspace(self) -> Option<BodyResResultSetKeyspace> {
    method from_cursor (line 187) | pub fn from_cursor(
  method serialize (line 103) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  type BodyResResultSetKeyspace (line 198) | pub struct BodyResResultSetKeyspace {
  method serialize (line 205) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 211) | fn from_cursor(
  type BodyResResultRows (line 222) | pub struct BodyResResultRows {
    method rows_content (line 246) | fn rows_content(
  method serialize (line 235) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 263) | fn from_cursor(
  type RowsMetadata (line 283) | pub struct RowsMetadata {
  method serialize (line 303) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 351) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  method serialize (line 408) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  function from (line 414) | fn from(value: RowsMetadataFlags) -> Self {
  method from_bytes (line 420) | fn from_bytes(bytes: &[u8]) -> error::Result<RowsMetadataFlags> {
  type TableSpec (line 430) | pub struct TableSpec {
  method serialize (line 437) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 444) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> error::...
  type ColSpec (line 456) | pub struct ColSpec {
    method parse_colspecs (line 479) | pub fn parse_colspecs(
  method serialize (line 468) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  type ColType (line 509) | pub enum ColType {
    type Error (line 539) | type Error = Error;
    method try_from (line 541) | fn try_from(value: CIntShort) -> Result<Self, Self::Error> {
  method from_bytes (line 576) | fn from_bytes(bytes: &[u8]) -> error::Result<ColType> {
  method serialize (line 585) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 619) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> error::...
  type ColTypeOption (line 630) | pub struct ColTypeOption {
  method serialize (line 639) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 648) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type ColTypeOptionValue (line 686) | pub enum ColTypeOptionValue {
  method serialize (line 698) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  type CUdt (line 716) | pub struct CUdt {
  method serialize (line 727) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 739) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type CTuple (line 765) | pub struct CTuple {
  method serialize (line 772) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 779) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  type BodyResResultPrepared (line 796) | pub struct BodyResResultPrepared {
    method from_cursor (line 823) | fn from_cursor(
  method serialize (line 810) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method serialize (line 855) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  type PreparedMetadata (line 862) | pub struct PreparedMetadata {
    method from_cursor (line 899) | fn from_cursor(
  method serialize (line 870) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  function extract_global_table_space (line 936) | fn extract_global_table_space(
  function test_encode_decode (line 950) | fn test_encode_decode(bytes: &[u8], expected: ResResultBody) {
  function cudt (line 971) | fn cudt() {
  function ctuple (line 1026) | fn ctuple() {
  function col_spec_with_table_spec (line 1059) | fn col_spec_with_table_spec() {
  function col_spec_without_table_spec (line 1097) | fn col_spec_without_table_spec() {
  function col_type_options_int (line 1133) | fn col_type_options_int() {
  function col_type_options_map (line 1155) | fn col_type_options_map() {
  function table_spec (line 1192) | fn table_spec() {
  function test_void (line 1222) | fn test_void() {
  function rows_metadata (line 1235) | fn rows_metadata() {
  function test_rows (line 1308) | fn test_rows() {
  function test_rows_no_metadata (line 1369) | fn test_rows_no_metadata() {
  function test_set_keyspace (line 1400) | fn test_set_keyspace() {
  function prepared_metadata (line 1420) | fn prepared_metadata() {
  function test_prepared (line 1492) | fn test_prepared() {
  function test_schema_change (line 1603) | fn test_schema_change() {

FILE: cassandra-protocol/src/frame/message_startup.rs
  constant CQL_VERSION (line 7) | const CQL_VERSION: &str = "CQL_VERSION";
  constant CQL_VERSION_VAL (line 8) | const CQL_VERSION_VAL: &str = "3.0.0";
  constant COMPRESSION (line 9) | const COMPRESSION: &str = "COMPRESSION";
  constant DRIVER_NAME (line 10) | const DRIVER_NAME: &str = "DRIVER_NAME";
  constant DRIVER_VERSION (line 11) | const DRIVER_VERSION: &str = "DRIVER_VERSION";
  type BodyReqStartup (line 14) | pub struct BodyReqStartup {
    method new (line 19) | pub fn new(compression: Option<String>, version: Version) -> BodyReqSt...
  method serialize (line 38) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 50) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...
  method new_req_startup (line 67) | pub fn new_req_startup(compression: Option<String>, version: Version) ->...
  function new_body_req_startup_some_compression (line 91) | fn new_body_req_startup_some_compression() {
  function new_body_req_startup_none_compression (line 106) | fn new_body_req_startup_none_compression() {
  function new_req_startup (line 116) | fn new_req_startup() {
  function body_req_startup_from_cursor (line 127) | fn body_req_startup_from_cursor() {

FILE: cassandra-protocol/src/frame/message_supported.rs
  type BodyResSupported (line 9) | pub struct BodyResSupported {
  method serialize (line 14) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 27) | fn from_cursor(
  function body_res_supported (line 54) | fn body_res_supported() {

FILE: cassandra-protocol/src/frame/traits.rs
  type Serialize (line 8) | pub trait Serialize {
    method serialize (line 10) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version);
    method serialize_to_vec (line 13) | fn serialize_to_vec(&self, version: Version) -> Vec<u8> {
    method serialize (line 52) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, _version: Versi...
    method serialize (line 59) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, _version: Versi...
    method serialize (line 66) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, _version: Versi...
    method serialize (line 73) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, _version: Versi...
  type FromBytes (line 22) | pub trait FromBytes {
    method from_bytes (line 24) | fn from_bytes(bytes: &[u8]) -> error::Result<Self>
  type FromCursor (line 31) | pub trait FromCursor {
    method from_cursor (line 33) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error:...
  type IntoQueryValues (line 39) | pub trait IntoQueryValues {
    method into_query_values (line 40) | fn into_query_values(self) -> query::QueryValues;
  type TryFromRow (line 43) | pub trait TryFromRow: Sized {
    method try_from_row (line 44) | fn try_from_row(row: crate::types::rows::Row) -> error::Result<Self>;
  type TryFromUdt (line 47) | pub trait TryFromUdt: Sized {
    method try_from_udt (line 48) | fn try_from_udt(udt: crate::types::udt::Udt) -> error::Result<Self>;

FILE: cassandra-protocol/src/lib.rs
  type Error (line 21) | pub type Error = error::Error;
  type Result (line 22) | pub type Result<T> = error::Result<T>;

FILE: cassandra-protocol/src/query/batch_query_builder.rs
  type QueryBatchPreparedStatement (line 11) | pub struct QueryBatchPreparedStatement {
  type QueryBatch (line 17) | pub struct QueryBatch {
  type BatchQueryBuilder (line 24) | pub struct BatchQueryBuilder {
    method new (line 51) | pub fn new() -> BatchQueryBuilder {
    method with_batch_type (line 56) | pub fn with_batch_type(mut self, batch_type: BatchType) -> Self {
    method add_query (line 63) | pub fn add_query<T: Into<String>>(mut self, query: T, values: QueryVal...
    method add_query_prepared (line 73) | pub fn add_query_prepared(mut self, query: &PreparedQuery, values: Que...
    method clear_queries (line 87) | pub fn clear_queries(mut self) -> Self {
    method with_consistency (line 93) | pub fn with_consistency(mut self, consistency: Consistency) -> Self {
    method with_serial_consistency (line 99) | pub fn with_serial_consistency(mut self, serial_consistency: Consisten...
    method with_timestamp (line 105) | pub fn with_timestamp(mut self, timestamp: CLong) -> Self {
    method with_keyspace (line 111) | pub fn with_keyspace(mut self, keyspace: String) -> Self {
    method with_now_in_seconds (line 117) | pub fn with_now_in_seconds(mut self, now_in_seconds: CInt) -> Self {
    method build (line 122) | pub fn build(self) -> CResult<QueryBatch> {
  method default (line 36) | fn default() -> Self {

FILE: cassandra-protocol/src/query/prepare_flags.rs
  method default (line 17) | fn default() -> Self {
  method serialize (line 24) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 30) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> Result<...

FILE: cassandra-protocol/src/query/prepared_query.rs
  type PreparedQuery (line 8) | pub struct PreparedQuery {
  method clone (line 17) | fn clone(&self) -> Self {
  method eq (line 30) | fn eq(&self, other: &Self) -> bool {
  method partial_cmp (line 39) | fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
  method cmp (line 46) | fn cmp(&self, other: &Self) -> Ordering {
  method hash (line 59) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: cassandra-protocol/src/query/query_flags.rs
  method default (line 34) | fn default() -> Self {
  method serialize (line 40) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 50) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> error::R...

FILE: cassandra-protocol/src/query/query_params.rs
  type QueryParams (line 15) | pub struct QueryParams {
    method flags (line 39) | fn flags(&self) -> QueryFlags {
  method serialize (line 79) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 124) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> Result<Q...

FILE: cassandra-protocol/src/query/query_params_builder.rs
  type QueryParamsBuilder (line 6) | pub struct QueryParamsBuilder {
    method new (line 21) | pub fn new() -> QueryParamsBuilder {
    method with_consistency (line 27) | pub fn with_consistency(mut self, consistency: Consistency) -> Self {
    method with_flags (line 34) | pub fn with_flags(mut self, flags: QueryFlags) -> Self {
    method with_values (line 41) | pub fn with_values(mut self, values: QueryValues) -> Self {
    method with_names (line 57) | pub fn with_names(mut self, with_names: bool) -> Self {
    method with_page_size (line 64) | pub fn with_page_size(mut self, size: CInt) -> Self {
    method with_paging_state (line 73) | pub fn with_paging_state(mut self, state: CBytes) -> Self {
    method with_serial_consistency (line 82) | pub fn with_serial_consistency(mut self, serial_consistency: Consisten...
    method with_timestamp (line 89) | pub fn with_timestamp(mut self, timestamp: CLong) -> Self {
    method with_keyspace (line 96) | pub fn with_keyspace(mut self, keyspace: String) -> Self {
    method with_now_in_seconds (line 103) | pub fn with_now_in_seconds(mut self, now_in_seconds: CInt) -> Self {
    method build (line 110) | pub fn build(self) -> QueryParams {

FILE: cassandra-protocol/src/query/query_values.rs
  type QueryValues (line 13) | pub enum QueryValues {
    method has_names (line 21) | pub fn has_names(&self) -> bool {
    method len (line 26) | pub fn len(&self) -> usize {
    method is_empty (line 34) | pub fn is_empty(&self) -> bool {
    method from (line 41) | fn from(values: Vec<T>) -> QueryValues {
    method from (line 49) | fn from(values: &[T]) -> QueryValues {
    method from (line 57) | fn from(values: HashMap<S, V>) -> QueryValues {
  method serialize (line 68) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {

FILE: cassandra-protocol/src/query/utils.rs
  function quote (line 3) | pub fn quote(text: &str) -> String {

FILE: cassandra-protocol/src/token.rs
  constant C1 (line 8) | const C1: Wrapping<i64> = Wrapping(0x87c3_7b91_1142_53d5_u64 as i64);
  constant C2 (line 9) | const C2: Wrapping<i64> = Wrapping(0x4cf5_ad43_2745_937f_u64 as i64);
  type Murmur3Token (line 13) | pub struct Murmur3Token {
    method generate (line 19) | pub fn generate(mut routing_key: &[u8]) -> Self {
    type Error (line 91) | type Error = Error;
    method try_from (line 93) | fn try_from(value: String) -> Result<Self, Self::Error> {
    method from (line 102) | fn from(value: i64) -> Self {
  function rotl64 (line 108) | fn rotl64(v: Wrapping<i64>, n: u32) -> Wrapping<i64> {
  function fmix (line 113) | fn fmix(mut k: Wrapping<i64>) -> Wrapping<i64> {
  function test_generate_murmur3_token (line 128) | fn test_generate_murmur3_token() {

FILE: cassandra-protocol/src/types.rs
  constant SHORT_LEN (line 12) | pub const SHORT_LEN: usize = 2;
  constant INT_LEN (line 13) | pub const INT_LEN: usize = 4;
  constant LONG_LEN (line 14) | pub const LONG_LEN: usize = 8;
  constant UUID_LEN (line 15) | pub const UUID_LEN: usize = 16;
  constant NULL_INT_LEN (line 17) | const NULL_INT_LEN: CInt = -1;
  constant NULL_SHORT_LEN (line 18) | const NULL_SHORT_LEN: CIntShort = -1;
  type AsCassandraType (line 50) | pub trait AsCassandraType {
    method as_cassandra_type (line 51) | fn as_cassandra_type(&self) -> CDRSResult<Option<CassandraType>>;
  type AsRustType (line 55) | pub trait AsRustType<T> {
    method as_rust_type (line 56) | fn as_rust_type(&self) -> CDRSResult<Option<T>>;
    method as_r_type (line 58) | fn as_r_type(&self) -> CDRSResult<T> {
  type AsRust (line 64) | pub trait AsRust {
    method as_rust (line 65) | fn as_rust<R>(&self) -> CDRSResult<Option<R>>
    method as_r_rust (line 72) | fn as_r_rust<T>(&self) -> CDRSResult<T>
  type IntoRustByName (line 82) | pub trait IntoRustByName<R> {
    method get_by_name (line 83) | fn get_by_name(&self, name: &str) -> CDRSResult<Option<R>>;
    method get_r_by_name (line 85) | fn get_r_by_name(&self, name: &str) -> CDRSResult<R> {
  type ByName (line 91) | pub trait ByName {
    method by_name (line 92) | fn by_name<R>(&self, name: &str) -> CDRSResult<Option<R>>
    method r_by_name (line 99) | fn r_by_name<R>(&self, name: &str) -> CDRSResult<R>
  type IntoRustByIndex (line 109) | pub trait IntoRustByIndex<R> {
    method get_by_index (line 110) | fn get_by_index(&self, index: usize) -> CDRSResult<Option<R>>;
    method get_r_by_index (line 112) | fn get_r_by_index(&self, index: usize) -> CDRSResult<R> {
  type ByIndex (line 118) | pub trait ByIndex {
    method by_index (line 119) | fn by_index<R>(&self, index: usize) -> CDRSResult<Option<R>>
    method r_by_index (line 126) | fn r_by_index<R>(&self, index: usize) -> CDRSResult<R>
  function convert_to_array (line 136) | fn convert_to_array<const S: usize>(bytes: &[u8]) -> Result<[u8; S], io:...
  function try_u64_from_bytes (line 143) | pub fn try_u64_from_bytes(bytes: &[u8]) -> Result<u64, io::Error> {
  function try_i64_from_bytes (line 148) | pub fn try_i64_from_bytes(bytes: &[u8]) -> Result<i64, io::Error> {
  function try_i32_from_bytes (line 153) | pub fn try_i32_from_bytes(bytes: &[u8]) -> Result<i32, io::Error> {
  function try_i16_from_bytes (line 158) | pub fn try_i16_from_bytes(bytes: &[u8]) -> Result<i16, io::Error> {
  function try_f32_from_bytes (line 163) | pub fn try_f32_from_bytes(bytes: &[u8]) -> Result<f32, io::Error> {
  function try_f64_from_bytes (line 168) | pub fn try_f64_from_bytes(bytes: &[u8]) -> Result<f64, io::Error> {
  function u16_from_bytes (line 173) | pub fn u16_from_bytes(bytes: [u8; 2]) -> u16 {
  function to_short (line 178) | pub fn to_short(int: i16) -> Vec<u8> {
  function to_int (line 183) | pub fn to_int(int: i32) -> Vec<u8> {
  function to_bigint (line 188) | pub fn to_bigint(int: i64) -> Vec<u8> {
  function to_u_short (line 193) | pub fn to_u_short(int: u16) -> Vec<u8> {
  function to_u_int (line 198) | pub fn to_u_int(int: u32) -> Vec<u8> {
  function to_u_big (line 203) | pub fn to_u_big(int: u64) -> Vec<u8> {
  function to_float (line 208) | pub fn to_float(f: f32) -> Vec<u8> {
  function to_float_big (line 213) | pub fn to_float_big(f: f64) -> Vec<u8> {
  function serialize_str (line 217) | pub fn serialize_str(cursor: &mut Cursor<&mut Vec<u8>>, value: &str, ver...
  function serialize_str_long (line 223) | pub(crate) fn serialize_str_long(cursor: &mut Cursor<&mut Vec<u8>>, valu...
  function from_cursor_str (line 229) | pub(crate) fn from_cursor_str<'a>(cursor: &mut Cursor<&'a [u8]>) -> CDRS...
  function from_cursor_str_long (line 239) | pub(crate) fn from_cursor_str_long<'a>(cursor: &mut Cursor<&'a [u8]>) ->...
  function serialize_str_list (line 249) | pub(crate) fn serialize_str_list<'a>(
  function from_cursor_string_list (line 262) | pub fn from_cursor_string_list(cursor: &mut Cursor<&[u8]>) -> CDRSResult...
  type CBytes (line 277) | pub struct CBytes {
    method new (line 283) | pub fn new(bytes: Vec<u8>) -> CBytes {
    method new_null (line 289) | pub fn new_null() -> CBytes {
    method into_bytes (line 295) | pub fn into_bytes(self) -> Option<Vec<u8>> {
    method as_slice (line 300) | pub fn as_slice(&self) -> Option<&[u8]> {
    method is_null_or_empty (line 305) | pub fn is_null_or_empty(&self) -> bool {
  method from_cursor (line 314) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> CDRSResu...
  method serialize (line 326) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  type CBytesShort (line 340) | pub struct CBytesShort {
    method new (line 346) | pub fn new(bytes: Vec<u8>) -> CBytesShort {
    method into_bytes (line 352) | pub fn into_bytes(self) -> Option<Vec<u8>> {
    method serialized_len (line 357) | pub fn serialized_len(&self) -> usize {
  method from_cursor (line 370) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> CDRSResu...
  method serialize (line 382) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  type CInt (line 395) | pub type CInt = i32;
  method from_cursor (line 398) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> CDRSRes...
  type CIntShort (line 407) | pub type CIntShort = i16;
  method from_cursor (line 410) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> CDRSRes...
  type CLong (line 419) | pub type CLong = i64;
  method from_cursor (line 422) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> CDRSRes...
  method serialize (line 431) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 448) | fn from_cursor(cursor: &mut Cursor<&[u8]>, version: Version) -> CDRSResu...
  function cursor_next_value (line 460) | pub fn cursor_next_value(cursor: &mut Cursor<&[u8]>, len: usize) -> CDRS...
  function cursor_next_value_ref (line 466) | pub fn cursor_next_value_ref<'a>(
  function from_i_bytes (line 490) | fn from_i_bytes(bytes: &[u8]) -> i64 {
  function try_u16_from_bytes (line 494) | fn try_u16_from_bytes(bytes: &[u8]) -> Result<u16, io::Error> {
  function to_varint (line 498) | fn to_varint(int: BigInt) -> Vec<u8> {
  function test_from_cursor_str (line 503) | fn test_from_cursor_str() {
  function test_from_cursor_str_long (line 511) | fn test_from_cursor_str_long() {
  function test_serialize_str (line 519) | fn test_serialize_str() {
  function test_serialize_str_long (line 529) | fn test_serialize_str_long() {
  function test_cstringlist (line 539) | fn test_cstringlist() {
  function test_cbytes_new (line 549) | fn test_cbytes_new() {
  function test_cbytes_into_bytes (line 555) | fn test_cbytes_into_bytes() {
  function test_cbytes_from_cursor (line 561) | fn test_cbytes_from_cursor() {
  function test_cbytes_serialize (line 569) | fn test_cbytes_serialize() {
  function test_cbytesshort_new (line 580) | fn test_cbytesshort_new() {
  function test_cbytesshort_into_bytes (line 586) | fn test_cbytesshort_into_bytes() {
  function test_cbytesshort_from_cursor (line 592) | fn test_cbytesshort_from_cursor() {
  function test_cbytesshort_serialize (line 600) | fn test_cbytesshort_serialize() {
  function test_cint_from_cursor (line 607) | fn test_cint_from_cursor() {
  function test_cintshort_from_cursor (line 615) | fn test_cintshort_from_cursor() {
  function test_cursor_next_value (line 623) | fn test_cursor_next_value() {
  function test_try_u16_from_bytes (line 632) | fn test_try_u16_from_bytes() {
  function test_from_i_bytes (line 639) | fn test_from_i_bytes() {
  function test_to_varint (line 646) | fn test_to_varint() {

FILE: cassandra-protocol/src/types/blob.rs
  type Blob (line 6) | pub struct Blob(Vec<u8>);
    method as_mut_slice (line 11) | pub fn as_mut_slice(&mut self) -> &[u8] {
    method into_vec (line 17) | pub fn into_vec(self) -> Vec<u8> {
    method from (line 24) | fn from(vec: Vec<u8>) -> Self {
    method from (line 31) | fn from(value: &[u8]) -> Self {

FILE: cassandra-protocol/src/types/cassandra_type.rs
  type CassandraType (line 13) | pub enum CassandraType {
  function wrapper_fn (line 44) | pub fn wrapper_fn(
  function custom (line 89) | pub fn custom(
  function map (line 116) | pub fn map(
  function set (line 132) | pub fn set(
  function udt (line 148) | pub fn udt(
  function tuple (line 167) | pub fn tuple(
  function null (line 186) | pub fn null(
  function blob (line 194) | pub fn blob(
  function ascii (line 207) | pub fn ascii(
  function int (line 220) | pub fn int(
  function list (line 233) | pub fn list(
  function bigint (line 245) | pub fn bigint(
  function counter (line 258) | pub fn counter(
  function decimal (line 271) | pub fn decimal(
  function double (line 284) | pub fn double(
  function float (line 297) | pub fn float(
  function timestamp (line 310) | pub fn timestamp(
  function uuid (line 323) | pub fn uuid(
  function varchar (line 336) | pub fn varchar(
  function varint (line 349) | pub fn varint(
  function timeuuid (line 362) | pub fn timeuuid(
  function inet (line 375) | pub fn inet(
  function date (line 388) | pub fn date(
  function time (line 401) | pub fn time(
  function smallint (line 414) | pub fn smallint(
  function tinyint (line 427) | pub fn tinyint(
  function bool (line 440) | pub fn bool(
  function duration (line 453) | pub fn duration(

FILE: cassandra-protocol/src/types/data_serialization_types.rs
  constant FALSE_BYTE (line 20) | const FALSE_BYTE: u8 = 0;
  function decode_custom (line 24) | pub fn decode_custom(bytes: &[u8]) -> Result<String, FromUtf8Error> {
  function decode_ascii (line 33) | pub fn decode_ascii(bytes: &[u8]) -> Result<String, FromUtf8Error> {
  function decode_varchar (line 42) | pub fn decode_varchar(bytes: &[u8]) -> Result<String, FromUtf8Error> {
  function decode_bigint (line 52) | pub fn decode_bigint(bytes: &[u8]) -> Result<i64, io::Error> {
  function decode_blob (line 58) | pub fn decode_blob(bytes: &[u8]) -> Result<Blob, io::Error> {
  function decode_boolean (line 65) | pub fn decode_boolean(bytes: &[u8]) -> Result<bool, io::Error> {
  function decode_int (line 78) | pub fn decode_int(bytes: &[u8]) -> Result<i32, io::Error> {
  function decode_date (line 87) | pub fn decode_date(bytes: &[u8]) -> Result<i32, io::Error> {
  function decode_decimal (line 92) | pub fn decode_decimal(bytes: &[u8]) -> Result<Decimal, io::Error> {
  function decode_double (line 112) | pub fn decode_double(bytes: &[u8]) -> Result<f64, io::Error> {
  function decode_float (line 118) | pub fn decode_float(bytes: &[u8]) -> Result<f32, io::Error> {
  function decode_inet (line 124) | pub fn decode_inet(bytes: &[u8]) -> Result<net::IpAddr, io::Error> {
  function decode_timestamp (line 145) | pub fn decode_timestamp(bytes: &[u8]) -> Result<i64, io::Error> {
  function decode_list (line 150) | pub fn decode_list(bytes: &[u8], version: Version) -> Result<Vec<CBytes>...
  function decode_float_vector (line 168) | pub fn decode_float_vector(
  function decode_set (line 206) | pub fn decode_set(bytes: &[u8], version: Version) -> Result<Vec<CBytes>,...
  function decode_map (line 211) | pub fn decode_map(bytes: &[u8], version: Version) -> Result<Vec<(CBytes,...
  function decode_smallint (line 231) | pub fn decode_smallint(bytes: &[u8]) -> Result<i16, io::Error> {
  function decode_tinyint (line 236) | pub fn decode_tinyint(bytes: &[u8]) -> Result<i8, io::Error> {
  function decode_text (line 248) | pub fn decode_text(bytes: &[u8]) -> Result<String, FromUtf8Error> {
  function decode_time (line 256) | pub fn decode_time(bytes: &[u8]) -> Result<i64, io::Error> {
  function decode_timeuuid (line 262) | pub fn decode_timeuuid(bytes: &[u8]) -> Result<uuid::Uuid, uuid::Error> {
  function decode_varint (line 268) | pub fn decode_varint(bytes: &[u8]) -> Result<BigInt, io::Error> {
  function decode_duration (line 274) | pub fn decode_duration(bytes: &[u8]) -> Result<Duration, io::Error> {
  function decode_udt (line 298) | pub fn decode_udt(bytes: &[u8], l: usize, version: Version) -> Result<Ve...
  function decode_tuple (line 323) | pub fn decode_tuple(bytes: &[u8], l: usize, version: Version) -> Result<...
  function decode_custom_test (line 344) | fn decode_custom_test() {
  function decode_ascii_test (line 349) | fn decode_ascii_test() {
  function decode_varchar_test (line 354) | fn decode_varchar_test() {
  function decode_bigint_test (line 359) | fn decode_bigint_test() {
  function decode_blob_test (line 364) | fn decode_blob_test() {
  function decode_boolean_test (line 372) | fn decode_boolean_test() {
  function decode_int_test (line 379) | fn decode_int_test() {
  function decode_date_test (line 384) | fn decode_date_test() {
  function decode_double_test (line 389) | fn decode_double_test() {
  function decode_float_test (line 399) | fn decode_float_test() {
  function decode_inet_test (line 409) | fn decode_inet_test() {
  function decode_timestamp_test (line 424) | fn decode_timestamp_test() {
  function decode_list_test (line 429) | fn decode_list_test() {
  function decode_duration_test (line 436) | fn decode_duration_test() {
  function decode_set_test (line 442) | fn decode_set_test() {
  function decode_map_test (line 449) | fn decode_map_test() {
  function decode_smallint_test (line 461) | fn decode_smallint_test() {
  function decode_tinyint_test (line 466) | fn decode_tinyint_test() {
  function decode_tinyint_empty_returns_error_not_panic (line 471) | fn decode_tinyint_empty_returns_error_not_panic() {
  function decode_decimal_short_input_returns_error_not_panic (line 478) | fn decode_decimal_short_input_returns_error_not_panic() {
  function decode_float_vector_short_input_returns_error_not_panic (line 486) | fn decode_float_vector_short_input_returns_error_not_panic() {
  function decode_decimal_test (line 494) | fn decode_decimal_test() {
  function decode_text_test (line 522) | fn decode_text_test() {
  function decode_string_returns_error_on_invalid_utf8 (line 532) | fn decode_string_returns_error_on_invalid_utf8() {
  function decode_time_test (line 555) | fn decode_time_test() {
  function decode_timeuuid_test (line 560) | fn decode_timeuuid_test() {
  function decode_varint_test (line 570) | fn decode_varint_test() {
  function decode_udt_test (line 582) | fn decode_udt_test() {
  function as_rust_blob_test (line 589) | fn as_rust_blob_test() {
  function as_rust_v4_blob_test (line 610) | fn as_rust_v4_blob_test() {
  function as_rust_string_test (line 628) | fn as_rust_string_test() {
  function as_rust_bool_test (line 662) | fn as_rust_bool_test() {
  function as_rust_v4_bool_test (line 683) | fn as_rust_v4_bool_test() {
  function as_rust_i64_test (line 701) | fn as_rust_i64_test() {
  function as_rust_v4_i64_test (line 729) | fn as_rust_v4_i64_test() {
  function as_rust_i32_test (line 758) | fn as_rust_i32_test() {
  function as_rust_v4_i32_test (line 778) | fn as_rust_v4_i32_test() {
  function as_rust_i16_test (line 797) | fn as_rust_i16_test() {
  function as_rust_v4_i16_test (line 815) | fn as_rust_v4_i16_test() {
  function as_rust_i8_test (line 830) | fn as_rust_i8_test() {
  function as_rust_v4_i8_test (line 845) | fn as_rust_v4_i8_test() {
  function as_rust_f64_test (line 857) | fn as_rust_f64_test() {
  function as_rust_v4_f64_test (line 876) | fn as_rust_v4_f64_test() {
  function as_rust_f32_test (line 892) | fn as_rust_f32_test() {
  function as_rust_v4_f32_test (line 913) | fn as_rust_v4_f32_test() {
  function as_rust_inet_test (line 931) | fn as_rust_inet_test() {
  function as_rust_v4_inet_test (line 950) | fn as_rust_v4_inet_test() {

FILE: cassandra-protocol/src/types/decimal.rs
  type Decimal (line 10) | pub struct Decimal {
    method as_plain (line 21) | pub fn as_plain(&self) -> BigInt {
    method from (line 69) | fn from(f: f32) -> Decimal {
    method from (line 97) | fn from(f: f64) -> Decimal {
  method serialize (line 40) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from (line 120) | fn from(value: Decimal) -> Self {
  function serialize_test (line 130) | fn serialize_test() {
  function from_f32 (line 155) | fn from_f32() {
  function from_f64 (line 171) | fn from_f64() {
  function from_f32_tolerates_inexact_floats (line 192) | fn from_f32_tolerates_inexact_floats() {
  function from_f64_tolerates_inexact_floats (line 199) | fn from_f64_tolerates_inexact_floats() {
  function as_plain_does_not_panic_on_negative_scale (line 209) | fn as_plain_does_not_panic_on_negative_scale() {

FILE: cassandra-protocol/src/types/duration.rs
  type DurationCreationError (line 9) | pub enum DurationCreationError {
  type Duration (line 24) | pub struct Duration {
    method new (line 31) | pub fn new(months: i32, days: i32, nanoseconds: i64) -> Result<Self, D...
    method months (line 49) | pub fn months(&self) -> i32 {
    method days (line 53) | pub fn days(&self) -> i32 {
    method nanoseconds (line 57) | pub fn nanoseconds(&self) -> i64 {
  method serialize (line 63) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, _version: Version) {
  function should_serialize_duration (line 84) | fn should_serialize_duration() {

FILE: cassandra-protocol/src/types/from_cdrs.rs
  type FromCdrs (line 17) | pub trait FromCdrs {
    method from_cdrs (line 18) | fn from_cdrs<T>(cdrs_type: T) -> CdrsResult<Option<Self>>
    method from_cdrs_r (line 26) | fn from_cdrs_r<T>(cdrs_type: T) -> CdrsResult<Self>
  type FromCdrsByName (line 59) | pub trait FromCdrsByName {
    method from_cdrs_by_name (line 60) | fn from_cdrs_by_name<T>(cdrs_type: &T, name: &str) -> CdrsResult<Optio...
    method from_cdrs_r (line 68) | fn from_cdrs_r<T>(cdrs_type: &T, name: &str) -> CdrsResult<Self>

FILE: cassandra-protocol/src/types/list.rs
  type List (line 20) | pub struct List {
    method map (line 29) | fn map<T, F>(&self, f: F) -> Vec<T>
    method try_map (line 36) | fn try_map<T, F>(&self, f: F) -> Result<Vec<T>>

FILE: cassandra-protocol/src/types/map.rs
  type Map (line 19) | pub struct Map {
    method new (line 27) | pub fn new(data: Vec<(CBytes, CBytes)>, meta: ColTypeOption, protocol_...

FILE: cassandra-protocol/src/types/rows.rs
  type Row (line 25) | pub struct Row {
    method from_body (line 32) | pub fn from_body(body: BodyResResultRows) -> Vec<Row> {
    method contains_column (line 46) | pub fn contains_column(&self, name: &str) -> bool {
    method is_empty (line 54) | pub fn is_empty(&self, index: usize) -> bool {
    method is_empty_by_name (line 62) | pub fn is_empty_by_name(&self, name: &str) -> bool {
    method col_spec_by_name (line 71) | fn col_spec_by_name(&self, name: &str) -> Option<(&ColSpec, &CBytes)> {
    method col_spec_by_index (line 83) | fn col_spec_by_index(&self, index: usize) -> Option<(&ColSpec, &CBytes...

FILE: cassandra-protocol/src/types/tuple.rs
  type Tuple (line 20) | pub struct Tuple {
    method new (line 50) | pub fn new(elements: Vec<CBytes>, metadata: &CTuple, protocol_version:...
  method eq (line 26) | fn eq(&self, other: &Tuple) -> bool {
  method hash (line 42) | fn hash<H: Hasher>(&self, state: &mut H) {

FILE: cassandra-protocol/src/types/udt.rs
  type Udt (line 22) | pub struct Udt {
    method new (line 28) | pub fn new(fields: Vec<CBytes>, metadata: &CUdt, protocol_version: Ver...

FILE: cassandra-protocol/src/types/value.rs
  constant NULL_INT_VALUE (line 20) | const NULL_INT_VALUE: i32 = -1;
  constant NOT_SET_INT_VALUE (line 21) | const NOT_SET_INT_VALUE: i32 = -2;
  type Value (line 25) | pub enum Value {
    method new (line 32) | pub fn new<B>(v: B) -> Value
    method from (line 84) | fn from(b: T) -> Value {
    method from (line 90) | fn from(b: Option<T>) -> Value {
  method serialize (line 41) | fn serialize(&self, cursor: &mut Cursor<&mut Vec<u8>>, version: Version) {
  method from_cursor (line 55) | fn from_cursor(cursor: &mut Cursor<&[u8]>, _version: Version) -> Result<...
  type Bytes (line 99) | pub struct Bytes(Vec<u8>);
    method into_inner (line 103) | pub fn into_inner(self) -> Vec<u8> {
    method from (line 110) | fn from(value: String) -> Self {
    method from (line 117) | fn from(value: &str) -> Self {
    method from (line 124) | fn from(value: i8) -> Self {
    method from (line 131) | fn from(value: i16) -> Self {
    method from (line 138) | fn from(value: i32) -> Self {
    method from (line 145) | fn from(value: i64) -> Self {
    method from (line 152) | fn from(value: u8) -> Self {
    method from (line 159) | fn from(value: u16) -> Self {
    method from (line 166) | fn from(value: u32) -> Self {
    method from (line 173) | fn from(value: u64) -> Self {
    method from (line 180) | fn from(value: NonZeroI8) -> Self {
    method from (line 187) | fn from(value: NonZeroI16) -> Self {
    method from (line 194) | fn from(value: NonZeroI32) -> Self {
    method from (line 201) | fn from(value: NonZeroI64) -> Self {
    method from (line 208) | fn from(value: bool) -> Self {
    method from (line 219) | fn from(value: Uuid) -> Self {
    method from (line 226) | fn from(value: IpAddr) -> Self {
    method from (line 236) | fn from(value: f32) -> Self {
    method from (line 243) | fn from(value: f64) -> Self {
    method from (line 250) | fn from(value: PrimitiveDateTime) -> Self {
    method from (line 259) | fn from(value: Blob) -> Self {
    method from (line 266) | fn from(value: Decimal) -> Self {
    method from (line 273) | fn from(value: NaiveDateTime) -> Self {
    method from (line 280) | fn from(value: DateTime<Utc>) -> Self {
    method from (line 287) | fn from(value: Duration) -> Self {
    method from (line 293) | fn from(vec: Vec<T>) -> Bytes {
    method from (line 312) | fn from(value: BigInt) -> Self {
    method from (line 322) | fn from(map: HashMap<K, V>) -> Bytes {
    method from (line 348) | fn from(map: BTreeMap<K, V>) -> Bytes {
  function test_value_serialization (line 374) | fn test_value_serialization() {
  function test_value_from_cursor_handles_all_lengths (line 396) | fn test_value_from_cursor_handles_all_lengths() {
  function test_new_value_all_types (line 438) | fn test_new_value_all_types() {

FILE: cassandra-protocol/src/types/vector.rs
  type Vector (line 11) | pub struct Vector {
    method try_map (line 20) | fn try_map<T, F>(&self, f: F) -> Result<Vec<T>>
  type VectorInfo (line 28) | pub struct VectorInfo {
  function get_vector_type_info (line 33) | pub fn get_vector_type_info(option_value: &ColTypeOptionValue) -> Result...

FILE: cdrs-tokio-helpers-derive/src/common.rs
  function get_struct_fields (line 10) | pub fn get_struct_fields(ast: &DeriveInput) -> Result<Vec<TokenStream>> {
  function struct_fields (line 27) | pub fn struct_fields(ast: &DeriveInput) -> Result<&FieldsNamed> {
  function extract_type (line 39) | fn extract_type(arg: &GenericArgument) -> Result<Type> {
  function get_map_params_string (line 46) | pub fn get_map_params_string(ty: &Type, name: &str) -> Result<(Type, Typ...
  function remove_r (line 76) | fn remove_r(s: String) -> String {
  function convert_field_into_rust (line 84) | fn convert_field_into_rust(field: Field) -> Result<TokenStream> {
  function get_arguments (line 99) | fn get_arguments(name: TokenStream) -> TokenStream {
  function into_rust_with_args (line 105) | fn into_rust_with_args(
  function is_non_zero_primitive (line 170) | fn is_non_zero_primitive(ty: &Type, name: &str) -> Result<bool> {
  function get_cdrs_type (line 179) | fn get_cdrs_type(ty: &Type, name: &str) -> Result<Type> {
  function get_ident (line 209) | fn get_ident<'a>(ty: &'a Type, name: &str) -> Result<&'a Ident> {
  function as_rust (line 230) | fn as_rust(ty: &Type, val: TokenStream, name: &str) -> Result<TokenStrea...
  function get_ident_string (line 277) | pub fn get_ident_string(ty: &Type, name: &str) -> Result<String> {
  function get_ident_params_string (line 281) | pub fn get_ident_params_string(ty: &Type, name: &str) -> Result<Type> {

FILE: cdrs-tokio-helpers-derive/src/db_mirror.rs
  function impl_db_mirror (line 9) | pub fn impl_db_mirror(ast: &DeriveInput) -> Result<TokenStream> {

FILE: cdrs-tokio-helpers-derive/src/into_cdrs_value.rs
  function impl_into_cdrs_value (line 9) | pub fn impl_into_cdrs_value(ast: &DeriveInput) -> Result<TokenStream> {

FILE: cdrs-tokio-helpers-derive/src/lib.rs
  function db_mirror (line 18) | pub fn db_mirror(input: TokenStream) -> TokenStream {
  function into_cdrs_value (line 29) | pub fn into_cdrs_value(input: TokenStream) -> TokenStream {
  function try_from_row (line 40) | pub fn try_from_row(input: TokenStream) -> TokenStream {
  function try_from_udt (line 51) | pub fn try_from_udt(input: TokenStream) -> TokenStream {

FILE: cdrs-tokio-helpers-derive/src/try_from_row.rs
  function impl_try_from_row (line 7) | pub fn impl_try_from_row(ast: &DeriveInput) -> Result<TokenStream> {

FILE: cdrs-tokio-helpers-derive/src/try_from_udt.rs
  function impl_try_from_udt (line 7) | pub fn impl_try_from_udt(ast: &DeriveInput) -> Result<TokenStream> {

FILE: cdrs-tokio/examples/crud_operations.rs
  type CurrentSession (line 15) | type CurrentSession = Session<
  function main (line 22) | async fn main() {
  type RowStruct (line 48) | struct RowStruct {
    method into_query_values (line 56) | fn into_query_values(self) -> QueryValues {
  type User (line 62) | struct User {
  function create_keyspace (line 66) | async fn create_keyspace(session: &mut CurrentSession) {
  function create_udt (line 75) | async fn create_udt(session: &mut CurrentSession) {
  function create_table (line 83) | async fn create_table(session: &mut CurrentSession) {
  function insert_struct (line 93) | async fn insert_struct(session: &mut CurrentSession) {
  function select_struct (line 113) | async fn select_struct(session: &mut CurrentSession) {
  function update_struct (line 130) | async fn update_struct(session: &mut CurrentSession) {
  function delete_struct (line 142) | async fn delete_struct(session: &mut CurrentSession) {

FILE: cdrs-tokio/examples/generic_connection.rs
  type CurrentSession (line 37) | type CurrentSession = Session<
  type VirtualClusterConfig (line 54) | struct VirtualClusterConfig {
    method create_manager (line 128) | fn create_manager(
    method event_channel_capacity (line 137) | fn event_channel_capacity(&self) -> usize {
    method version (line 141) | fn version(&self) -> Version {
    method connection_pool_config (line 145) | fn connection_pool_config(&self) -> ConnectionPoolConfig {
  function rewrite (line 61) | fn rewrite(addr: SocketAddr, mask: &Ipv4Addr, actual: &Ipv4Addr) -> Sock...
  type VirtualConnectionManager (line 83) | struct VirtualConnectionManager {
    method connection (line 90) | fn connection(
    method new (line 105) | async fn new(
  function main (line 151) | async fn main() {
  type RowStruct (line 194) | struct RowStruct {
    method into_query_values (line 202) | fn into_query_values(self) -> QueryValues {
  type User (line 208) | struct User {
  function create_keyspace (line 212) | async fn create_keyspace(session: &mut CurrentSession) {
  function create_udt (line 221) | async fn create_udt(session: &mut CurrentSession) {
  function create_table (line 229) | async fn create_table(session: &mut CurrentSession) {
  function insert_struct (line 240) | async fn insert_struct(session: &mut CurrentSession) {
  function select_struct (line 261) | async fn select_struct(session: &mut CurrentSession) {
  function update_struct (line 279) | async fn update_struct(session: &mut CurrentSession) {
  function delete_struct (line 291) | async fn delete_struct(session: &mut CurrentSession) {

FILE: cdrs-tokio/examples/insert_collection.rs
  type CurrentSession (line 15) | type CurrentSession = Session<
  function main (line 22) | async fn main() {
  type RowStruct (line 53) | struct RowStruct {
    method into_query_values (line 61) | fn into_query_values(self) -> QueryValues {
  type User (line 67) | struct User {
  function create_keyspace (line 71) | async fn create_keyspace(session: &mut CurrentSession) {
  function create_udt (line 80) | async fn create_udt(session: &mut CurrentSession) {
  function create_table (line 88) | async fn create_table(session: &mut CurrentSession) {
  function append_list (line 99) | async fn append_list(session: &mut CurrentSession) {
  function prepend_list (line 117) | async fn prepend_list(session: &mut CurrentSession) {
  function append_set (line 135) | async fn append_set(session: &mut CurrentSession) {
  function append_map (line 153) | async fn append_map(session: &mut CurrentSession) {
  function insert_struct (line 167) | async fn insert_struct(session: &mut CurrentSession) {
  function select_struct (line 187) | async fn select_struct(session: &mut CurrentSession) {
  function delete_struct (line 204) | async fn delete_struct(session: &mut CurrentSession) {

FILE: cdrs-tokio/examples/multiple_thread.rs
  type CurrentSession (line 12) | type CurrentSession = Session<
  function main (line 19) | async fn main() {
  type RowStruct (line 50) | struct RowStruct {
    method into_query_values (line 55) | fn into_query_values(self) -> QueryValues {
  type User (line 61) | struct User {
  function create_keyspace (line 65) | async fn create_keyspace(session: Arc<CurrentSession>) {
  function create_table (line 74) | async fn create_table(session: Arc<CurrentSession>) {
  function insert_struct (line 83) | async fn insert_struct(session: Arc<CurrentSession>, key: i32) {
  function select_struct (line 93) | async fn select_struct(session: Arc<CurrentSession>) {

FILE: cdrs-tokio/examples/paged_query.rs
  type CurrentSession (line 12) | type CurrentSession = Session<
  type RowStruct (line 19) | struct RowStruct {
    method into_query_values (line 24) | fn into_query_values(self) -> QueryValues {
  type AnotherTestTable (line 30) | struct AnotherTestTable {
    method into_query_values (line 39) | fn into_query_values(self) -> QueryValues {
  function main (line 45) | async fn main() {
  function create_keyspace (line 73) | async fn create_keyspace(session: &CurrentSession) {
  function create_udt (line 82) | async fn create_udt(session: &CurrentSession) {
  function create_table (line 90) | async fn create_table(session: &CurrentSession) {
  function fill_table (line 100) | async fn fill_table(session: &CurrentSession) {
  function paged_selection_query (line 113) | async fn paged_selection_query(session: &CurrentSession) {
  function paged_with_value (line 131) | async fn paged_with_value(session: &CurrentSession) {
  function paged_with_values_list (line 180) | async fn paged_with_values_list(session: &CurrentSession) {
  function paged_selection_query_with_state (line 223) | async fn paged_selection_query_with_state(session: &CurrentSession, stat...

FILE: cdrs-tokio/examples/prepare_batch_execute.rs
  type CurrentSession (line 11) | type CurrentSession = Session<
  type RowStruct (line 18) | struct RowStruct {
    method into_query_values (line 23) | fn into_query_values(self) -> QueryValues {
  function main (line 31) | async fn main() {
  function create_keyspace (line 62) | async fn create_keyspace(session: &mut CurrentSession) {
  function create_table (line 71) | async fn create_table(session: &mut CurrentSession) {
  function insert_row (line 80) | async fn insert_row(session: &mut CurrentSession, row: RowStruct, prepar...
  function batch_few_queries (line 87) | async fn batch_few_queries(session: &mut CurrentSession, query: &str) {

FILE: cdrs-tokio/src/cluster.rs
  type GenericClusterConfig (line 55) | pub trait GenericClusterConfig<T: CdrsTransport, CM: ConnectionManager<T...
    method create_manager (line 56) | fn create_manager(
    method event_channel_capacity (line 63) | fn event_channel_capacity(&self) -> usize;
    method version (line 66) | fn version(&self) -> Version;
    method connection_pool_config (line 69) | fn connection_pool_config(&self) -> ConnectionPoolConfig;
    method beta_protocol (line 72) | fn beta_protocol(&self) -> bool {

FILE: cdrs-tokio/src/cluster/cluster_metadata_manager.rs
  function find_in_peers (line 37) | fn find_in_peers(
  function send_query (line 54) | async fn send_query<T: CdrsTransport>(
  function send_query_with_values (line 64) | async fn send_query_with_values<T: CdrsTransport, V: Into<QueryValues>>(
  function send_query_with_params (line 75) | async fn send_query_with_params<T: CdrsTransport>(
  function build_node_info (line 102) | fn build_node_info(row: &Row, broadcast_rpc_address: SocketAddr) -> Resu...
  function build_node_broadcast_rpc_address (line 147) | fn build_node_broadcast_rpc_address(
  function broadcast_rpc_address_from_row (line 163) | fn broadcast_rpc_address_from_row(row: &Row, control_addr: SocketAddr) -...
  function is_peer_row_valid (line 210) | fn is_peer_row_valid(row: &Row) -> bool {
  function fetch_control_connection_info (line 224) | async fn fetch_control_connection_info<T: CdrsTransport>(
  function build_keyspace (line 241) | fn build_keyspace(row: &Row) -> Result<(String, KeyspaceMetadata)> {
  function build_replication_strategy (line 263) | fn build_replication_strategy(
  function extract_datacenter_replication_factor (line 288) | fn extract_datacenter_replication_factor(
  function extract_replication_factor (line 300) | fn extract_replication_factor(value: Option<&JsonValue>) -> Result<usize> {
  type ClusterMetadataManager (line 317) | pub(crate) struct ClusterMetadataManager<
  function new (line 333) | pub(crate) fn new(
  function listen_to_events (line 354) | pub(crate) fn listen_to_events(self: &Arc<Self>, mut event_receiver: Rec...
  function process_event (line 376) | async fn process_event(&self, event: ServerEvent) {
  function process_schema_event (line 387) | async fn process_schema_event(&self, event: SchemaChange) {
  function process_topology_event (line 401) | async fn process_topology_event(&self, event: TopologyChange) {
  function process_status_event (line 431) | async fn process_status_event(&self, event: StatusChange) {
  function remove_keyspace (line 503) | fn remove_keyspace(&self, keyspace: &str) {
  function refresh_keyspace (line 512) | async fn refresh_keyspace(&self, keyspace: &str) {
  function try_refresh_keyspace (line 518) | async fn try_refresh_keyspace(&self, keyspace: &str) -> Result<()> {
  function add_new_node (line 559) | async fn add_new_node(
  function find_new_node_info (line 586) | async fn find_new_node_info(
  function control_transport (line 624) | fn control_transport(&self) -> Result<Arc<T>> {
  function peer_table_name (line 633) | fn peer_table_name(&self) -> &'static str {
  function metadata (line 642) | pub(crate) fn metadata(&self) -> Arc<ClusterMetadata<T, CM>> {
  function find_node_by_rpc_address (line 647) | pub(crate) fn find_node_by_rpc_address(
  function refresh_metadata (line 657) | pub(crate) async fn refresh_metadata(&self, full_refresh: bool) -> Resul...
  function refresh_keyspaces (line 697) | async fn refresh_keyspaces(&self) -> Result<FxHashMap<String, KeyspaceMe...
  function refresh_node_infos (line 713) | async fn refresh_node_infos(&self) -> Result<Vec<NodeInfo>> {
  function query_peers (line 757) | async fn query_peers(&self, transport: &T) -> Result<Option<Vec<Row>>> {
  function query_legacy_peers (line 801) | async fn query_legacy_peers(&self, transport: &T) -> Result<Option<Vec<R...

FILE: cdrs-tokio/src/cluster/config_proxy.rs
  type HttpBasicAuth (line 2) | pub(crate) struct HttpBasicAuth {
  type HttpProxyConfig (line 8) | pub struct HttpProxyConfig {
  type HttpProxyConfigBuilder (line 14) | pub struct HttpProxyConfigBuilder {
    method new (line 21) | pub fn new(address: String) -> Self {
    method with_basic_auth (line 29) | pub fn with_basic_auth(mut self, username: String, password: String) -...
    method build (line 35) | pub fn build(self) -> HttpProxyConfig {

FILE: cdrs-tokio/src/cluster/config_rustls.rs
  type NodeRustlsConfig (line 16) | pub struct NodeRustlsConfig {
  type NodeRustlsConfigBuilder (line 31) | pub struct NodeRustlsConfigBuilder {
    method new (line 44) | pub fn new(dns_name: ServerName<'static>, config: Arc<ClientConfig>) -...
    method with_authenticator_provider (line 59) | pub fn with_authenticator_provider(
    method with_contact_point (line 70) | pub fn with_contact_point(mut self, addr: NodeAddress) -> Self {
    method with_contact_points (line 77) | pub fn with_contact_points(mut self, addr: Vec<NodeAddress>) -> Self {
    method with_version (line 84) | pub fn with_version(mut self, version: Version) -> Self {
    method with_beta_protocol (line 91) | pub fn with_beta_protocol(mut self, beta_protocol: bool) -> Self {
    method with_http_proxy (line 99) | pub fn with_http_proxy(mut self, config: HttpProxyConfig) -> Self {
    method build (line 105) | pub async fn build(self) -> Result<NodeRustlsConfig> {

FILE: cdrs-tokio/src/cluster/config_tcp.rs
  type NodeTcpConfig (line 15) | pub struct NodeTcpConfig {
  type NodeTcpConfigBuilder (line 28) | pub struct NodeTcpConfigBuilder {
    method new (line 52) | pub fn new() -> NodeTcpConfigBuilder {
    method with_authenticator_provider (line 58) | pub fn with_authenticator_provider(
    method with_contact_point (line 69) | pub fn with_contact_point(mut self, addr: NodeAddress) -> Self {
    method with_contact_points (line 76) | pub fn with_contact_points(mut self, addr: Vec<NodeAddress>) -> Self {
    method with_version (line 83) | pub fn with_version(mut self, version: Version) -> Self {
    method with_beta_protocol (line 90) | pub fn with_beta_protocol(mut self, beta_protocol: bool) -> Self {
    method with_http_proxy (line 98) | pub fn with_http_proxy(mut self, config: HttpProxyConfig) -> Self {
    method build (line 104) | pub async fn build(self) -> Result<NodeTcpConfig> {
  method default (line 39) | fn default() -> Self {

FILE: cdrs-tokio/src/cluster/connection_manager.rs
  type ConnectionManager (line 19) | pub trait ConnectionManager<T: CdrsTransport>: Send + Sync {
    method connection (line 22) | fn connection(
  function startup (line 47) | pub async fn startup<
  function set_keyspace (line 130) | async fn set_keyspace<T: CdrsTransport>(

FILE: cdrs-tokio/src/cluster/connection_pool.rs
  type ReconnectionState (line 27) | enum ReconnectionState {
  function new_connection (line 33) | async fn new_connection<T: CdrsTransport, CM: ConnectionManager<T>>(
  type ConnectionPoolConfig (line 62) | pub struct ConnectionPoolConfig {
  method default (line 70) | fn default() -> Self {
  type ConnectionPoolConfigBuilder (line 82) | pub struct ConnectionPoolConfigBuilder {
    method new (line 87) | pub fn new() -> Self {
    method with_local_size (line 93) | pub fn with_local_size(mut self, local_size: usize) -> Self {
    method with_remote_size (line 100) | pub fn with_remote_size(mut self, remote_size: usize) -> Self {
    method with_connect_timeout (line 107) | pub fn with_connect_timeout(mut self, connect_timeout: Option<Duration...
    method with_heartbeat_interval (line 114) | pub fn with_heartbeat_interval(mut self, heartbeat_interval: Duration)...
    method build (line 121) | pub fn build(self) -> ConnectionPoolConfig {
  type ConnectionPoolFactory (line 126) | pub(crate) struct ConnectionPoolFactory<
  function new (line 139) | pub(crate) fn new(
  function connection_manager (line 157) | pub(crate) fn connection_manager(&self) -> &CM {
  function create (line 161) | pub(crate) async fn create(
  function start_heartbeat (line 259) | fn start_heartbeat(
  function monitor_connections (line 310) | fn monitor_connections(
  function are_all_connections_down (line 422) | async fn are_all_connections_down(pool: &ConnectionPool<T, CM>) -> bool {
  function run_reconnection_loop (line 433) | async fn run_reconnection_loop(
  type ConnectionPool (line 457) | pub(crate) struct ConnectionPool<T: CdrsTransport, CM: ConnectionManager...
  function new (line 468) | async fn new(
  function connection (line 523) | pub(crate) async fn connection(&self) -> CdrsResult<Arc<T>> {
  function is_any_connection_up (line 556) | pub(crate) async fn is_any_connection_up(&self) -> bool {
  function reconnect_broken (line 567) | async fn reconnect_broken(&self) -> CdrsResult<bool> {
  function create_heartbeat_interval (line 617) | fn create_heartbeat_interval(now: Instant, period: Duration) -> Interval {
  function create_heartbeat_interval_skips_missed_ticks (line 628) | async fn create_heartbeat_interval_skips_missed_ticks() {

FILE: cdrs-tokio/src/cluster/control_connection.rs
  constant DEFAULT_RECONNECT_DELAY (line 17) | const DEFAULT_RECONNECT_DELAY: Duration = Duration::from_secs(10);
  constant EVENT_CHANNEL_CAPACITY (line 18) | const EVENT_CHANNEL_CAPACITY: usize = 32;
  type ControlConnection (line 21) | pub(crate) struct ControlConnection<
  function run (line 41) | pub(crate) async fn run(self, init_complete_sender: tokio::sync::oneshot...
  function wait_for_reconnection (line 152) | async fn wait_for_reconnection(schedule: &mut Box<dyn ReconnectionSchedu...
  function process_events (line 158) | fn process_events(

FILE: cdrs-tokio/src/cluster/keyspace_holder.rs
  type KeyspaceHolder (line 8) | pub struct KeyspaceHolder {
    method new (line 14) | pub fn new(keyspace_sender: Sender<Option<String>>) -> Self {
    method current_keyspace (line 22) | pub fn current_keyspace(&self) -> Option<Arc<String>> {
    method update_current_keyspace (line 27) | pub fn update_current_keyspace(&self, keyspace: String) {
    method update_current_keyspace_without_notification (line 41) | pub fn update_current_keyspace_without_notification(&self, keyspace: S...
    method send_notification (line 46) | fn send_notification(&self, keyspace: String) {

FILE: cdrs-tokio/src/cluster/metadata_builder.rs
  function build_initial_metadata (line 12) | pub(crate) fn build_initial_metadata<T: CdrsTransport, CM: ConnectionMan...
  function refresh_metadata (line 56) | pub(crate) fn refresh_metadata<T: CdrsTransport, CM: ConnectionManager<T>>(
  function add_new_node (line 105) | pub(crate) fn add_new_node<T: CdrsTransport, CM: ConnectionManager<T>>(
  function create_connection_pool_factory (line 158) | fn create_connection_pool_factory(
  function should_create_initial_metadata_from_all_new_nodes (line 176) | fn should_create_initial_metadata_from_all_new_nodes() {
  function should_copy_old_node (line 213) | fn should_copy_old_node() {
  function should_replace_old_metadata_nodes_with_new (line 258) | fn should_replace_old_metadata_nodes_with_new() {
  function should_update_old_metadata_nodes_with_new_info (line 313) | fn should_update_old_metadata_nodes_with_new_info() {
  function should_not_add_already_existing_node (line 363) | fn should_not_add_already_existing_node() {
  function should_update_existing_node (line 417) | fn should_update_existing_node() {
  function should_add_new_node (line 468) | fn should_add_new_node() {

FILE: cdrs-tokio/src/cluster/node_address.rs
  type NodeAddress (line 11) | pub enum NodeAddress {
    method from (line 17) | fn from(addr: SocketAddr) -> Self {
    method from (line 23) | fn from(value: String) -> Self {
    method from (line 29) | fn from(value: &String) -> Self {
    method from (line 35) | fn from(value: &str) -> Self {
    method resolve_address (line 42) | pub async fn resolve_address(&self) -> Result<Vec<SocketAddr>> {

FILE: cdrs-tokio/src/cluster/node_info.rs
  type NodeInfo (line 11) | pub struct NodeInfo {

FILE: cdrs-tokio/src/cluster/pager.rs
  type SessionPager (line 14) | pub struct SessionPager<
  function new (line 31) | pub fn new(session: &'a Session<T, CM, LB>, page_size: i32) -> SessionPa...
  function query_with_pager_state (line 35) | pub fn query_with_pager_state<Q>(
  function query_with_pager_state_params (line 46) | pub fn query_with_pager_state_params<Q>(
  function query (line 64) | pub fn query<Q>(&'a mut self, query: Q) -> QueryPager<'a, Q, SessionPage...
  function query_with_params (line 76) | pub fn query_with_params<Q>(
  function exec_with_pager_state (line 87) | pub fn exec_with_pager_state(
  function exec (line 99) | pub fn exec(
  type QueryPager (line 107) | pub struct QueryPager<'a, Q: ToString, P: 'a> {
  function into_pager_state (line 123) | pub fn into_pager_state(self) -> PagerState {
  function next (line 127) | pub async fn next(&mut self) -> error::Result<Vec<Row>> {
  function has_more (line 159) | pub fn has_more(&self) -> bool {
  function pager_state (line 165) | pub fn pager_state(&self) -> PagerState {
  type ExecPager (line 170) | pub struct ExecPager<'a, P: 'a> {
  function into_pager_state (line 183) | pub fn into_pager_state(self) -> PagerState {
  function next (line 187) | pub async fn next(&mut self) -> error::Result<Vec<Row>> {
  function has_more (line 213) | pub fn has_more(&self) -> bool {
  function pager_state (line 220) | pub fn pager_state(&self) -> PagerState {
  type PagerState (line 226) | pub struct PagerState {
    method new (line 232) | pub fn new() -> Self {
    method new_with_cursor (line 236) | pub fn new_with_cursor(cursor: CBytes) -> Self {
    method new_with_cursor_and_more_flag (line 243) | pub fn new_with_cursor_and_more_flag(cursor: CBytes, has_more: bool) -...
    method has_more (line 251) | pub fn has_more(&self) -> bool {
    method cursor (line 256) | pub fn cursor(&self) -> Option<CBytes> {
    method into_cursor (line 261) | pub fn into_cursor(self) -> Option<CBytes> {

FILE: cdrs-tokio/src/cluster/rustls_connection_manager.rs
  type RustlsConnectionManager (line 26) | pub struct RustlsConnectionManager {
    method connection (line 42) | fn connection(
    method new (line 55) | pub fn new(
    method create_transport (line 84) | async fn create_transport(
    method create_transport (line 148) | async fn create_transport(
    method establish_connection (line 172) | async fn establish_connection(

FILE: cdrs-tokio/src/cluster/send_envelope.rs
  function send_envelope (line 13) | pub async fn send_envelope<T: CdrsTransport + 'static, CM: ConnectionMan...

FILE: cdrs-tokio/src/cluster/session.rs
  constant DEFAULT_TRANSPORT_BUFFER_SIZE (line 60) | pub const DEFAULT_TRANSPORT_BUFFER_SIZE: usize = 1024;
  constant DEFAULT_EVENT_CHANNEL_CAPACITY (line 61) | const DEFAULT_EVENT_CHANNEL_CAPACITY: usize = 128;
  constant MAX_REPREPARE_ATTEMPTS (line 68) | const MAX_REPREPARE_ATTEMPTS: usize = 5;
  function convert_to_prepared (line 73) | fn convert_to_prepared(body: ResponseBody) -> error::Result<BodyResResul...
  function prepare_flags (line 79) | fn prepare_flags(with_tracing: bool, with_warnings: bool, beta_protocol:...
  function create_keyspace_holder (line 97) | fn create_keyspace_holder() -> (Arc<KeyspaceHolder>, watch::Receiver<Opt...
  function verify_compression_configuration (line 105) | fn verify_compression_configuration(
  function serialize_routing_value (line 117) | fn serialize_routing_value(cursor: &mut Cursor<&mut Vec<u8>>, value: &Ve...
  function serialize_routing_key_with_indexes (line 138) | fn serialize_routing_key_with_indexes(
  function serialize_routing_key (line 172) | fn serialize_routing_key(values: &[Value], version: Version) -> Vec<u8> {
  type Session (line 198) | pub struct Session<
  method drop (line 227) | fn drop(&mut self) {
  function paged (line 239) | pub fn paged(&self, page_size: i32) -> SessionPager<'_, T, CM, LB> {
  function exec_with_params (line 244) | pub fn exec_with_params<'a, 'b: 'a>(
  function exec_with_values (line 371) | pub async fn exec_with_values<V: Into<QueryValues>>(
  function exec (line 387) | pub async fn exec(&self, prepared: &PreparedQuery) -> error::Result<Enve...
  function prepare_raw_tw (line 396) | pub async fn prepare_raw_tw<Q: ToString>(
  function prepare_raw_tw_with_query_plan (line 420) | pub async fn prepare_raw_tw_with_query_plan<Q: ToString>(
  function prepare_raw (line 456) | pub async fn prepare_raw<Q: ToString>(&self, query: Q) -> error::Result<...
  function prepare_tw (line 464) | pub async fn prepare_tw<Q: ToString>(
  function prepare (line 490) | pub async fn prepare<Q: ToString>(&self, query: Q) -> error::Result<Prep...
  function batch (line 496) | pub async fn batch(&self, batch: QueryBatch) -> error::Result<Envelope> {
  function batch_with_params (line 502) | pub fn batch_with_params<'a, 'b: 'a>(
  function reprepare (line 579) | async fn reprepare(
  function query (line 633) | pub async fn query<Q: ToString>(&self, query: Q) -> error::Result<Envelo...
  function query_with_values (line 640) | pub async fn query_with_values<Q: ToString, V: Into<QueryValues>>(
  function query_with_params (line 655) | pub async fn query_with_params<Q: ToString>(
  function current_keyspace (line 697) | pub fn current_keyspace(&self) -> Option<Arc<String>> {
  function cluster_metadata (line 703) | pub fn cluster_metadata(&self) -> Arc<ClusterMetadata<T, CM>> {
  function query_plan (line 710) | pub fn query_plan(&self, request: Option<Request>) -> QueryPlan<T, CM> {
  function create_event_receiver (line 717) | pub fn create_event_receiver(&self) -> Receiver<ServerEvent> {
  function retry_policy (line 723) | pub fn retry_policy(&self) -> &dyn RetryPolicy {
  function send_envelope (line 733) | async fn send_envelope(
  function effective_retry_policy (line 870) | fn effective_retry_policy<'a, 'b: 'a>(
  function new (line 880) | async fn new(
  type RetryPolicyWrapper (line 984) | pub struct RetryPolicyWrapper(pub Box<dyn RetryPolicy + Send + Sync>);
  type ReconnectionPolicyWrapper (line 988) | pub struct ReconnectionPolicyWrapper(pub Arc<dyn ReconnectionPolicy + Se...
  type NodeDistanceEvaluatorWrapper (line 992) | pub struct NodeDistanceEvaluatorWrapper(pub Box<dyn NodeDistanceEvaluato...
  type SpeculativeExecutionPolicyWrapper (line 996) | pub struct SpeculativeExecutionPolicyWrapper(pub Box<dyn SpeculativeExec...
  function connect_generic (line 1005) | pub async fn connect_generic<T, C, A, CM, LB>(
  type SessionConfig (line 1042) | struct SessionConfig<
  function new (line 1068) | fn new(load_balancing: LB) -> Self {
  function into_session (line 1086) | async fn into_session(
  type SessionBuildError (line 1120) | pub enum SessionBuildError {
  type SessionBuilder (line 1130) | pub trait SessionBuilder<
    method with_compression (line 1138) | fn with_compression(self, compression: Compression) -> Self;
    method with_retry_policy (line 1142) | fn with_retry_policy(self, retry_policy: Box<dyn RetryPolicy + Send + ...
    method with_reconnection_policy (line 1146) | fn with_reconnection_policy(
    method with_frame_encoder_factory (line 1153) | fn with_frame_encoder_factory(
    method with_node_distance_evaluator (line 1161) | fn with_node_distance_evaluator(
    method with_speculative_execution_policy (line 1168) | fn with_speculative_execution_policy(
    method with_transport_buffer_size (line 1176) | fn with_transport_buffer_size(self, transport_buffer_size: usize) -> S...
    method with_tcp_nodelay (line 1180) | fn with_tcp_nodelay(self, tcp_nodelay: bool) -> Self;
    method with_event_channel_capacity (line 1185) | fn with_event_channel_capacity(self, event_channel_capacity: usize) ->...
    method with_connection_pool_config (line 1189) | fn with_connection_pool_config(self, connection_pool_config: Connectio...
    method with_keyspace (line 1198) | fn with_keyspace(self, keyspace: String) -> Self;
    method with_beta_protocol (line 1203) | fn with_beta_protocol(self, beta_protocol: bool) -> Self;
    method build (line 1206) | fn build(self) -> BoxFuture<'static, Result<Session<T, CM, LB>, Sessio...
  type TcpSessionBuilder (line 1210) | pub struct TcpSessionBuilder<
  function new (line 1223) | pub fn new(load_balancing: LB, node_config: NodeTcpConfig) -> Self {
  function with_compression (line 1235) | fn with_compression(mut self, compression: Compression) -> Self {
  function with_retry_policy (line 1240) | fn with_retry_policy(mut self, retry_policy: Box<dyn RetryPolicy + Send ...
  function with_reconnection_policy (line 1245) | fn with_reconnection_policy(
  function with_frame_encoder_factory (line 1253) | fn with_frame_encoder_factory(
  function with_node_distance_evaluator (line 1261) | fn with_node_distance_evaluator(
  function with_speculative_execution_policy (line 1269) | fn with_speculative_execution_policy(
  function with_transport_buffer_size (line 1277) | fn with_transport_buffer_size(mut self, transport_buffer_size: usize) ->...
  function with_tcp_nodelay (line 1282) | fn with_tcp_nodelay(mut self, tcp_nodelay: bool) -> Self {
  function with_event_channel_capacity (line 1287) | fn with_event_channel_capacity(mut self, event_channel_capacity: usize) ...
  function with_connection_pool_config (line 1292) | fn with_connection_pool_config(mut self, connection_pool_config: Connect...
  function with_keyspace (line 1297) | fn with_keyspace(mut self, keyspace: String) -> Self {
  function with_beta_protocol (line 1302) | fn with_beta_protocol(mut self, beta_protocol: bool) -> Self {
  function build (line 1307) | fn build(
  type RustlsSessionBuilder (line 1352) | pub struct RustlsSessionBuilder<
  function new (line 1366) | pub fn new(load_balancing: LB, node_config: NodeRustlsConfig) -> Self {
  function with_compression (line 1380) | fn with_compression(mut self, compression: Compression) -> Self {
  function with_retry_policy (line 1385) | fn with_retry_policy(mut self, retry_policy: Box<dyn RetryPolicy + Send ...
  function with_reconnection_policy (line 1390) | fn with_reconnection_policy(
  function with_frame_encoder_factory (line 1398) | fn with_frame_encoder_factory(
  function with_node_distance_evaluator (line 1406) | fn with_node_distance_evaluator(
  function with_speculative_execution_policy (line 1414) | fn with_speculative_execution_policy(
  function with_transport_buffer_size (line 1422) | fn with_transport_buffer_size(mut self, transport_buffer_size: usize) ->...
  function with_tcp_nodelay (line 1427) | fn with_tcp_nodelay(mut self, tcp_nodelay: bool) -> Self {
  function with_event_channel_capacity (line 1432) | fn with_event_channel_capacity(mut self, event_channel_capacity: usize) ...
  function with_connection_pool_config (line 1437) | fn with_connection_pool_config(mut self, connection_pool_config: Connect...
  function with_keyspace (line 1442) | fn with_keyspace(mut self, keyspace: String) -> Self {
  function with_beta_protocol (line 1447) | fn with_beta_protocol(mut self, beta_protocol: bool) -> Self {
  function build (line 1452) | fn build(
  type AbortOnDropHandle (line 1506) | struct AbortOnDropHandle(Option<JoinHandle<()>>);
    method new (line 1509) | fn new(handle: JoinHandle<()>) -> Self {
    method into_inner (line 1516) | fn into_inner(mut self) -> JoinHandle<()> {
  method drop (line 1524) | fn drop(&mut self) {
  function prepare_flags_test (line 1538) | fn prepare_flags_test() {
  function abort_on_drop_handle_aborts_when_dropped (line 1553) | async fn abort_on_drop_handle_aborts_when_dropped() {
  function abort_on_drop_handle_does_not_abort_when_released (line 1582) | async fn abort_on_drop_handle_does_not_abort_when_released() {

FILE: cdrs-tokio/src/cluster/session_context.rs
  type SessionContext (line 4) | pub struct SessionContext<T: CdrsTransport> {
  method default (line 9) | fn default() -> Self {

FILE: cdrs-tokio/src/cluster/tcp_connection_manager.rs
  type TcpConnectionManager (line 25) | pub struct TcpConnectionManager {
    method connection (line 39) | fn connection(
    method new (line 52) | pub fn new(
    method create_transport (line 77) | async fn create_transport(
    method create_transport (line 136) | async fn create_transport(
    method establish_connection (line 158) | async fn establish_connection(

FILE: cdrs-tokio/src/cluster/token_map.rs
  type TokenMap (line 12) | pub struct TokenMap<T: CdrsTransport + 'static, CM: ConnectionManager<T>...
  method clone (line 17) | fn clone(&self) -> Self {
  method fmt (line 25) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  method default (line 33) | fn default() -> Self {
  function new (line 41) | pub fn new(nodes: &NodeMap<T, CM>) -> Self {
  function nodes_for_token_capped (line 61) | pub fn nodes_for_token_capped(
  function nodes_for_token (line 95) | pub fn nodes_for_token(
  function clone_with_node (line 114) | pub fn clone_with_node(&self, node: Arc<Node<T, CM>>) -> Self {
  function clone_without_node (line 125) | pub fn clone_without_node(&self, broadcast_rpc_address: SocketAddr) -> S...
  function prepare_nodes (line 163) | fn prepare_nodes() -> NodeMap<MockCdrsTransport, MockConnectionManager<M...
  function verify_tokens (line 229) | fn verify_tokens(host_ids: &[Uuid], token: Murmur3Token) {
  function should_return_replicas_in_order (line 242) | fn should_return_replicas_in_order() {
  function should_return_replicas_in_order_for_non_primary_token (line 250) | fn should_return_replicas_in_order_for_non_primary_token() {
  function should_return_distinct_nodes_as_replicas (line 261) | fn should_return_distinct_nodes_as_replicas() {
  function should_cap_replica_count_when_smaller_than_distinct_nodes (line 274) | fn should_cap_replica_count_when_smaller_than_distinct_nodes() {
  function should_return_replicas_in_a_ring (line 287) | fn should_return_replicas_in_a_ring() {

FILE: cdrs-tokio/src/cluster/topology.rs
  type NodeMap (line 22) | pub type NodeMap<T, CM> = FxHashMap<Uuid, Arc<Node<T, CM>>>;

FILE: cdrs-tokio/src/cluster/topology/cluster_metadata.rs
  function build_datacenter_info (line 13) | fn build_datacenter_info<T: CdrsTransport, CM: ConnectionManager<T>>(
  type ClusterMetadata (line 34) | pub struct ClusterMetadata<T: CdrsTransport + 'static, CM: ConnectionMan...
  function new (line 42) | pub fn new(nodes: NodeMap<T, CM>, keyspaces: FxHashMap<String, KeyspaceM...
  function token_map (line 55) | pub fn token_map(&self) -> &TokenMap<T, CM> {
  function clone_with_keyspace (line 61) | pub fn clone_with_keyspace(&self, keyspace_name: String, keyspace: Keysp...
  function clone_without_keyspace (line 75) | pub fn clone_without_keyspace(&self, keyspace: &str) -> Self {
  function clone_with_node (line 89) | pub fn clone_with_node(&self, node: Node<T, CM>) -> Self {
  function clone_without_node (line 111) | pub fn clone_without_node(&self, broadcast_rpc_address: SocketAddr) -> S...
  function nodes (line 129) | pub fn nodes(&self) -> &NodeMap<T, CM> {
  function keyspaces (line 135) | pub fn keyspaces(&self) -> &FxHashMap<String, KeyspaceMetadata> {
  function keyspace (line 141) | pub fn keyspace(&self, keyspace: &str) -> Option<&KeyspaceMetadata> {
  function datacenters (line 147) | pub fn datacenters(&self) -> &FxHashMap<String, DatacenterMetadata> {
  function datacenter (line 153) | pub fn datacenter(&self, name: &str) -> Option<&DatacenterMetadata> {
  function unignored_nodes (line 159) | pub fn unignored_nodes(&self) -> Vec<Arc<Node<T, CM>>> {
  function unignored_local_nodes (line 174) | pub fn unignored_local_nodes(&self) -> Vec<Arc<Node<T, CM>>> {
  function unignored_remote_nodes_capped (line 189) | pub fn unignored_remote_nodes_capped(&self, max_count: usize) -> Vec<Arc...
  function has_nodes (line 205) | pub fn has_nodes(&self) -> bool {
  function has_node_by_rpc_address (line 211) | pub fn has_node_by_rpc_address(&self, broadcast_rpc_address: SocketAddr)...
  function find_node_by_rpc_address (line 219) | pub fn find_node_by_rpc_address(
  function find_node_by_host_id (line 231) | pub fn find_node_by_host_id(&self, host_id: &Uuid) -> Option<Arc<Node<T,...
  method default (line 237) | fn default() -> Self {
  function should_build_datacenter_info (line 265) | fn should_build_datacenter_info() {

FILE: cdrs-tokio/src/cluster/topology/datacenter_metadata.rs
  type DatacenterMetadata (line 5) | pub struct DatacenterMetadata {

FILE: cdrs-tokio/src/cluster/topology/keyspace_metadata.rs
  type KeyspaceMetadata (line 7) | pub struct KeyspaceMetadata {

FILE: cdrs-tokio/src/cluster/topology/node.rs
  type Node (line 20) | pub struct Node<T: CdrsTransport + 'static, CM: ConnectionManager<T> + '...
  method fmt (line 34) | fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
  function new (line 50) | pub(crate) fn new(
  function new_with_state (line 75) | pub(crate) fn new_with_state(
  function with_state (line 101) | pub(crate) fn with_state(
  function with_distance (line 126) | pub(crate) fn with_distance(
  function state (line 148) | pub fn state(&self) -> NodeState {
  function host_id (line 155) | pub fn host_id(&self) -> Option<Uuid> {
  function broadcast_rpc_address (line 162) | pub fn broadcast_rpc_address(&self) -> SocketAddr {
  function broadcast_address (line 169) | pub fn broadcast_address(&self) -> Option<SocketAddr> {
  function tokens (line 175) | pub fn tokens(&self) -> &[Murmur3Token] {
  function datacenter (line 181) | pub fn datacenter(&self) -> &str {
  function rack (line 187) | pub fn rack(&self) -> &str {
  function persistent_connection (line 193) | pub async fn persistent_connection(self: &Arc<Self>) -> Result<Arc<T>> {
  function is_any_connection_up (line 221) | pub async fn is_any_connection_up(&self) -> bool {
  function new_connection (line 230) | pub async fn new_connection(
  function distance (line 244) | pub fn distance(&self) -> Option<NodeDistance> {
  function is_local (line 250) | pub fn is_local(&self) -> bool {
  function is_remote (line 256) | pub fn is_remote(&self) -> bool {
  function is_ignored (line 262) | pub fn is_ignored(&self) -> bool {
  function force_down (line 266) | pub(crate) fn force_down(&self) {
  function mark_down (line 270) | pub(crate) fn mark_down(&self) {
  function mark_up (line 274) | pub(crate) fn mark_up(&self) {
  function clone_with_node_info (line 279) | pub(crate) fn clone_with_node_info(&self, node_info: NodeInfo) -> Self {
  function clone_as_contact_point (line 323) | pub(crate) fn clone_as_contact_point(&self, node_info: NodeInfo) -> Self {
  function clone_with_node_info_and_state (line 340) | pub(crate) fn clone_with_node_info_and_state(
  function clone_with_node_state (line 361) | pub(crate) fn clone_with_node_state(&self, state: NodeState) -> Self {

FILE: cdrs-tokio/src/cluster/topology/node_distance.rs
  type NodeDistance (line 5) | pub enum NodeDistance {

FILE: cdrs-tokio/src/cluster/topology/node_state.rs
  type NodeState (line 7) | pub enum NodeState {

FILE: cdrs-tokio/src/cluster/topology/replication_strategy.rs
  type ReplicationStrategy (line 5) | pub enum ReplicationStrategy {

FILE: cdrs-tokio/src/envelope_parser.rs
  constant MAX_ENVELOPE_BODY_SIZE (line 22) | const MAX_ENVELOPE_BODY_SIZE: usize = 256 * 1024 * 1024;
  function parse_raw_envelope (line 24) | async fn parse_raw_envelope<T: AsyncReadExt + Unpin>(
  function parse_envelope (line 120) | pub async fn parse_envelope<T: AsyncReadExt + Unpin>(
  function convert_envelope_into_result (line 129) | pub(crate) fn convert_envelope_into_result(
  function header_with_length (line 156) | fn header_with_length(length_bytes: [u8; 4]) -> Vec<u8> {
  function parse_envelope_rejects_negative_body_length (line 169) | async fn parse_envelope_rejects_negative_body_length() {
  function parse_envelope_rejects_oversized_body_length (line 186) | async fn parse_envelope_rejects_oversized_body_length() {
  function parse_envelope_does_not_read_tracing_id_for_request_direction (line 205) | async fn parse_envelope_does_not_read_tracing_id_for_request_direction() {

FILE: cdrs-tokio/src/frame_encoding.rs
  type FrameEncodingFactory (line 11) | pub trait FrameEncodingFactory {
    method create_encoder (line 13) | fn create_encoder(
    method create_decoder (line 20) | fn create_decoder(
    method create_encoder (line 32) | fn create_encoder(
    method create_decoder (line 48) | fn create_decoder(
  type ProtocolFrameEncodingFactory (line 29) | pub struct ProtocolFrameEncodingFactory;

FILE: cdrs-tokio/src/future.rs
  type BoxFuture (line 3) | pub type BoxFuture<'a, T> = futures::future::BoxFuture<'a, T>;

FILE: cdrs-tokio/src/lib.rs
  type Error (line 65) | pub type Error = error::Error;
  type Result (line 66) | pub type Result<T> = error::Result<T>;

FILE: cdrs-tokio/src/load_balancing.rs
  type QueryPlan (line 20) | pub struct QueryPlan<T: CdrsTransport + 'static, CM: ConnectionManager<T...
  method clone (line 25) | fn clone(&self) -> Self {
  type LoadBalancingStrategy (line 31) | pub trait LoadBalancingStrategy<T: CdrsTransport, CM: ConnectionManager<...
    method query_plan (line 34) | fn query_plan(

FILE: cdrs-tokio/src/load_balancing/initializing_wrapper.rs
  type InitializingWrapperLoadBalancingStrategy (line 9) | pub struct InitializingWrapperLoadBalancingStrategy<
  function query_plan (line 21) | fn query_plan(
  function new (line 37) | pub fn new(inner: LB, contact_points: Vec<Arc<Node<T, CM>>>) -> Self {

FILE: cdrs-tokio/src/load_balancing/node_distance_evaluator.rs
  type NodeDistanceEvaluator (line 9) | pub trait NodeDistanceEvaluator {
    method compute_distance (line 13) | fn compute_distance(&self, node: &NodeInfo) -> Option<NodeDistance>;
    method compute_distance (line 21) | fn compute_distance(&self, _node: &NodeInfo) -> Option<NodeDistance> {
    method compute_distance (line 35) | fn compute_distance(&self, node: &NodeInfo) -> Option<NodeDistance> {
  type AllLocalNodeDistanceEvaluator (line 18) | pub struct AllLocalNodeDistanceEvaluator;
  type TopologyAwareNodeDistanceEvaluator (line 30) | pub struct TopologyAwareNodeDistanceEvaluator {
    method new (line 46) | pub fn new(local_dc: String) -> Self {
  function should_return_topology_aware_distance (line 63) | fn should_return_topology_aware_distance() {

FILE: cdrs-tokio/src/load_balancing/random.rs
  type RandomLoadBalancingStrategy (line 14) | pub struct RandomLoadBalancingStrategy<T: CdrsTransport, CM: ConnectionM...
  function new (line 22) | pub fn new() -> Self {
  function query_plan (line 33) | fn query_plan(

FILE: cdrs-tokio/src/load_balancing/request.rs
  type Request (line 8) | pub struct Request<'a> {

FILE: cdrs-tokio/src/load_balancing/round_robin.rs
  type RoundRobinLoadBalancingStrategy (line 12) | pub struct RoundRobinLoadBalancingStrategy<T: CdrsTransport, CM: Connect...
  function new (line 21) | pub fn new() -> Self {
  function query_plan (line 33) | fn query_plan(

FILE: cdrs-tokio/src/load_balancing/topology_aware.rs
  type TopologyAwareLoadBalancingStrategy (line 32) | pub struct TopologyAwareLoadBalancingStrategy<T: CdrsTransport, CM: Conn...
  function query_plan (line 45) | fn query_plan(
  function new (line 63) | pub fn new(
  function replicas_for_request (line 76) | fn replicas_for_request(
  function replicas_for_token (line 92) | fn replicas_for_token(
  function replicas_for_keyspace (line 105) | fn replicas_for_keyspace(
  function network_topology_strategy_replicas (line 128) | fn network_topology_strategy_replicas(
  function simple_strategy_replicas (line 258) | fn simple_strategy_replicas(
  function round_robin_unignored_nodes (line 288) | fn round_robin_unignored_nodes(
  function round_robin_unignored_local_nodes (line 303) | fn round_robin_unignored_local_nodes(
  function create_cluster (line 348) | fn create_cluster(
  function should_return_nodes_without_request (line 497) | fn should_return_nodes_without_request() {
  function should_return_local_nodes_without_request (line 510) | fn should_return_local_nodes_without_request() {
  function should_return_local_nodes_without_token (line 523) | fn should_return_local_nodes_without_token() {
  function should_return_local_nodes_without_keyspace (line 536) | fn should_return_local_nodes_without_keyspace() {
  function should_return_all_nodes_with_unknown_strategy (line 552) | fn should_return_all_nodes_with_unknown_strategy() {
  function should_return_replica_nodes_with_simple_strategy (line 570) | fn should_return_replica_nodes_with_simple_strategy() {
  function simple_strategy_uses_unignored_nodes_when_ring_starts_on_ignored (line 610) | fn simple_strategy_uses_unignored_nodes_when_ring_starts_on_ignored() {
  function should_return_topology_aware_nodes_with_network_topology_strategy_with_repeated_racks (line 651) | fn should_return_topology_aware_nodes_with_network_topology_strategy_wit...
  function should_return_topology_aware_nodes_with_network_topology_strategy (line 684) | fn should_return_topology_aware_nodes_with_network_topology_strategy() {
  function should_return_topology_aware_nodes_with_network_topology_strategy_with_remote (line 712) | fn should_return_topology_aware_nodes_with_network_topology_strategy_wit...

FILE: cdrs-tokio/src/retry/reconnection_policy.rs
  constant DEFAULT_BASE_DELAY (line 7) | const DEFAULT_BASE_DELAY: Duration = Duration::from_secs(1);
  constant DEFAULT_MAX_DELAY (line 8) | const DEFAULT_MAX_DELAY: Duration = Duration::from_secs(60);
  type ReconnectionSchedule (line 11) | pub trait ReconnectionSchedule {
    method next_delay (line 13) | fn next_delay(&mut self) -> Option<Duration>;
    method next_delay (line 47) | fn next_delay(&mut self) -> Option<Duration> {
    method next_delay (line 65) | fn next_delay(&mut self) -> Option<Duration> {
    method next_delay (line 119) | fn next_delay(&mut self) -> Option<Duration> {
  type ReconnectionPolicy (line 18) | pub trait ReconnectionPolicy {
    method new_node_schedule (line 20) | fn new_node_schedule(&self) -> Box<dyn ReconnectionSchedule + Send + S...
    method new_node_schedule (line 36) | fn new_node_schedule(&self) -> Box<dyn ReconnectionSchedule + Send + S...
    method new_node_schedule (line 57) | fn new_node_schedule(&self) -> Box<dyn ReconnectionSchedule + Send + S...
    method new_node_schedule (line 89) | fn new_node_schedule(&self) -> Box<dyn ReconnectionSchedule + Send + S...
  type ConstantReconnectionPolicy (line 25) | pub struct ConstantReconnectionPolicy {
  method default (line 30) | fn default() -> Self {
  type ConstantReconnectionSchedule (line 42) | struct ConstantReconnectionSchedule {
  type NeverReconnectionPolicy (line 54) | pub struct NeverReconnectionPolicy;
  type NeverReconnectionSchedule (line 62) | struct NeverReconnectionSchedule;
  type ExponentialReconnectionPolicy (line 80) | pub struct ExponentialReconnectionPolicy {
  method default (line 99) | fn default() -> Self {
  type ExponentialReconnectionSchedule (line 111) | struct ExponentialReconnectionSchedule {
    method new (line 148) | pub fn new(base_delay: Duration, max_delay: Duration, max_attempts: us...
  function should_reach_max_exponential_delay_without_panic (line 164) | fn should_reach_max_exponential_delay_without_panic() {
  function saturated_schedule_keeps_returning_max_delay (line 180) | fn saturated_schedule_keeps_returning_max_delay() {

FILE: cdrs-tokio/src/retry/retry_policy.rs
  type RetryDecision (line 9) | pub enum RetryDecision {
  type QueryInfo (line 16) | pub struct QueryInfo<'a> {
  type RetrySession (line 22) | pub trait RetrySession {
    method decide (line 24) | fn decide(&mut self, query_info: QueryInfo) -> RetryDecision;
    method decide (line 47) | fn decide(&mut self, _query_info: QueryInfo) -> RetryDecision {
    method decide (line 71) | fn decide(&mut self, query_info: QueryInfo) -> RetryDecision {
  type RetryPolicy (line 28) | pub trait RetryPolicy {
    method new_session (line 30) | fn new_session(&self) -> Box<dyn RetrySession + Send + Sync>;
    method new_session (line 38) | fn new_session(&self) -> Box<dyn RetrySession + Send + Sync> {
    method new_session (line 58) | fn new_session(&self) -> Box<dyn RetrySession + Send + Sync> {
  type FallthroughRetryPolicy (line 35) | pub struct FallthroughRetryPolicy;
  type FallthroughRetrySession (line 44) | pub struct FallthroughRetrySession;
  type DefaultRetryPolicy (line 55) | pub struct DefaultRetryPolicy;
  type DefaultRetrySession (line 64) | pub struct DefaultRetrySession {

FILE: cdrs-tokio/src/speculative_execution.rs
  type Context (line 18) | pub struct Context {
  type SpeculativeExecutionPolicy (line 26) | pub trait SpeculativeExecutionPolicy {
    method execution_interval (line 29) | fn execution_interval(&self, context: &Context) -> Option<Duration>;
    method execution_interval (line 41) | fn execution_interval(&self, context: &Context) -> Option<Duration> {
  type ConstantSpeculativeExecutionPolicy (line 35) | pub struct ConstantSpeculativeExecutionPolicy {

FILE: cdrs-tokio/src/statement/statement_params.rs
  type StatementParams (line 13) | pub struct StatementParams {

FILE: cdrs-tokio/src/statement/statement_params_builder.rs
  type StatementParamsBuilder (line 15) | pub struct StatementParamsBuilder {
    method new (line 39) | pub fn new() -> StatementParamsBuilder {
    method with_consistency (line 45) | pub fn with_consistency(mut self, consistency: Consistency) -> Self {
    method with_flags (line 52) | pub fn with_flags(mut self, flags: QueryFlags) -> Self {
    method with_values (line 59) | pub fn with_values(mut self, values: QueryValues) -> Self {
    method with_names (line 75) | pub fn with_names(mut self, with_names: bool) -> Self {
    method with_page_size (line 82) | pub fn with_page_size(mut self, size: i32) -> Self {
    method with_paging_state (line 91) | pub fn with_paging_state(mut self, state: CBytes) -> Self {
    method with_serial_consistency (line 100) | pub fn with_serial_consistency(mut self, serial_consistency: Consisten...
    method with_timestamp (line 107) | pub fn with_timestamp(mut self, timestamp: i64) -> Self {
    method with_keyspace (line 114) | pub fn with_keyspace(mut self, keyspace: String) -> Self {
    method with_token (line 121) | pub fn with_token(mut self, token: Murmur3Token) -> Self {
    method with_routing_key (line 128) | pub fn with_routing_key(mut self, routing_key: Vec<Value>) -> Self {
    method idempotent (line 135) | pub fn idempotent(mut self, value: bool) -> Self {
    method with_speculative_execution_policy (line 142) | pub fn with_speculative_execution_policy(
    method with_retry_policy (line 152) | pub fn with_retry_policy(mut self, retry_policy: Arc<dyn RetryPolicy +...
    method with_beta_protocol (line 159) | pub fn with_beta_protocol(mut self, beta_protocol: bool) -> Self {
    method with_now_in_seconds (line 166) | pub fn with_now_in_seconds(mut self, now_in_seconds: CInt) -> Self {
    method build (line 172) | pub fn build(self) -> StatementParams {

FILE: cdrs-tokio/src/transport.rs
  constant INITIAL_STREAM_ID (line 50) | const INITIAL_STREAM_ID: i16 = 1;
  type CdrsTransport (line 53) | pub trait CdrsTransport: Send + Sync {
    method write_envelope (line 56) | fn write_envelope<'a>(
    method is_broken (line 63) | fn is_broken(&self) -> bool;
    method address (line 66) | fn address(&self) -> SocketAddr;
    method write_envelope (line 155) | fn write_envelope<'a>(
    method is_broken (line 164) | fn is_broken(&self) -> bool {
    method address (line 169) | fn address(&self) -> SocketAddr {
    method write_envelope (line 254) | fn write_envelope<'a>(
    method is_broken (line 263) | fn is_broken(&self) -> bool {
    method address (line 268) | fn address(&self) -> SocketAddr {
  type TransportTcp (line 89) | pub struct TransportTcp {
    method new (line 95) | pub async fn new(
    method with_stream (line 123) | pub fn with_stream<T: AsyncRead + AsyncWrite + Send + Sync + 'static>(
  type TransportRustls (line 176) | pub struct TransportRustls {
    method new (line 183) | pub async fn new(
    method with_stream (line 216) | pub async fn with_stream<T: AsyncRead + AsyncWrite + Send + Sync + Unp...
  type AsyncTransport (line 274) | struct AsyncTransport {
    method new (line 290) | fn new<T: AsyncRead + AsyncWrite + Send + 'static>(
    method is_broken (line 329) | fn is_broken(&self) -> bool {
    method addr (line 334) | fn addr(&self) -> SocketAddr {
    method write_envelope (line 338) | async fn write_envelope(&self, envelope: &Envelope, handshake: bool) -...
    method start_processing (line 361) | async fn start_processing<T: AsyncRead + AsyncWrite>(
    method start_reading_handshake_frames (line 409) | async fn start_reading_handshake_frames(
    method start_reading_normal_frames (line 452) | async fn start_reading_normal_frames(
    method start_writing (line 506) | async fn start_writing(
    method write_self_contained_frame (line 606) | async fn write_self_contained_frame(
    method write_frame (line 632) | async fn write_frame(
    method notify_error_handlers (line 656) | fn notify_error_handlers(
  method drop (line 283) | fn drop(&mut self) {
  type ResponseHandler (line 668) | type ResponseHandler = oneshot::Sender<Result<Envelope>>;
  type ResponseHandlerMap (line 670) | struct ResponseHandlerMap {
    method new (line 677) | pub fn new() -> Self {
    method add_handler (line 685) | pub fn add_handler(&self, stream_id: StreamId, handler: ResponseHandle...
    method send_response (line 692) | pub fn send_response(&self, stream_id: StreamId, response: Result<Enve...
    method signal_general_error (line 703) | pub fn signal_general_error(&self, error: &Error) {
    method next_stream_id (line 709) | pub fn next_stream_id(&self) -> StreamId {
  type Request (line 762) | struct Request {
    method set_stream_id (line 770) | fn set_stream_id(&mut self, stream_d: StreamId) {
  function write_self_contained_frame_clears_stream_ids_on_success (line 787) | async fn write_self_contained_frame_clears_stream_ids_on_success() {
  function next_stream_id_starts_at_initial_value (line 825) | fn next_stream_id_starts_at_initial_value() {
  function next_stream_id_wraps_to_initial_after_overflow (line 832) | fn next_stream_id_wraps_to_initial_after_overflow() {

FILE: cdrs-tokio/tests/collection_types.rs
  function list_v4 (line 30) | async fn list_v4() {
  function list_v5 (line 41) | async fn list_v5() {
  function list_test (line 51) | async fn list_test(session: CurrentSession) {
  function list_advanced_v4 (line 100) | async fn list_advanced_v4() {
  function list_advanced_v5 (line 111) | async fn list_advanced_v5() {
  function list_advanced_test (line 121) | async fn list_advanced_test(session: CurrentSession) {
  function set_v4 (line 174) | async fn set_v4() {
  function set_v5 (line 185) | async fn set_v5() {
  function set_test (line 195) | async fn set_test(session: CurrentSession) {
  function set_advanced_v4 (line 248) | async fn set_advanced_v4() {
  function set_advanced_v5 (line 259) | async fn set_advanced_v5() {
  function set_advanced_test (line 269) | async fn set_advanced_test(session: CurrentSession) {
  function map_without_blob_v4 (line 322) | async fn map_without_blob_v4() {
  function map_without_blob_v5 (line 334) | async fn map_without_blob_v5() {
  function map_without_blob_test (line 345) | async fn map_without_blob_test(session: CurrentSession) {
  function map_without_blob_advanced_v4 (line 410) | async fn map_without_blob_advanced_v4() {
  function map_without_blob_advanced_v5 (line 421) | async fn map_without_blob_advanced_v5() {
  function map_without_blob_advanced_test (line 431) | async fn map_without_blob_advanced_test(session: CurrentSession) {
  function map_v4 (line 496) | async fn map_v4() {
  function map_v5 (line 507) | async fn map_v5() {
  function map_test (line 517) | async fn map_test(session: CurrentSession) {

FILE: cdrs-tokio/tests/common.rs
  constant ADDR (line 26) | pub const ADDR: &str = "127.0.0.1:9042";
  type CurrentSession (line 29) | pub type CurrentSession = Session<
  function setup (line 37) | pub async fn setup(create_table_cql: &'static str, version: Version) -> ...
  function setup_multiple (line 42) | pub async fn setup_multiple(

FILE: cdrs-tokio/tests/compression.rs
  function encode_decode_test (line 31) | async fn encode_decode_test(version: Version) {
  function encode_decode_test_v4 (line 97) | async fn encode_decode_test_v4() {
  function encode_decode_test_v5 (line 103) | async fn encode_decode_test_v5() {

FILE: cdrs-tokio/tests/derive_traits.rs
  function simple_udt_v4 (line 37) | async fn simple_udt_v4() {
  function simple_udt_v5 (line 50) | async fn simple_udt_v5() {
  function simple_udt_test (line 62) | async fn simple_udt_test(session: CurrentSession) {
  function nested_udt_v4 (line 117) | async fn nested_udt_v4() {
  function nested_udt_v5 (line 135) | async fn nested_udt_v5() {
  function nested_udt_test (line 152) | async fn nested_udt_test(session: CurrentSession) {
  function alter_udt_add_v4 (line 210) | async fn alter_udt_add_v4() {
  function alter_udt_add_v5 (line 233) | async fn alter_udt_add_v5() {
  function alter_udt_add_test (line 255) | async fn alter_udt_add_test(session: CurrentSession) {
  function update_list_with_udt_v4 (line 327) | async fn update_list_with_udt_v4() {
  function update_list_with_udt_v5 (line 351) | async fn update_list_with_udt_v5() {
  function update_list_with_udt_test (line 374) | async fn update_list_with_udt_test(session: CurrentSession) {

FILE: cdrs-tokio/tests/keyspace.rs
  function create_keyspace (line 25) | async fn create_keyspace() {
  function alter_keyspace (line 99) | async fn alter_keyspace() {
  function use_keyspace (line 164) | async fn use_keyspace() {
  function drop_keyspace (line 202) | async fn drop_keyspace() {

FILE: cdrs-tokio/tests/multi_node_speculative_execution.rs
  function multi_node_speculative_execution (line 27) | async fn multi_node_speculative_execution() {

FILE: cdrs-tokio/tests/multithread.rs
  function multithread (line 16) | async fn multithread() {

FILE: cdrs-tokio/tests/native_types.rs
  function string_v4 (line 34) | async fn string_v4() {
  function string_v5 (line 44) | async fn string_v5() {
  function string_test (line 53) | async fn string_test(session: CurrentSession) {
  function counter_v4 (line 89) | async fn counter_v4() {
  function counter_v5 (line 99) | async fn counter_v5() {
  function counter_test (line 108) | async fn counter_test(session: CurrentSession) {
  function integer_v4 (line 142) | async fn integer_v4() {
  function integer_v5 (line 153) | async fn integer_v5() {
  function integer_test (line 162) | async fn integer_test(session: CurrentSession) {
  function integer_advanced_v4 (line 199) | async fn integer_advanced_v4() {
  function integer_advanced_v5 (line 211) | async fn integer_advanced_v5() {
  function integer_advanced_test (line 221) | async fn integer_advanced_test(session: CurrentSession) {
  function float_v4 (line 263) | async fn float_v4() {
  function float_v5 (line 273) | async fn float_v5() {
  function float_test (line 282) | async fn float_test(session: CurrentSession) {
  function blob_v4 (line 325) | async fn blob_v4() {
  function blob_v5 (line 335) | async fn blob_v5() {
  function blob_test (line 344) | async fn blob_test(session: CurrentSession) {
  function uuid_v4 (line 396) | async fn uuid_v4() {
  function uuid_v5 (line 407) | async fn uuid_v5() {
  function uuid_test (line 416) | async fn uuid_test(session: CurrentSession) {
  function time_v4 (line 446) | async fn time_v4() {
  function time_v5 (line 457) | async fn time_v5() {
  function time_test (line 466) | async fn time_test(session: CurrentSession) {
  function inet_v4 (line 500) | async fn inet_v4() {
  function inet_v5 (line 510) | async fn inet_v5() {
  function inet_test (line 519) | async fn inet_test(session: CurrentSession) {

FILE: cdrs-tokio/tests/paged_query.rs
  function paged_query (line 16) | async fn paged_query() {

FILE: cdrs-tokio/tests/query_values.rs
  function query_values_in_v4 (line 14) | async fn query_values_in_v4() {
  function query_values_in_v5 (line 24) | async fn query_values_in_v5() {
  function query_values_in_test (line 33) | async fn query_values_in_test(cql: &str, session: CurrentSession) {

FILE: cdrs-tokio/tests/single_node_speculative_execution.rs
  function single_node_speculative_execution (line 27) | async fn single_node_speculative_execution() {

FILE: cdrs-tokio/tests/topology_aware.rs
  function query_topology_aware (line 27) | async fn query_topology_aware() {

FILE: cdrs-tokio/tests/tuple_types.rs
  function simple_tuple_v4 (line 36) | async fn simple_tuple_v4() {
  function nested_tuples_v4 (line 100) | async fn nested_tuples_v4() {
  function simple_tuple_v5 (line 218) | async fn simple_tuple_v5() {
  function nested_tuples_v5 (line 282) | async fn nested_tuples_v5() {

FILE: cdrs-tokio/tests/user_defined_types.rs
  type TestStaticStrReference (line 36) | pub struct TestStaticStrReference {
  function simple_udt_v4 (line 42) | async fn simple_udt_v4() {
  function nested_udt_v4 (line 104) | async fn nested_udt_v4() {
  function alter_udt_add_v4 (line 195) | async fn alter_udt_add_v4() {
  function simple_udt_v5 (line 291) | async fn simple_udt_v5() {
  function nested_udt_v5 (line 353) | async fn nested_udt_v5() {
  function alter_udt_add_v5 (line 444) | async fn alter_udt_add_v5() {