Beispiel #1
0
bool test_output_seekable(std::ostream& io)
{
    int i;  // old 'for' scope workaround.

    // Test seeking with ios::cur
    for (i = 0; i < data_reps; ++i) {
        for (int j = 0; j < chunk_size; ++j)
            io.put(narrow_data()[j]);
        io.seekp(-chunk_size, BOOST_IOS::cur);
        io.write(narrow_data(), chunk_size);
    }

    // Test seeking with ios::beg
    std::streamoff off = 0;
    io.seekp(0, BOOST_IOS::beg);
    for (i = 0; i < data_reps; ++i, off += chunk_size) {
        for (int j = 0; j < chunk_size; ++j)
            io.put(narrow_data()[j]);
        io.seekp(off, BOOST_IOS::beg);
        io.write(narrow_data(), chunk_size);
    }
    
    // Test seeking with ios::end
    io.seekp(0, BOOST_IOS::end);
    off = io.tellp();
    io.seekp(-off, BOOST_IOS::end);
    for (i = 0; i < data_reps; ++i, off -= chunk_size) {
        for (int j = 0; j < chunk_size; ++j)
            io.put(narrow_data()[j]);
        io.seekp(-off, BOOST_IOS::end);
        io.write(narrow_data(), chunk_size);
    }
    return true;
}
Beispiel #2
0
void join_lines_remove_shell_comments_function(std::istream& is, std::ostream& os) {
	bool skip = false;
	char current;
	while (is.get(current)) {
		if (skip) {
			if (current != '\n' && current != '\\')
				continue;
		}
		else if (skip = (current == '#')) {
			continue;
		}
		if (current != '\\') {
			if (current == '\n')
				skip = false;
			if (!skip)
				os.put(current);
			continue;
		}
		if (!is.get(current)) {
			if (!skip)
				os.put('\\');
			return;
		}
		if (skip || current == '\n')
			continue;
		os.put('\\');
		os.put(current);
	}
}
Beispiel #3
0
void Image::savePPM(std::ostream &os)
{
	// write header
	os << "P6\n" << m_nWidth << ' ' << m_nHeight << "\n255\n";
	
	unsigned int nR, nG, nB;
	unsigned char cR, cG, cB;
	
	// write clamped [0, 255] values
	for(int y = m_nHeight-1; y >= 0; y--) {
		for(int x = 0; x < m_nWidth; x++) {
			nR = (unsigned int) (256 * m_rgbImage[x][y].r());
			nG = (unsigned int) (256 * m_rgbImage[x][y].g());
			nB = (unsigned int) (256 * m_rgbImage[x][y].b());
			
			if(nR > 255) nR = 255;
			if(nG > 255) nG = 255;
			if(nB > 255) nB = 255;
			
			cR = (unsigned char) (nR);
			cG = (unsigned char) (nG);
			cB = (unsigned char) (nB);
			
			os.put(cR);
			os.put(cG);
			os.put(cB);
		}
	}
}
Beispiel #4
0
inline size_t
writeVarNumber(std::ostream& os, uint64_t varNumber)
{
  if (varNumber < 253) {
    os.put(static_cast<char>(varNumber));
    return 1;
  }
  else if (varNumber <= std::numeric_limits<uint16_t>::max()) {
    os.put(static_cast<char>(253));
    uint16_t value = htobe16(static_cast<uint16_t>(varNumber));
    os.write(reinterpret_cast<const char*>(&value), 2);
    return 3;
  }
  else if (varNumber <= std::numeric_limits<uint32_t>::max()) {
    os.put(static_cast<char>(254));
    uint32_t value = htobe32(static_cast<uint32_t>(varNumber));
    os.write(reinterpret_cast<const char*>(&value), 4);
    return 5;
  }
  else {
    os.put(static_cast<char>(255));
    uint64_t value = htobe64(varNumber);
    os.write(reinterpret_cast<const char*>(&value), 8);
    return 9;
  }
}
inline
void write_and_pad_shader_source_header(
	std::ostream& output,
	shader_source_header& header,
	span_size_t source_text_size,
	span_size_t& spos
)
{
	using eagine::memory::is_aligned_as;
	while(!is_aligned_as<shader_source_header>(spos)) {
		output.put('\0');
		++spos;
	}

	// if changing this also change shader_block
	// in write_and_pad_program_source_header
	const span_size_t size = 48;
	span_size_t done = 0;
	assert(size >= span_size(sizeof(shader_source_header)));

	eagine::memory::const_address hdraddr(&header);

	header.source_text.reset(hdraddr+std::ptrdiff_t(size),source_text_size);

	output.write(static_cast<const char*>(hdraddr), sizeof(header));
	spos += sizeof(header);
	done += sizeof(header);

	while(done < size)
	{
		output.put('\0');
		++spos;
		++done;
	}
}
Beispiel #6
0
void Image::writePPM(std::ostream& s) const {
    s << "P6\n" << _width << " " << _height << "\n255\n";
    unsigned int i;
    double gamma = 1.0 / 2.2;
    for (int y = 0; y < _height; y++) {
        for (int x = 0; x < _width; x++) {

            _pixels(y, x) = Color(
                pow(_pixels(y, x)[0], gamma),
                pow(_pixels(y, x)[1], gamma),
                pow(_pixels(y, x)[2], gamma)
            );

            i = 256.0 * _pixels(y, x)[0];
            if (i > 255)
                i = 255;
            s.put((unsigned char) i);

            i = 256.0 * _pixels(y, x)[1];
            if (i > 255)
                i = 255;
            s.put((unsigned char) i);

            i = 256.0 * _pixels(y, x)[2];
            if (i > 255)
                i = 255;
            s.put((unsigned char) i);
        }
    }
}
Beispiel #7
0
FIT_UINT8 FieldDefinition::Write(std::ostream &file) const
{
   file.put(num);
   file.put(size);
   file.put(type);

   return 3;
}
Beispiel #8
0
// Save & change and restore stream properties
void
saver_tests_2
(
    std::istream &  input,
    std::ostream &  output,
    std::ostream &  err
)
{
    using std::locale;
    using std::ios_base;

    boost::io::ios_tie_saver const    its( input, &err );
    boost::io::ios_rdbuf_saver const  irs( output, err.rdbuf() );
    boost::io::ios_iword_saver const  iis( output, my_index, 69L );
    boost::io::ios_pword_saver const  ipws( output, my_index, &err );
    output << "The data is (a third time; adding the numbers):\n";

    boost::io::ios_flags_saver const      ifls( output, (output.flags()
     & ~ios_base::adjustfield) | ios_base::showpos | ios_base::boolalpha
     | (ios_base::internal & ios_base::adjustfield) );
    boost::io::ios_precision_saver const  iprs( output, 9 );
    boost::io::ios_fill_saver const       ifis( output, '@' );
    output << '\t' << test_string << '\n';

    boost::io::ios_width_saver const  iws( output, 12 );
    output.put( '\t' );
    output << test_num1 + test_num2;
    output.put( '\n' );

    locale                             loc( locale::classic(),
     new backward_bool_names );
    boost::io::ios_locale_saver const  ils( output, loc );
    output << '\t' << test_bool << '\n';

    BOOST_CHECK( &err == output.pword(my_index) );
    BOOST_CHECK( 69L == output.iword(my_index) );

    try
    {
        boost::io::ios_exception_saver const  ies( output, ios_base::eofbit  );
        boost::io::ios_iostate_saver const    iis( output, output.rdstate()
         | ios_base::eofbit );

        BOOST_ERROR( "previous line should have thrown" );
    }
    catch ( ios_base::failure &f )
    {
        err << "Got the expected I/O failure: \"" << f.what() << "\".\n";
        BOOST_CHECK( output.exceptions() == ios_base::goodbit );
    }
    catch ( ... )
    {
        err << "Got an unknown error when doing exception test!\n";
        throw;
    }
}
Beispiel #9
0
int Mesg::Write(std::ostream& file, const MesgDefinition* mesgDef) const
{
   MesgDefinition mesgDefOnNull;
   FIT_UINT8 mesgSize = 1;

   file.put((localNum & FIT_HDR_TYPE_MASK)); // Message record header with local message number.

   if (mesgDef == FIT_NULL)
   {
      mesgDefOnNull = MesgDefinition(*this);
      mesgDef = &mesgDefOnNull;
   }

   for (FIT_UINT16 fieldDefIndex = 0; fieldDefIndex < (mesgDef->GetFields().size()); fieldDefIndex++)
   {
      const Field* field = GetField(mesgDef->GetFieldByIndex(fieldDefIndex)->GetNum());
      FIT_UINT8 fieldSize = 0;

      if (field != FIT_NULL)
      {
         fieldSize = field->Write(file);

         if (fieldSize == 0)
            return 0;
      }

      if (fieldSize < (mesgDef->GetFieldByIndex(fieldDefIndex)->GetSize()))
      {
         FIT_UINT8 baseTypeNum = ((mesgDef->GetFieldByIndex(fieldDefIndex)->GetType()) & FIT_BASE_TYPE_NUM_MASK);

         if (baseTypeNum < FIT_BASE_TYPES)
         {
            FIT_UINT8 baseTypeByteIndex = (fieldSize % (baseTypeSizes[baseTypeNum]));
            FIT_UINT8 numBytesRemaining = (mesgDef->GetFieldByIndex(fieldDefIndex)->GetSize()) - fieldSize;

            while (numBytesRemaining--)
            {
               file.put(*(baseTypeInvalids[baseTypeNum] + baseTypeByteIndex));

               if ((++baseTypeByteIndex) >= baseTypeSizes[baseTypeNum])
                  baseTypeByteIndex = 0;

               fieldSize++;
            }
         }
         else
         {
            return 0;   // Do not continue if base type not supported.
         }
      }

      mesgSize += fieldSize;
   }

   return mesgSize;
}
void InfixPrinter::WriteToken(std::ostream& aOutput, const std::string& aString)
{
    if (IsAlNum(iPrevLastChar) && (IsAlNum(aString[0]) || aString[0] == '_'))
        aOutput.put(' ');
    else if (IsSymbolic(iPrevLastChar) && IsSymbolic(aString[0]))
        aOutput.put(' ');

    aOutput.write(aString.c_str(), aString.size());
    RememberLastChar(aString.back());
}
Beispiel #11
0
size_t u8_wc_toutf8(std::ostream &out, long ch) {
  if (ch < 0x80) {
    out.put((char)ch);
    return 1;
  }
  if (ch < 0x800) {
    out.put((ch>>6) | 0xC0);
    out.put((ch & 0x3F) | 0x80);
    return 2;
  }
Beispiel #12
0
	void DoubleWord::writeSwappedOrder(std::ostream& destinationStream) const
	{
		DoubleWordValue value;
		value.doubleWord = mValue;

		destinationStream.put(value.bytes[3]);
		destinationStream.put(value.bytes[2]);
		destinationStream.put(value.bytes[1]);
		destinationStream.put(value.bytes[0]);
	}
Beispiel #13
0
    void writeEscaped(std::ostream &out, InputIterator begin, InputIterator end, char delim = ',')
    {
        for (; begin != end; ++begin)
        {
            char c = *begin;
            if (c == delim || c == '\\')
                out.put('\\');

            out.put(c);
        }
    }
Beispiel #14
0
 void operator () (std::ostream &file,
         const film< rgb<uint8_t>, E > &image) {
     typedef typename film< rgb<uint8_t>, E >::size_type size_type;
     for ( size_type r = 0; r < image.height(); ++r )
         for ( size_type c = 0; c < image.width(); ++c ) {
             rgb<uint8_t> col(image[c][r]);
             file.put(col.blue());
             file.put(col.green());
             file.put(col.red());
         }
 }
Beispiel #15
0
void LafsFlat::encodeSkipName(std::ostream& out, const int iNext)
{
	out.put('.');
	out.put(0);

	WORD wBuffer = iNext;

	out.write(reinterpret_cast<char*>(&wBuffer), sizeof(WORD));
	
	out.put(0);
	out.put(0);
}
Beispiel #16
0
//
// SaveInt
//
static void SaveInt(std::ostream &save, biguint i)
{
   if(!i) return;

   SaveInt(save, i / 16);
   save.put("0123456789ABCDEF"[i % 16]);
}
 void Word::writeSwappedOrder(std::ostream& destinationStream) const
 {
     const Byte* bytes = reinterpret_cast<const Byte*>(&myValue);
     
     destinationStream.put(bytes[1]);
     destinationStream.put(bytes[0]);
 }
Beispiel #18
0
bool Reader::read_until_boundary(int sock, const std::string& boundary, std::ostream& out, size_t max)
{
    size_t read_so_far = 0;
    unsigned got = 0;

    while (got < boundary.size())
    {
        char c;
        ssize_t count = read(sock, &c, 1);
        if (count == 0) throw wibble::exception::Consistency("reading from socket", "data ends before MIME boundary");
        if (count < 0) throw wibble::exception::System("reading from socket");

        if (c == boundary[got])
            ++got;
        else
        {
            if (max == 0 || read_so_far < max)
            {
                if (got > 0)
                {
                    out.write(boundary.data(), got);
                    read_so_far += got;
                }
                out.put(c);
                ++read_so_far;
            }
            got = 0;
        }
    }

    return readboundarytail(sock);
}
 void sign_helper ( std::ostream& aStr, const int64_t& aInt )
 {
   if ( aInt < int64_t ( 0 ) )
   {
     aStr.put ( '-' );
   }
 }
Beispiel #20
0
	static void dump_node(std::ostream&out, const Node*node){
		for (unsigned line = 1, height = get_height(node); line <= height; ++line){
			dump_line(out, node, line);
			out.put('\n');
		}
		out.flush();
	}
Beispiel #21
0
void write_array(std::ostream &_stream, Iter _begin, uint16_t _size) {
  _stream.put((uint8_t) 0xDC);
  _stream.write(reinterpret_cast<const char*>(&_size), sizeof(_size));
  for (int i = 0; i < _size; i++) {
    msgpack<T>::write(_stream, *_begin++);
  }
}
Beispiel #22
0
//
// SaveRealInt
//
static void SaveRealInt(std::ostream &save, bigreal i)
{
   if(!i) return;

   SaveRealInt(save, std::floor(i / 16));
   save.put("0123456789ABCDEF"[static_cast<unsigned>(std::floor(std::fmod(i, 16)))]);
}
	void print(std::ostream &out) const {
		for (char ci='a'; ci <= 'z'; ++ci){
			for (size_t i=0; i < count(ci); ++i){
				out.put(ci);
			}
		}
	}
Beispiel #24
0
void write_template(
    std::ostream & out,
    mapper_impl<std::integer_sequence<std::size_t, Ints...>, Binders...> const & map,
    char const * fmt)
{
    auto fmt_point = fmt;
    for (; *fmt; ++fmt) {
        if ('%' == *fmt && *(fmt+1)) {
            ++fmt;
            bool is_executed = false;
            (void)std::initializer_list<int>{(
                !is_executed && get_binder<Ints>(map).c == *fmt
                ? ((out.write(fmt_point, fmt - fmt_point - 1) << get_binder<Ints>(map).x),
                    fmt_point = fmt+1,
                    is_executed = true
                ) : 1
            )...};
            if (!is_executed) {
                out.write(fmt_point, fmt - fmt_point - 1);
                out.put(*fmt);
                fmt_point = fmt+1;
            }
        }
    }
    out.write(fmt_point, fmt - fmt_point);
}
Beispiel #25
0
void writeDxfBinary(std::ostream &file,GroupCode code)
{
  writeleshort(file,code.tag);
  switch(tagFormat(code.tag))
  {
    case 1:
      file.put(code.flag);
      break;
    case 2:
      writeleshort(file,code.integer);
      break;
    case 4:
      writeleint(file,code.integer);
      break;
    case 8:
      writelelong(file,code.integer);
      break;
    case 72:
      writeledouble(file,code.real);
      break;
    case 128:
      writeustring(file,code.str);
      break;
    case 129:
      writeustring(file,hexEncodeString(code.str));
      break;
    case 132:
      writeustring(file,hexEncodeInt(code.integer));
      break;
  }
}
static void decompress(BitInputStream &in, std::ostream &out) {
	// Set up decoder and model. In this PPM model, symbol 256 represents EOF;
	// its frequency is 1 in the order -1 context but its frequency
	// is 0 in all other contexts (which have non-negative order).
	ArithmeticDecoder dec(32, in);
	PpmModel model(MODEL_ORDER, 257, 256);
	vector<uint32_t> history;
	
	while (true) {
		// Decode and write one byte
		uint32_t symbol = decodeSymbol(dec, model, history);
		if (symbol == 256)  // EOF symbol
			break;
		int b = static_cast<int>(symbol);
		if (std::numeric_limits<char>::is_signed)
			b -= (b >> 7) << 8;
		out.put(static_cast<char>(b));
		model.incrementContexts(history, symbol);
		
		if (model.modelOrder >= 1) {
			// Prepend current symbol, dropping oldest symbol if necessary
			if (history.size() >= static_cast<unsigned int>(model.modelOrder))
				history.erase(history.end() - 1);
			history.insert(history.begin(), symbol);
		}
	}
}
Beispiel #27
0
uint32_t AsmHashTag::write(std::ostream &o) const
{
	uint16_t strsize(value.size());
	o.write((const char *) &strsize, 2);
	o.write(value.c_str(), strsize);
	o.put('\0');
	return strsize + 3;
}
Beispiel #28
0
void join_lines_function(std::istream& is, std::ostream& os) {
	char current;
	while (is.get(current)) {
		if (current != '\\') {
			os.put(current);
			continue;
		}
		if (!is.get(current)) {
			return;
		}
		if (current == '\n') {
			continue;
		}
		os.put('\\');
		os.put(current);
	}
}
Beispiel #29
0
void LafsFlat::encodeName(std::ostream& out, const std::string& sName)
{
	if(sName.size() > LAFS_NAME_SIZE)
		throw FormattingException("Name of file exceeds permitted limit.");

	for(unsigned int i = 0; i < LAFS_NAME_SIZE; i++)
		out.put( i < sName.size() ? sName.c_str()[i] : 0);
}
Beispiel #30
0
int CsoundFile::exportMidifile(std::ostream &stream) const
{
  for(int i = 0, n = midifile.size(); i < n; i++)
    {
      stream.put(midifile[i]);
    }
  return stream.good();
}