//! General purposed interfaces for message queues. Now we provide the following implementations:

//!

//! - AMQP 0-9-1

//! - MQTT

//!

//! By using these classes, you can configure queues with the following properties:

//!

//! - Unicast or broadcast.

//! - Reliable or best-effort.

//!

//! **Notes**

//!

//! - MQTT uses **shared queues** to implement unicast.

//! - AMQP uses **confirm channels** to implement reliable publish, and MQTT uses **QoS 1** to

//!   implement reliable publish/subscribe.

//!

//! # Relationships of Connections and Queues

//!

//! The term **connection** describes a TCP/TLS connection to the message broker.

//! The term **queue** describes a message queue or a topic within a connection.

//! You can use one connection to manage multiple queues, or one connection to manage one queue.

//!

//! A queue can only be a receiver or a sender at a time.

//!

//! ### Connections for sender/receiver queues with the same name

//!

//! The sender and the receiver are usually different programs, there are two connections to hold

//! two queues.

//!

//! For the special case that a program acts both the sender and the receiver using the same queue:

//!

//! - The AMQP implementation uses one **Channel** for one queue, so the program can manages all

//!   queues with one connection.

//! - The MQTT implementation **MUST** uses one connection for one queue, or both sender and

//!   receiver will receive packets.

//!

//! # Test

//!

//! Please prepare a [RabbitMQ](https://www.rabbitmq.com/) broker and a [EMQX](https://emqx.io/)

//! broker at **localhost** for testing.

//!

//! - To install using Docker:

//!

//!       $ docker run --rm --name rabbitmq -d -p 5672:5672 rabbitmq:management-alpine

//!       $ docker run --rm --name emqx -d -p 1883:1883 emqx/emqx

//!

//! Then run the test:

//!

//!     $ cargo test --test integration_test -- --nocapture

//!

//! # Example

//!

//! Run RabbitMQ and then run AMQP example:

//!

//!     $ cargo run --example simple

//!

//! Run EMQX and then run MQTT example:

//!

//!     $ RUN_MQTT= cargo run --example simple

use std::{error::Error as StdError, fmt, sync::Arc};

use async_trait::async_trait;

use rand::{distributions::Alphanumeric, thread_rng, Rng};

pub mod connection;

pub mod queue;

mod amqp;

mod mqtt;

pub use amqp::{AmqpConnection, AmqpConnectionOptions, AmqpQueue, AmqpQueueOptions};

pub use mqtt::{MqttConnection, MqttConnectionOptions, MqttQueue, MqttQueueOptions};

use queue::{EventHandler, GmqQueue, MessageHandler, Status};

/// general-mq error.

#[derive(Clone, Debug)]

pub enum Error {

    /// The queue does not have [`MessageHandler`].

    NoMsgHandler,

    /// The connection is not connected or the queue (topic) is not

    /// connected (declared/subscribed).

    NotConnected,

    /// The queue is a receiver that cannot send messages.

    QueueIsReceiver,

}

#[derive(Clone)]

pub enum Queue {

    Amqp(AmqpQueue),

    Mqtt(MqttQueue),

}

#[derive(Clone)]

pub enum QueueOptions<'a> {

    Amqp(AmqpQueueOptions, &'a AmqpConnection),

    Mqtt(MqttQueueOptions, &'a MqttConnection),

}

/// Identifier length of inner handlers.

pub(crate) const ID_SIZE: usize = 24;

impl fmt::Display for Error {

        }

}

impl StdError for Error {}

impl Queue {

        }

}

#[async_trait]

impl GmqQueue for Queue {

        }

        }

        }

        }

        }

        }

        }

        }

        }

}

/// Generate random alphanumeric with the specified length.