bool Pickle::WriteData(const char* data, int length) { return length>=0 && WriteInt(length) && WriteBytes(data, length); }
NS_IMETHODIMP nsBinaryOutputStream::WriteByteArray(PRUint8 *aBytes, PRUint32 aLength) { return WriteBytes(reinterpret_cast<char *>(aBytes), aLength); }
void COutArchive::WriteByte(Byte b) { WriteBytes(&b, 1); }
static SRes WriteBytesAndCrc(ISeqOutStream *s, const void *buf, UInt32 size, UInt32 *crc) { *crc = CrcUpdate(*crc, buf, size); return WriteBytes(s, buf, size); }
static SRes Xz_Compress(CXzStream *xz, CLzma2WithFilters *lzmaf, ISeqOutStream *outStream, ISeqInStream *inStream, const CXzProps *props, ICompressProgress *progress) { xz->flags = (Byte)props->checkId; RINOK(Lzma2Enc_SetProps(lzmaf->lzma2, props->lzma2Props)); RINOK(Xz_WriteHeader(xz->flags, outStream)); { CSeqCheckInStream checkInStream; CSeqSizeOutStream seqSizeOutStream; CXzBlock block; unsigned filterIndex = 0; CXzFilter *filter = NULL; const CXzFilterProps *fp = props->filterProps; XzBlock_ClearFlags(&block); XzBlock_SetNumFilters(&block, 1 + (fp ? 1 : 0)); if (fp) { filter = &block.filters[filterIndex++]; filter->id = fp->id; filter->propsSize = 0; if (fp->id == XZ_ID_Delta) { filter->props[0] = (Byte)(fp->delta - 1); filter->propsSize = 1; } else if (fp->ipDefined) { SetUi32(filter->props, fp->ip); filter->propsSize = 4; } } { CXzFilter *f = &block.filters[filterIndex++]; f->id = XZ_ID_LZMA2; f->propsSize = 1; f->props[0] = Lzma2Enc_WriteProperties(lzmaf->lzma2); } seqSizeOutStream.p.Write = MyWrite; seqSizeOutStream.realStream = outStream; seqSizeOutStream.processed = 0; RINOK(XzBlock_WriteHeader(&block, &seqSizeOutStream.p)); checkInStream.p.Read = SeqCheckInStream_Read; checkInStream.realStream = inStream; SeqCheckInStream_Init(&checkInStream, XzFlags_GetCheckType(xz->flags)); if (fp) { #ifdef USE_SUBBLOCK if (fp->id == XZ_ID_Subblock) { lzmaf->sb.inStream = &checkInStream.p; RINOK(SbEncInStream_Init(&lzmaf->sb)); } else #endif { lzmaf->filter.realStream = &checkInStream.p; RINOK(SeqInFilter_Init(&lzmaf->filter, filter)); } } { UInt64 packPos = seqSizeOutStream.processed; SRes res = Lzma2Enc_Encode(lzmaf->lzma2, &seqSizeOutStream.p, fp ? #ifdef USE_SUBBLOCK (fp->id == XZ_ID_Subblock) ? &lzmaf->sb.p: #endif &lzmaf->filter.p: &checkInStream.p, progress); RINOK(res); block.unpackSize = checkInStream.processed; block.packSize = seqSizeOutStream.processed - packPos; } { unsigned padSize = 0; Byte buf[128]; while((((unsigned)block.packSize + padSize) & 3) != 0) buf[padSize++] = 0; SeqCheckInStream_GetDigest(&checkInStream, buf + padSize); RINOK(WriteBytes(&seqSizeOutStream.p, buf, padSize + XzFlags_GetCheckSize(xz->flags))); RINOK(Xz_AddIndexRecord(xz, block.unpackSize, seqSizeOutStream.processed - padSize, &g_Alloc)); } } return Xz_WriteFooter(xz, outStream); }
static AJ_Status MarshalMsg(AJ_Message* msg, uint8_t msgType, uint32_t msgId, uint8_t flags) { AJ_Status status = AJ_OK; AJ_IOBuffer* ioBuf = &msg->bus->sock.tx; uint8_t fieldId; uint8_t secure = FALSE; /* * Use the msgId to lookup information in the object and interface descriptions to * initialize the message header fields. */ status = AJ_InitMessageFromMsgId(msg, msgId, msgType, &secure); if (status != AJ_OK) { return status; } AJ_IO_BUF_RESET(ioBuf); msg->hdr = (AJ_MsgHeader*)ioBuf->bufStart; memset(msg->hdr, 0, sizeof(AJ_MsgHeader)); ioBuf->writePtr += sizeof(AJ_MsgHeader); msg->hdr->endianess = HOST_ENDIANESS; msg->hdr->msgType = msgType; msg->hdr->flags = flags; if (secure) { msg->hdr->flags |= AJ_FLAG_ENCRYPTED; } /* * The wire-protocol calls this flag NO_AUTO_START we toggle the meaning in the API * so the default flags value can be zero. */ msg->hdr->flags ^= AJ_FLAG_AUTO_START; /* * Serial number cannot be zero (wire-spec wierdness) */ do { msg->hdr->serialNum = msg->bus->serial++; } while (msg->bus->serial == 1); /* * Marshal the header fields */ for (fieldId = AJ_HDR_OBJ_PATH; fieldId <= AJ_HDR_SESSION_ID; ++fieldId) { char typeId = TypeForHdr[fieldId]; char buf[4]; const char* fieldSig = &buf[2]; AJ_Arg hdrVal; /* * Skip field id's that are not currently used. */ if (typeId == AJ_ARG_INVALID) { continue; } InitArg(&hdrVal, typeId, NULL); switch (fieldId) { case AJ_HDR_OBJ_PATH: if ((msgType == AJ_MSG_METHOD_CALL) || (msgType == AJ_MSG_SIGNAL)) { hdrVal.val.v_objPath = msg->objPath; } break; case AJ_HDR_INTERFACE: hdrVal.val.v_string = msg->iface; break; case AJ_HDR_MEMBER: if (msgType != AJ_MSG_ERROR) { int32_t len = AJ_StringFindFirstOf(msg->member, " "); hdrVal.val.v_string = msg->member; hdrVal.len = (len >= 0) ? len : 0; } break; case AJ_HDR_ERROR_NAME: if (msgType == AJ_MSG_ERROR) { hdrVal.val.v_string = msg->error; } break; case AJ_HDR_REPLY_SERIAL: if ((msgType == AJ_MSG_METHOD_RET) || (msgType == AJ_MSG_ERROR)) { hdrVal.val.v_uint32 = &msg->replySerial; } break; case AJ_HDR_DESTINATION: hdrVal.val.v_string = msg->destination; break; case AJ_HDR_SENDER: hdrVal.val.v_string = AJ_GetUniqueName(msg->bus); break; case AJ_HDR_SIGNATURE: hdrVal.val.v_signature = msg->signature; break; case AJ_HDR_TIMESTAMP: if (msg->ttl) { AJ_Time timer; timer.seconds = 0; timer.milliseconds = 0; msg->timestamp = AJ_GetElapsedTime(&timer, FALSE); hdrVal.val.v_uint32 = &msg->timestamp; } break; case AJ_HDR_TIME_TO_LIVE: if (msg->ttl) { hdrVal.val.v_uint32 = &msg->ttl; } break; case AJ_HDR_SESSION_ID: if (msg->sessionId) { hdrVal.val.v_uint32 = &msg->sessionId; } break; case AJ_HDR_HANDLES: case AJ_HDR_COMPRESSION_TOKEN: default: continue; } /* * Ignore empty fields. */ if (!hdrVal.val.v_data) { continue; } /* * Custom marshal the header field - signature is "(yv)" so starts off with STRUCT aligment. */ buf[0] = fieldId; buf[1] = 1; buf[2] = typeId; buf[3] = 0; WriteBytes(msg, buf, 4, PadForType(AJ_ARG_STRUCT, ioBuf)); /* * Now marshal the field value */ Marshal(msg, &fieldSig, &hdrVal); } if (status == AJ_OK) { /* * Write the header length */ msg->hdr->headerLen = (uint32_t)((ioBuf->writePtr - ioBuf->bufStart) - sizeof(AJ_MsgHeader)); /* * Header must be padded to an 8 byte boundary */ status = WritePad(msg, (8 - msg->hdr->headerLen) & 7); } return status; }
SERIALISATION_INLINE void StreamWriter::WriteBlock(const char *const firstByte, size_t byteCount) { WriteBytes(firstByte, byteCount); }
static AJ_Status Marshal(AJ_Message* msg, const char** sig, AJ_Arg* arg) { AJ_Status status = AJ_OK; AJ_IOBuffer* ioBuf = &msg->bus->sock.tx; char typeId = **sig; uint32_t pad = PadForType(typeId, ioBuf); size_t sz; if (!arg) { return AJ_ERR_NULL; } *sig += 1; if (IsScalarType(arg->typeId)) { if (arg->flags & AJ_ARRAY_FLAG) { if ((typeId != AJ_ARG_ARRAY) || (**sig != arg->typeId)) { return AJ_ERR_MARSHAL; } *sig += 1; sz = arg->len; status = WriteBytes(msg, &sz, 4, pad); if (status == AJ_OK) { /* * May need to pad if the elements required 8 byte alignment */ pad = PadForType(arg->typeId, ioBuf); } } else { if (typeId != arg->typeId) { return AJ_ERR_MARSHAL; } sz = SizeOfType(typeId); } if (status == AJ_OK) { status = WriteBytes(msg, arg->val.v_data, sz, pad); } } else if (TYPE_FLAG(typeId) & (AJ_STRING | AJ_VARIANT)) { if (typeId != arg->typeId) { return AJ_ERR_MARSHAL; } sz = arg->len ? arg->len : strlen(arg->val.v_string); /* * Length field for a signature is 1 byte, for regular strings its 4 bytes */ if (ALIGNMENT(typeId) == 1) { uint8_t szu8 = (uint8_t)sz; if (sz > 255) { return AJ_ERR_MARSHAL; } status = WriteBytes(msg, &szu8, 1, pad); } else { status = WriteBytes(msg, &sz, 4, pad); } if (status == AJ_OK) { status = WriteBytes(msg, arg->val.v_string, sz, 0); /* * String must be NUL terminated on the wire */ if (status == AJ_OK) { status = WritePad(msg, 1); } /* * If marshalling a variant store offset to start of signature */ if (typeId == AJ_ARG_VARIANT) { msg->varOffset = (uint8_t)(sz + 1); } } } else if (TYPE_FLAG(typeId) & AJ_CONTAINER) { if (typeId != arg->typeId) { return AJ_ERR_MARSHAL; } status = MarshalContainer(msg, sig, arg, pad); } else { return AJ_ERR_MARSHAL; } return status; }
/********************************************************************** * TABRawBinBlock::Write<datatype>() * * Arc/Info files are binary files with MSB first (Motorola) byte * ordering. The following functions will reorder the byte for the * value properly and write that to the output file. * * If a problem happens, then CPLError() will be called and * CPLGetLastErrNo() can be used to test if a write operation was * succesful. **********************************************************************/ int TABRawBinBlock::WriteByte(GByte byValue) { return WriteBytes(1, (GByte*)&byValue); }
ScriptStream& ScriptStream::operator<<( const char* str ) { WriteBytes( str, strlen( str ) ); return *this; }
void ScriptStream::endl() { char ch = '\n'; WriteBytes( &ch, 1 ); }
ScriptStream& ScriptStream::operator<<( char ch ) { WriteBytes( &ch, 1 ); return *this; }