Tanl Linguistic Pipeline

search/ixe/io/Socket.h

/*
**      IXE
**      io/Socket.h
** ----------------------------------------------------------------------
**      Copyright (c) 2004  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  IXE is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef IXE_io_Socket_H
#define IXE_io_Socket_H

// Settings
#include "platform.h"

// Standard
#ifdef _WIN32
# include <winsock2.h>
# include <mswsock.h>
# define MSG_DONTWAIT 0
# define socklen_t int
# define in_port_t u_short
#else
# include <arpa/inet.h>
# include <sys/socket.h>
# include <sys/time.h>
# include <errno.h>
# include <unistd.h>
# define INVALID_SOCKET -1
# define SOCKET_ERROR -1
# define SOCKET int
# define closesocket ::close
#endif

#ifdef MSG_NOSIGNAL
#define HAVE_MSG_NOSIGNAL
#else
#define MSG_NOSIGNAL 0
#endif

// local
#include "include/error.h"

namespace IXE {
namespace io {

// IPv4 for the time being
typedef unsigned long   InetAddress;

class AbstractSocket
{
public:

  ~AbstractSocket();

  bool          isOpen() const;

  void          close();

  size_t        read(char* buffer, size_t len);

  size_t        readAll(char* buffer, size_t len);

  size_t        write(char const* buffer, size_t len);

  size_t        write(char const* buffer) {
    return write(buffer, ::strlen(buffer));
  }

  size_t        write(std::string s) {
    return write(s.c_str(), s.length());
  }

  SOCKET        socket() { return sock; }

protected:

  AbstractSocket(SOCKET sock = INVALID_SOCKET, InetAddress inetAddress = 0,
                 in_port_t port = 0);

  void          copy(const AbstractSocket& r)
  {
    AbstractSocket& rhs = const_cast<AbstractSocket&>(r);
    sock = rhs.sock;
    inetAddress = rhs.inetAddress;
    port = rhs.port;
    rhs.sock = INVALID_SOCKET;  // avoid being closed twice
  }

  SOCKET        sock;
  InetAddress   inetAddress;
  in_port_t     port;
};

class Socket : public AbstractSocket
{
public:
  Socket() { }

  Socket(char const* host, int port);

  Socket(Socket const& other) { copy(other); }

  bool          connect(char const* host, int port);

  bool          open();

  InetAddress   Address() { return inetAddress; }

  in_port_t     Port() { return port; }

  Socket&       operator =(const Socket& rhs)
  {
    if (&rhs != this) {
      close();
      copy(rhs);
    }
    return *this;
  }

protected:
  friend class ServerSocket;
  Socket(SOCKET sock, InetAddress inetAddress, in_port_t port);
};

} // io
} // IXE

#endif // IXE_io_Socket_H

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.