contrib/llvm/tools/lldb/include/lldb/Core/StreamTee.h

   1 //===-- StreamTee.h ------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef liblldb_StreamTee_h_
  11 #define liblldb_StreamTee_h_
  12
  13 #include <limits.h>
  14
  15 #include "lldb/Core/Stream.h"
  16 #include "lldb/Host/Mutex.h"
  17
  18 namespace lldb_private {
  19
  20 class StreamTee : public Stream
  21 {
  22 public:
  23     StreamTee () :
  24         Stream (),
  25         m_streams_mutex (Mutex::eMutexTypeRecursive),
  26         m_streams ()
  27     {
  28     }
  29
  30     StreamTee (lldb::StreamSP &stream_sp):
  31         Stream (),
  32         m_streams_mutex (Mutex::eMutexTypeRecursive),
  33         m_streams ()
  34     {
  35         // No need to lock mutex during construction
  36         if (stream_sp)
  37             m_streams.push_back (stream_sp);
  38     }
  39
  40
  41     StreamTee (lldb::StreamSP &stream_sp, lldb::StreamSP &stream_2_sp) :
  42         Stream (),
  43         m_streams_mutex (Mutex::eMutexTypeRecursive),
  44         m_streams ()
  45     {
  46         // No need to lock mutex during construction
  47         if (stream_sp)
  48             m_streams.push_back (stream_sp);
  49         if (stream_2_sp)
  50             m_streams.push_back (stream_2_sp);
  51     }
  52
  53     StreamTee (const StreamTee &rhs) :
  54         Stream (rhs),
  55         m_streams_mutex (Mutex::eMutexTypeRecursive),
  56         m_streams() // Don't copy until we lock down "rhs"
  57     {
  58         Mutex::Locker locker (rhs.m_streams_mutex);
  59         m_streams = rhs.m_streams;
  60     }
  61
  62     virtual
  63     ~StreamTee ()
  64     {
  65     }
  66
  67     StreamTee &
  68     operator = (const StreamTee &rhs)
  69     {
  70         if (this != &rhs) {
  71             Stream::operator=(rhs);
  72             Mutex::Locker lhs_locker (m_streams_mutex);
  73             Mutex::Locker rhs_locker (rhs.m_streams_mutex);
  74             m_streams = rhs.m_streams;
  75         }
  76         return *this;
  77     }
  78
  79     virtual void
  80     Flush ()
  81     {
  82         Mutex::Locker locker (m_streams_mutex);
  83         collection::iterator pos, end;
  84         for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos)
  85         {
  86             // Allow for our collection to contain NULL streams. This allows
  87             // the StreamTee to be used with hard coded indexes for clients
  88             // that might want N total streams with only a few that are set
  89             // to valid values.
  90             Stream *strm = pos->get();
  91             if (strm)
  92                 strm->Flush ();
  93         }
  94     }
  95
  96     virtual size_t
  97     Write (const void *s, size_t length)
  98     {
  99         Mutex::Locker locker (m_streams_mutex);
 100         if (m_streams.empty())
 101             return 0;
 102
 103         size_t min_bytes_written = SIZE_MAX;
 104         collection::iterator pos, end;
 105         for (pos = m_streams.begin(), end = m_streams.end(); pos != end; ++pos)
 106         {
 107             // Allow for our collection to contain NULL streams. This allows
 108             // the StreamTee to be used with hard coded indexes for clients
 109             // that might want N total streams with only a few that are set
 110             // to valid values.
 111             Stream *strm = pos->get();
 112             if (strm)
 113             {
 114                 const size_t bytes_written = strm->Write (s, length);
 115                 if (min_bytes_written > bytes_written)
 116                     min_bytes_written = bytes_written;
 117             }
 118         }
 119         if (min_bytes_written == SIZE_MAX)
 120             return 0;
 121         return min_bytes_written;
 122     }
 123
 124     size_t
 125     AppendStream (const lldb::StreamSP &stream_sp)
 126     {
 127         size_t new_idx = m_streams.size();
 128         Mutex::Locker locker (m_streams_mutex);
 129         m_streams.push_back (stream_sp);
 130         return new_idx;
 131     }
 132
 133     size_t
 134     GetNumStreams () const
 135     {
 136         size_t result = 0;
 137         {
 138             Mutex::Locker locker (m_streams_mutex);
 139             result = m_streams.size();
 140         }
 141         return result;
 142     }
 143
 144     lldb::StreamSP
 145     GetStreamAtIndex (uint32_t idx)
 146     {
 147         lldb::StreamSP stream_sp;
 148         Mutex::Locker locker (m_streams_mutex);
 149         if (idx < m_streams.size())
 150             stream_sp = m_streams[idx];
 151         return stream_sp;
 152     }
 153
 154     void
 155     SetStreamAtIndex (uint32_t idx, const lldb::StreamSP& stream_sp)
 156     {
 157         Mutex::Locker locker (m_streams_mutex);
 158         // Resize our stream vector as necessary to fit as many streams
 159         // as needed. This also allows this class to be used with hard
 160         // coded indexes that can be used contain many streams, not all
 161         // of which are valid.
 162         if (idx >= m_streams.size())
 163             m_streams.resize(idx + 1);
 164         m_streams[idx] = stream_sp;
 165     }
 166
 167
 168 protected:
 169     typedef std::vector<lldb::StreamSP> collection;
 170     mutable Mutex m_streams_mutex;
 171     collection m_streams;
 172 };
 173
 174 } // namespace lldb_private
 175 #endif  // #ifndef liblldb_StreamTee_h_