Line data    Source code

       1             : /*
       2             :  * Copyright 2017 Google Inc.
       3             :  *
       4             :  * Use of this source code is governed by a BSD-style license that can be
       5             :  * found in the LICENSE file.
       6             :  */
       7             : 
       8             : #ifndef SKSL_STRINGSTREAM
       9             : #define SKSL_STRINGSTREAM
      10             : 
      11             : #include "SkSLOutputStream.h"
      12             : 
      13             : #ifdef SKSL_STANDALONE
      14             : 
      15             : namespace SkSL {
      16             : 
      17             : class StringStream : public OutputStream {
      18             : public:
      19             :     void write8(uint8_t b) override {
      20             :         fBuffer += (char) b;
      21             :     }
      22             : 
      23             :     void writeText(const char* s) override {
      24             :         fBuffer += s;
      25             :     }
      26             : 
      27             :     void write(const void* s, size_t size) override {
      28             :         fBuffer.append((const char*) s, size);
      29             :     }
      30             : 
      31             :     const char* data() const {
      32             :         return fBuffer.c_str();
      33             :     }
      34             : 
      35             :     size_t size() const {
      36             :         return fBuffer.size();
      37             :     }
      38             : 
      39             :     void reset() {
      40             :         fBuffer = "";
      41             :     }
      42             : 
      43             : private:
      44             :     String fBuffer;
      45             : };
      46             : 
      47             : #else
      48             : 
      49             : #include "SkData.h"
      50             : #include "SkStream.h"
      51             : 
      52             : namespace SkSL {
      53             : 
      54           0 : class StringStream : public OutputStream {
      55             : public:
      56           0 :     void write8(uint8_t b) override {
      57           0 :         SkASSERT(!fData);
      58           0 :         fStream.write8(b);
      59           0 :     }
      60             : 
      61           0 :     void writeText(const char* s) override {
      62           0 :         SkASSERT(!fData);
      63           0 :         fStream.writeText(s);
      64           0 :     }
      65             : 
      66           0 :     void write(const void* s, size_t size) override {
      67           0 :         SkASSERT(!fData);
      68           0 :         fStream.write(s, size);
      69           0 :     }
      70             : 
      71           0 :     const char* data() const {
      72           0 :         if (!fData) {
      73           0 :             fData = fStream.detachAsData();
      74             :         }
      75           0 :         return (const char*) fData->data();
      76             :     }
      77             : 
      78           0 :     size_t size() const {
      79           0 :         if (!fData) {
      80           0 :             fData = fStream.detachAsData();
      81             :         }
      82           0 :         return fData->size();
      83             :     }
      84             : 
      85           0 :     void reset() {
      86           0 :         fStream.reset();
      87           0 :         fData = nullptr;
      88           0 :     }
      89             : 
      90             : private:
      91             :     mutable SkDynamicMemoryWStream fStream;
      92             :     mutable sk_sp<SkData> fData;
      93             : };
      94             : 
      95             : #endif // SKSL_STANDALONE
      96             : 
      97             : } // namespace
      98             : 
      99             : #endif