src/xamarin/sk_managedstream.cpp

   1 /*
   2  * Copyright 2015 Xamarin Inc.
   3  * Copyright 2017 Microsoft Corporation. All rights reserved.
   4  *
   5  * Use of this source code is governed by a BSD-style license that can be
   6  * found in the LICENSE file.
   7  */
   8
   9 #include "SkManagedStream.h"
  10
  11 #include "sk_managedstream.h"
  12 #include "sk_types_priv.h"
  13
  14
  15 static sk_managedwstream_write_delegate        gWrite;
  16 static sk_managedwstream_flush_delegate        gFlush;
  17 static sk_managedwstream_bytesWritten_delegate gBytesWritten;
  18 static sk_managedwstream_destroy_delegate      gWDestroy;
  19
  20 static inline SkManagedWStream* AsManagedWStream(sk_wstream_managedstream_t* cstream) {
  21     return reinterpret_cast<SkManagedWStream*>(cstream);
  22 }
  23 static inline sk_wstream_managedstream_t* ToManagedWStream(SkManagedWStream* stream) {
  24     return reinterpret_cast<sk_wstream_managedstream_t*>(stream);
  25 }
  26 static inline const sk_wstream_managedstream_t* ToManagedWStream(const SkManagedWStream* stream) {
  27     return reinterpret_cast<const sk_wstream_managedstream_t*>(stream);
  28 }
  29
  30 bool dWrite(SkManagedWStream* managedStream, const void* buffer, size_t size)
  31 {
  32     return gWrite(ToManagedWStream(managedStream), buffer, size);
  33 }
  34 void dFlush(SkManagedWStream* managedStream)
  35 {
  36     gFlush(ToManagedWStream(managedStream));
  37 }
  38 size_t dBytesWritten(const SkManagedWStream* managedStream)
  39 {
  40     return gBytesWritten(ToManagedWStream(managedStream));
  41 }
  42 void dWDestroy(size_t managedStream)
  43 {
  44     gWDestroy(managedStream);
  45 }
  46
  47 sk_wstream_managedstream_t* sk_managedwstream_new()
  48 {
  49     return ToManagedWStream(new SkManagedWStream());
  50 }
  51
  52 void sk_managedwstream_destroy(sk_wstream_managedstream_t* stream)
  53 {
  54     delete AsManagedWStream(stream);
  55 }
  56
  57 void sk_managedwstream_set_delegates(const sk_managedwstream_write_delegate pWrite,
  58                                      const sk_managedwstream_flush_delegate pFlush,
  59                                      const sk_managedwstream_bytesWritten_delegate pBytesWritten,
  60                                      const sk_managedwstream_destroy_delegate pDestroy)
  61 {
  62     gWrite = pWrite;
  63     gFlush = pFlush;
  64     gBytesWritten = pBytesWritten;
  65     gWDestroy = pDestroy;
  66
  67     SkManagedWStream::setDelegates(dWrite, dFlush, dBytesWritten, dWDestroy);
  68 }
  69
  70
  71 static sk_managedstream_read_delegate         gRead;
  72 static sk_managedstream_peek_delegate         gPeek;
  73 static sk_managedstream_isAtEnd_delegate      gIsAtEnd;
  74 static sk_managedstream_hasPosition_delegate  gHasPosition;
  75 static sk_managedstream_hasLength_delegate    gHasLength;
  76 static sk_managedstream_rewind_delegate       gRewind;
  77 static sk_managedstream_getPosition_delegate  gGetPosition;
  78 static sk_managedstream_seek_delegate         gSeek;
  79 static sk_managedstream_move_delegate         gMove;
  80 static sk_managedstream_getLength_delegate    gGetLength;
  81 static sk_managedstream_createNew_delegate    gCreateNew;
  82 static sk_managedstream_destroy_delegate      gDestroy;
  83
  84
  85 static inline SkManagedStream* AsManagedStream(sk_stream_managedstream_t* cstream) {
  86     return reinterpret_cast<SkManagedStream*>(cstream);
  87 }
  88 static inline sk_stream_managedstream_t* ToManagedStream(SkManagedStream* stream) {
  89     return reinterpret_cast<sk_stream_managedstream_t*>(stream);
  90 }
  91 static inline const sk_stream_managedstream_t* ToManagedStream(const SkManagedStream* stream) {
  92     return reinterpret_cast<const sk_stream_managedstream_t*>(stream);
  93 }
  94
  95
  96 size_t dRead(SkManagedStream* managedStream, void* buffer, size_t size)
  97 {
  98     return gRead(ToManagedStream(managedStream), buffer, size);
  99 }
 100 size_t dPeek(SkManagedStream* managedStream, void* buffer, size_t size)
 101 {
 102     return gPeek(ToManagedStream(managedStream), buffer, size);
 103 }
 104 bool dIsAtEnd(const SkManagedStream* managedStream)
 105 {
 106     return gIsAtEnd(ToManagedStream(managedStream));
 107 }
 108 bool dHasPosition(const SkManagedStream* managedStream)
 109 {
 110     return gHasPosition(ToManagedStream(managedStream));
 111 }
 112 bool dHasLength(const SkManagedStream* managedStream)
 113 {
 114     return gHasLength(ToManagedStream(managedStream));
 115 }
 116 bool dRewind(SkManagedStream* managedStream)
 117 {
 118     return gRewind(ToManagedStream(managedStream));
 119 }
 120 size_t dGetPosition(const SkManagedStream* managedStream)
 121 {
 122     return gGetPosition(ToManagedStream(managedStream));
 123 }
 124 bool dSeek(SkManagedStream* managedStream, size_t position)
 125 {
 126     return gSeek(ToManagedStream(managedStream), position);
 127 }
 128 bool dMove(SkManagedStream* managedStream, long offset)
 129 {
 130     return gMove(ToManagedStream(managedStream), offset);
 131 }
 132 size_t dGetLength(const SkManagedStream* managedStream)
 133 {
 134     return gGetLength(ToManagedStream(managedStream));
 135 }
 136 SkManagedStream* dCreateNew(const SkManagedStream* managedStream)
 137 {
 138     return AsManagedStream(gCreateNew(ToManagedStream(managedStream)));
 139 }
 140 void dDestroy(size_t managedStream)
 141 {
 142     gDestroy(managedStream);
 143 }
 144
 145
 146 sk_stream_managedstream_t* sk_managedstream_new ()
 147 {
 148     return ToManagedStream (new SkManagedStream ());
 149 }
 150
 151 void sk_managedstream_destroy (sk_stream_managedstream_t* stream)
 152 {
 153     delete AsManagedStream (stream);
 154 }
 155
 156 void sk_managedstream_set_delegates (const sk_managedstream_read_delegate pRead,
 157                                      const sk_managedstream_peek_delegate pPeek,
 158                                      const sk_managedstream_isAtEnd_delegate pIsAtEnd,
 159                                      const sk_managedstream_hasPosition_delegate pHasPosition,
 160                                      const sk_managedstream_hasLength_delegate pHasLength,
 161                                      const sk_managedstream_rewind_delegate pRewind,
 162                                      const sk_managedstream_getPosition_delegate pGetPosition,
 163                                      const sk_managedstream_seek_delegate pSeek,
 164                                      const sk_managedstream_move_delegate pMove,
 165                                      const sk_managedstream_getLength_delegate pGetLength,
 166                                      const sk_managedstream_createNew_delegate pCreateNew,
 167                                      const sk_managedstream_destroy_delegate pDestroy)
 168 {
 169     gRead = pRead;
 170     gPeek = pPeek;
 171     gIsAtEnd = pIsAtEnd;
 172     gHasPosition = pHasPosition;
 173     gHasLength = pHasLength;
 174     gRewind = pRewind;
 175     gGetPosition = pGetPosition;
 176     gSeek = pSeek;
 177     gMove = pMove;
 178     gGetLength = pGetLength;
 179     gCreateNew = pCreateNew;
 180     gDestroy = pDestroy;
 181
 182     SkManagedStream::setDelegates(dRead, dPeek, dIsAtEnd, dHasPosition, dHasLength, dRewind, dGetPosition, dSeek, dMove, dGetLength, dCreateNew, dDestroy);
 183 }
 184