/*

* All rights reserved.

* See the COPYING file for more information.

*/

#include <Swiften/Base/LogSerializers.h>

#include <Swiften/Elements/Presence.h>

namespace Swift {

std::ostream& operator<<(std::ostream& stream, const Presence& presence) {

std::string typeString;

switch (presence.getType()) {

case Presence::Available:

typeString = "Available";

break;

case Presence::Error:

typeString = "Error";

break;

case Presence::Probe:

typeString = "Probe";

break;

case Presence::Subscribe:

typeString = "Subscribe";

break;

case Presence::Subscribed:

typeString = "Subscribed";

break;

case Presence::Unavailable:

typeString = "Unavailable";

break;

case Presence::Unsubscribe:

typeString = "Unsubscribe";

break;

case Presence::Unsubscribed:

typeString = "Unsubscribed";

break;

}

std::string showTypeString;

switch (presence.getShow()) {

case StatusShow::Online:

showTypeString = "Online";

break;

case StatusShow::Away:

showTypeString = "Away";

break;

case StatusShow::FFC:

showTypeString = "FFC";

break;

case StatusShow::DND:

showTypeString = "DND";

break;

case StatusShow::XA:

showTypeString = "XA";

break;

case StatusShow::None:

showTypeString = "None";

break;

}

stream << "Presence(" << "from: " << presence.getFrom() << ", to: " << presence.getTo() << ", type: " << typeString << ", status: " << showTypeString << ", priority: " << presence.getPriority() << ", '" << presence.getStatus() << "'" << " )";

return stream;

}

};

::std::ostream& operator<<(::std::ostream& os, const boost::optional<std::string>& optStr) {

if (optStr.is_initialized()) {

return os << "boost::optional<std::string>(\"" << optStr.get() << "\")";

}

else {

return os << "boost::optional<std::string>()";

}

}

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <ostream>

#include <string>

#include <vector>

#include <boost/optional.hpp>

namespace Swift {

class Presence;

template <typename T>

std::ostream& operator<<(std::ostream& stream, const std::shared_ptr<T>& ptr) {

if (ptr) {

stream << *ptr;

}

else {

stream << "nullptr";

}

return stream;

}

template <typename T>

std::ostream& operator<<(std::ostream& stream, const std::vector<T>& vec) {

stream << "[";

if (!vec.empty()) {

auto it = std::begin(vec);

stream << *it;

++it;

for (auto end = std::end(vec); it != end; ++it) {

stream << ", " << *it;

}

}

stream << "]";

return stream;

}

std::ostream& operator<<(std::ostream& stream, const Presence& presence);

};

::std::ostream& operator<<(::std::ostream& os, const boost::optional<std::string>& optStr);

/*

* Copyright (c) 2011 Thilo Cestonaro

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

/*

* All rights reserved.

* See the COPYING file for more information.

*/

#pragma once

#include <memory>

#include <Swiften/Base/API.h>

#include <Swiften/Base/Error.h>

#include <Swiften/Base/String.h>

#include <Swiften/Base/URL.h>

#include <Swiften/Network/Connection.h>

#include <Swiften/Network/Connector.h>

#include <Swiften/Network/HostAddressPort.h>

#include <Swiften/Session/SessionStream.h>

#include <Swiften/TLS/TLSError.h>

namespace boost {

class thread;

namespace system {

class error_code;

}

}

class BOSHConnectionTest;

namespace Swift {

class XMLParserFactory;

class TLSContextFactory;

class TLSLayer;

struct TLSOptions;

class HighLayer;

class SWIFTEN_API BOSHError : public SessionStream::SessionStreamError {

public:

enum Type {

BadRequest, HostGone, HostUnknown, ImproperAddressing,

InternalServerError, ItemNotFound, OtherRequest, PolicyViolation,

RemoteConnectionFailed, RemoteStreamError, SeeOtherURI, SystemShutdown, UndefinedCondition,

NoError};

BOSHError(Type type) : SessionStream::SessionStreamError(SessionStream::SessionStreamError::ConnectionReadError), type(type) {}

typedef std::shared_ptr<BOSHError> ref;

private:

Type type;

};

class SWIFTEN_API BOSHConnection : public std::enable_shared_from_this<BOSHConnection> {

public:

typedef std::shared_ptr<BOSHConnection> ref;

static ref create(const URL& boshURL, Connector::ref connector, XMLParserFactory* parserFactory, TLSContextFactory* tlsContextFactory, const TLSOptions& tlsOptions) {

return ref(new BOSHConnection(boshURL, connector, parserFactory, tlsContextFactory, tlsOptions));

}

virtual ~BOSHConnection();

virtual void connect();

virtual void disconnect();

virtual void write(const SafeByteArray& data);

const std::string& getSID();

void setRID(unsigned long long rid);

void setSID(const std::string& sid);

void startStream(const std::string& to, unsigned long long rid);

void terminateStream();

bool isReadyToSend();

void restartStream();

bool setClientCertificate(CertificateWithKey::ref cert);

Certificate::ref getPeerCertificate() const;

std::vector<Certificate::ref> getPeerCertificateChain() const;

CertificateVerificationError::ref getPeerCertificateVerificationError() const;