1 files changed, 242 insertions, 0 deletions
diff --git a/include/osl/pipe_decl.hxx b/include/osl/pipe_decl.hxx
new file mode 100644
index 0000000000..cad7538c7d
--- /dev/null
+++ b/include/osl/pipe_decl.hxx
@@ -0,0 +1,242 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+/*
+ * This file is part of LibreOffice published API.
+ */
+#ifndef INCLUDED_OSL_PIPE_DECL_HXX
+#define INCLUDED_OSL_PIPE_DECL_HXX
+
+#include "osl/pipe.h"
+#include "osl/security.hxx"
+#include "rtl/ustring.hxx"
+
+namespace osl
+{
+class StreamPipe;
+
+/** Represents a pipe.
+*/
+class Pipe
+{
+protected:
+    oslPipe m_handle;
+
+public:
+    /** Does not create a pipe. Use assignment operator to
+        make this a usable pipe.
+    */
+    inline Pipe();
+
+    /** Creates an insecure pipe that is accessible for all users.
+        @param strName
+        @param Options
+    */
+    inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options);
+
+    /** Creates a secure pipe that access depends on the umask settings.
+        @param strName
+        @param Options
+        @param rSecurity
+    */
+    inline Pipe(const ::rtl::OUString& strName, oslPipeOptions Options, const Security& rSecurity);
+
+    /** Copy constructor.
+    */
+    inline Pipe(const Pipe& pipe);
+
+#if defined LIBO_INTERNAL_ONLY
+    inline Pipe(Pipe&& other) noexcept;
+#endif
+
+    /** Constructs a Pipe reference without acquiring the handle
+    */
+    inline Pipe(oslPipe pipe, __sal_NoAcquire noacquire);
+
+    /** Creates pipe as wrapper around the underlying oslPipe.
+        @param Pipe
+    */
+    inline Pipe(oslPipe Pipe);
+
+    /** Destructor. Destroys the underlying oslPipe.
+    */
+    inline ~Pipe();
+
+    inline bool SAL_CALL is() const;
+
+    /** Creates an insecure pipe that is accessible for all users
+        with the given attributes.
+        If the pipe was already created, the old one will be discarded.
+        @param strName
+        @param Options
+        @param rSec
+        @return True if socket was successfully created.
+    */
+    inline bool create(const ::rtl::OUString& strName, oslPipeOptions Options,
+                       const Security& rSec);
+
+    /** Creates a secure that access rights depend on the umask settings
+        with the given attributes.
+
+        If socket was already created, the old one will be discarded.
+        @param strName
+        @param Options
+        @return True if socket was successfully created.
+    */
+    inline bool create(const ::rtl::OUString& strName, oslPipeOptions Options = osl_Pipe_OPEN);
+
+    /** releases the underlying handle
+     */
+    inline void SAL_CALL clear();
+
+    /** Assignment operator. If pipe was already created, the old one will
+        be discarded.
+    */
+    inline Pipe& SAL_CALL operator=(const Pipe& pipe);
+
+#if defined LIBO_INTERNAL_ONLY
+    inline Pipe& operator=(Pipe&& other) noexcept;
+#endif
+
+    /** Assignment operator. If pipe was already created, the old one will
+        be discarded.
+    */
+    inline Pipe& SAL_CALL operator=(const oslPipe pipe);
+
+    /** Checks if the pipe is valid.
+        @return True if the object represents a valid pipe.
+    */
+    inline bool SAL_CALL isValid() const;
+
+    inline bool SAL_CALL operator==(const Pipe& rPipe) const;
+
+    /** Closes the pipe.
+    */
+    inline void SAL_CALL close();
+
+    /** Accept connection on an existing pipe
+    */
+    inline oslPipeError SAL_CALL accept(StreamPipe& Connection);
+
+    /** Delivers a constant describing the last error for the pipe system.
+        @return ENONE if no error occurred, invalid_PipeError if
+        an unknown (unmapped) error occurred, otherwise an enum describing the
+        error.
+    */
+    inline oslPipeError SAL_CALL getError() const;
+
+    inline oslPipe SAL_CALL getHandle() const;
+};
+
+/** A pipe to send or receive a stream of data.
+*/
+class StreamPipe : public Pipe
+{
+public:
+    /** Creates an unattached pipe. You must attach the pipe to an oslPipe
+        e.g. by using the operator=(oslPipe), before you can use the stream-
+        functionality of the object.
+    */
+    inline StreamPipe();
+
+    /** Creates pipe as wrapper around the underlying oslPipe.
+
+        @param Pipe
+    */
+    inline StreamPipe(oslPipe Pipe);
+
+    /** Creates a pipe.
+
+        @param[in] strName Pipe name
+        @param[in] Options Pipe options
+    */
+    inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options = osl_Pipe_OPEN);
+
+    /** Creates a pipe.
+
+        @param[in] strName Pipe name
+        @param[in] Options Pipe options
+        @param[in] rSec    Security for the pipe
+    */
+    inline StreamPipe(const ::rtl::OUString& strName, oslPipeOptions Options, const Security& rSec);
+
+    /** Constructs a Pipe reference without acquiring the handle
+    */
+    inline StreamPipe(oslPipe pipe, __sal_NoAcquire noacquire);
+
+    /** Attaches the oslPipe to this object. If the object
+        already was attached to an oslPipe, the old one will
+        be closed and destroyed.
+
+        @param[in] Pipe    Pipe to attach to this object
+    */
+    inline StreamPipe& SAL_CALL operator=(oslPipe Pipe);
+
+    /** Assignment operator
+    */
+    inline StreamPipe& SAL_CALL operator=(const Pipe& pipe);
+
+    /** Tries to receives BytesToRead data from the connected pipe,
+
+        @param[out] pBuffer Points to a buffer that will be filled with the received
+                     data.
+        @param[in] BytesToRead The number of bytes to read. pBuffer must have at least
+                     this size.
+
+        @return the number of received bytes.
+    */
+    inline sal_Int32 SAL_CALL recv(void* pBuffer, sal_Int32 BytesToRead) const;
+
+    /** Tries to sends BytesToSend data from the connected pipe.
+
+        @param[in] pBuffer Points to a buffer that contains the send-data.
+        @param[in] BytesToSend The number of bytes to send. pBuffer must have at least
+                       this size.
+
+        @return the number of transferred bytes.
+    */
+    inline sal_Int32 SAL_CALL send(const void* pBuffer, sal_Int32 BytesToSend) const;
+
+    /** Retrieves n bytes from the stream and copies them into pBuffer.
+        The method avoids incomplete reads due to packet boundaries.
+
+        @param[in] pBuffer receives the read data.
+        @param[in] n the number of bytes to read. pBuffer must be large enough
+        to hold the n bytes!
+
+        @return the number of read bytes. The number will only be smaller than
+            n if an exceptional condition (e.g. connection closed) occurs.
+    */
+    inline sal_Int32 SAL_CALL read(void* pBuffer, sal_Int32 n) const;
+
+    /** Writes n bytes from pBuffer to the stream. The method avoids
+        incomplete writes due to packet boundaries.
+
+        @param[in] pBuffer contains the data to be written.
+        @param[in] n the number of bytes to write.
+
+        @return the number of written bytes. The number will only be smaller than
+            n if an exceptional condition (e.g. connection closed) occurs.
+    */
+    sal_Int32 SAL_CALL write(const void* pBuffer, sal_Int32 n) const;
+};
+}
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */