示例#1
0
void BmpImageExporter::saveToStream(const ImageRawData& image, std::ostream& os)
{
    if (image.isNull())
        throw Exception("[BmpImageExporter::save] null image given");

    BitmapFileHeader bf; //  bmp fileheader
    BitmapInfoHeader * bfinfo = (BitmapInfoHeader *) image.data();

    // uliss: TODO! check for endianness
    bf.bfType = 0x4d42; // 'BM'
    bf.bfSize = BMP_FILE_HEADER_SIZE + image.dataSize();
    // fileheader + infoheader + palette
    bf.bfOffBits = BMP_FILE_HEADER_SIZE + sizeof(BitmapInfoHeader) + bfinfo->biClrUsed
            * sizeof(RGBQuad);

    os.write((char*) &bf, sizeof(bf));

    if (os.fail())
        throw Exception("[BmpImageExporter::save] failed");

    os << image;

    if (os.fail())
        throw Exception("[BmpImageExporter::save] failed");
}
void  FeatureFileIO::SaveFile (FeatureVectorList&    _data,
                               const KKStr&          _fileName,
                               FeatureNumListConst&  _selFeatures,
                               std::ostream&         _out,
                               kkuint32&             _numExamplesWritten,
                               VolConstBool&         _cancelFlag,
                               bool&                 _successful,
                               KKStr&                _errorMessage,
                               RunLog&               _log
                              )
{
   _errorMessage = "Driver: '" + this->DriverName () + "' does not implement 'SaveFile' method.";
   _log.Level (-1) << endl
      << "FeatureFileIO::SaveFile    ***ERROR***   " << _errorMessage << endl
      << "     _data.size   : " << _data.size () << endl
      << "     _fileName    : " << _fileName << endl
      << "     _selFeatures : " << _selFeatures.ToCommaDelStr () << endl
      << "     _out.fail    : " << _out.fail () << endl
      << "     _cancelFlag  : " << _cancelFlag << endl
      << endl;
      
  _successful = false;
  _numExamplesWritten = 0;
  return;
}
bool VehicleStateBasicLux::serialize(std::ostream& os) const
{
	const std::istream::pos_type startPos = os.tellp();

	lock();

	ibeo::writeLE(os, m_timestamp);
	ibeo::writeLE(os, m_scanNumber);
	ibeo::writeLE(os, m_errorFlags);
	ibeo::writeLE(os, m_longitudinalVelocity);
	ibeo::writeLE(os, m_steeringWheeAngle);
	ibeo::writeLE(os, m_wheelAngle);
	ibeo::writeLE(os, m_reserved0);

	ibeo::writeLE(os, m_xPos);
	ibeo::writeLE(os, m_yPos);
	ibeo::writeLE(os, m_courseAngle);

	ibeo::writeLE(os, m_timeDiff);
	ibeo::writeLE(os, m_xDiff);
	ibeo::writeLE(os, m_yDiff);
	ibeo::writeLE(os, m_yaw);

	ibeo::writeLE(os, m_reserved1);
	ibeo::writeLE(os, m_currentYawRate);
	ibeo::writeLE(os, m_reserved2);

	unlock();

	return !os.fail() && ((os.tellp() - startPos) == this->getSerializedSize());
}
示例#4
0
bool WriteBinaryMaterial(const Material& material, std::ostream& stream)
{
    IOUtils::WriteBinaryFloat(material.diffuse.r, stream);
    IOUtils::WriteBinaryFloat(material.diffuse.g, stream);
    IOUtils::WriteBinaryFloat(material.diffuse.b, stream);
    IOUtils::WriteBinaryFloat(material.diffuse.a, stream);

    IOUtils::WriteBinaryFloat(material.ambient.r, stream);
    IOUtils::WriteBinaryFloat(material.ambient.g, stream);
    IOUtils::WriteBinaryFloat(material.ambient.b, stream);
    IOUtils::WriteBinaryFloat(material.ambient.a, stream);

    IOUtils::WriteBinaryFloat(material.specular.r, stream);
    IOUtils::WriteBinaryFloat(material.specular.g, stream);
    IOUtils::WriteBinaryFloat(material.specular.b, stream);
    IOUtils::WriteBinaryFloat(material.specular.a, stream);

    /* emissive.r */  IOUtils::WriteBinaryFloat(0.0f, stream);
    /* emissive.g */  IOUtils::WriteBinaryFloat(0.0f, stream);
    /* emissive.b */  IOUtils::WriteBinaryFloat(0.0f, stream);
    /* emissive.a */  IOUtils::WriteBinaryFloat(0.0f, stream);

    /* power */       IOUtils::WriteBinaryFloat(0.0f, stream);

    return !stream.fail();
}
示例#5
0
// ヘッダを書き込む
bool WriteHeader(std::ostream& stream,
  std::uint32_t hash_value, const std::string& architecture) {
  stream.write(reinterpret_cast<const char*>(&kVersion), sizeof(kVersion));
  stream.write(reinterpret_cast<const char*>(&hash_value), sizeof(hash_value));
  const std::uint32_t size = static_cast<std::uint32_t>(architecture.size());
  stream.write(reinterpret_cast<const char*>(&size), sizeof(size));
  stream.write(architecture.data(), size);
  return !stream.fail();
}
示例#6
0
 /**
  * Dump the current status to a stream
  *
  * @param[out] os The output stream where the data is saved
  *
  * @exception std::runtime_error When failed to dump.
  */
 void dump(std::ostream& os) const {
     os.write((char*)&b_, sizeof(b_));
     os.write((char*)&M_[0], sizeof(M_[0]) * M_.size());
     os.write((char*)&c_, sizeof(c_));
     os.write((char*)&p_, sizeof(p_));
     if(os.fail()){
         throw std::runtime_error("Failed to dump");
     }
 }
bool ReaderWriterGZ::write(std::ostream& fout, const std::string& source) const
{
    int ret, flush = Z_FINISH;
    unsigned have;
    z_stream strm;
    unsigned char out[CHUNK];

    int level = 6;
    int stategy = Z_DEFAULT_STRATEGY; // looks to be the best for .osg/.ive files
    //int stategy = Z_FILTERED;
    //int stategy = Z_HUFFMAN_ONLY;
    //int stategy = Z_RLE;

    /* allocate deflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    ret = deflateInit2(&strm,
                       level,
                       Z_DEFLATED,
                       15+16, // +16 to use gzip encoding
                       8, // default
                       stategy);
    if (ret != Z_OK)
    return false;

    strm.avail_in = source.size();
    strm.next_in = (Bytef*)(&(*source.begin()));

    /* run deflate() on input until output buffer not full, finish
       compression if all of source has been read in */
    do {
        strm.avail_out = CHUNK;
        strm.next_out = out;
        ret = deflate(&strm, flush);    /* no bad return value */

        if (ret == Z_STREAM_ERROR)
        {
            OSG_NOTICE<<"Z_STREAM_ERROR"<<std::endl;
            return false;
        }

        have = CHUNK - strm.avail_out;

        if (have>0) fout.write((const char*)out, have);

        if (fout.fail())
        {
            (void)deflateEnd(&strm);
            return false;
        }
    } while (strm.avail_out == 0);

    /* clean up and return */
    (void)deflateEnd(&strm);
    return true;
}
示例#8
0
bool CModelFile::WriteBinaryModel(std::ostream& stream)
{
    if (m_triangles.size() == 0)
    {
        GetLogger()->Error("Empty model\n");
        return false;
    }

    NewModelHeader header;

    header.version        = 1;
    header.totalTriangles = m_triangles.size();

    IOUtils::WriteBinary<4, int>(header.version, stream);
    IOUtils::WriteBinary<4, int>(header.totalTriangles, stream);

    for (int i = 0; i < static_cast<int>( m_triangles.size() ); ++i)
    {
        NewModelTriangle1 t;

        t.p1 = m_triangles[i].p1;
        t.p2 = m_triangles[i].p2;
        t.p3 = m_triangles[i].p3;
        t.material = m_triangles[i].material;
        t.tex1Name = m_triangles[i].tex1Name;
        t.tex2Name = m_triangles[i].tex2Name;
        t.variableTex2 = m_triangles[i].variableTex2;
        t.state = m_triangles[i].state;

        switch (m_triangles[i].lodLevel)
        {
            case LOD_Constant: t.lodLevel = 0; break;
            case LOD_Low:      t.lodLevel = 1; break;
            case LOD_Medium:   t.lodLevel = 2; break;
            case LOD_High:     t.lodLevel = 3; break;
        }

        WriteBinaryVertexTex2(t.p1, stream);
        WriteBinaryVertexTex2(t.p2, stream);
        WriteBinaryVertexTex2(t.p3, stream);
        WriteBinaryMaterial(t.material, stream);
        IOUtils::WriteBinaryString<1>(t.tex1Name, stream);
        IOUtils::WriteBinaryString<1>(t.tex2Name, stream);
        IOUtils::WriteBinaryBool(t.variableTex2, stream);
        IOUtils::WriteBinary<4, int>(t.lodLevel, stream);
        IOUtils::WriteBinary<4, int>(t.state, stream);

        if (stream.fail())
        {
            GetLogger()->Error("Error writing model file\n");
            return false;
        }
    }

    return true;
}
示例#9
0
bool Event::Write(std::ostream & o) const
{
    if(o.fail()) return false;

    o.write(reinterpret_cast<const char*>(pack), sp);
    o.write(&status, 1);
    if(size) o.write(reinterpret_cast<const char*>(data), size);

    return true;
}
示例#10
0
void cmnDataSerializeBinary_size_t(const size_t & data,
                                   std::ostream & outputStream)
    throw (std::runtime_error)
{
    outputStream.write(reinterpret_cast<const char *>(&data),
                       sizeof(size_t));
    if (outputStream.fail()) {
        cmnThrow("cmnDataSerializeBinary(type): error occured with std::ostream::write");
    }
}
示例#11
0
void cmnDataSerializeText_size_t(const size_t & data,
                                 std::ostream & outputStream,
                                 const char CMN_UNUSED(delimiter))
    throw (std::runtime_error)
{
    outputStream << data;
    if (outputStream.fail()) {
        cmnThrow("cmnDataSerializeText_size_t: error occured with std::ostream::write");
    }
}
示例#12
0
bool WriteTextVertexTex2(const VertexTex2& vertex, std::ostream& stream)
{
    stream << "c " << vertex.coord.x << " " << vertex.coord.y << " " << vertex.coord.z;
    stream << " n " << vertex.normal.x << " " << vertex.normal.y << " " << vertex.normal.z;
    stream << " t1 " << vertex.texCoord.x << " " << vertex.texCoord.y;
    stream << " t2 " << vertex.texCoord2.x << " " << vertex.texCoord2.y;
    stream << std::endl;

    return !stream.fail();
}
示例#13
0
void cmnDataSerializeBinary(const std::string & data,
                            std::ostream & outputStream)
    throw (std::runtime_error)
{
    cmnData<size_t>::SerializeBinary(data.size(), outputStream);
    outputStream.write(data.data(), data.size());
    if (outputStream.fail()) {
        cmnThrow("cmnDataSerializeBinary(std::string): error occured with std::ostream::write");
    }
}
示例#14
0
bool S3D::WritePoint( std::ostream& aFile, const SGPOINT& aPoint )
{
    aFile.write( (char*)&aPoint.x, sizeof(aPoint.x) );
    aFile.write( (char*)&aPoint.y, sizeof(aPoint.y) );
    aFile.write( (char*)&aPoint.z, sizeof(aPoint.z) );

    if( aFile.fail() )
        return false;

    return true;
}
示例#15
0
 virtual WriteResult writeImage(const Image& image,std::ostream& fout, const osgDB::ReaderWriter::Options* options) const
 {
     ive::DataOutputStream out(&fout, options);
     out.writeImage(ive::IMAGE_INCLUDE_DATA, const_cast<osg::Image*>(&image));
     if (fout.fail()) return WriteResult::ERROR_IN_WRITING_FILE;
     if (out.getException())
     {
         OSG_WARN<<"Error writing IVE image: "<< out.getException()->getError() << std::endl;
         return WriteResult::FILE_NOT_HANDLED;
     }
     return WriteResult::FILE_SAVED;
 }
示例#16
0
文件: Misc.cpp 项目: zipang29/rss
/* Compress from file source to file dest until EOF on source.
   def() returns Z_OK on success, Z_MEM_ERROR if memory could not be
   allocated for processing, Z_STREAM_ERROR if an invalid compression
   level is supplied, Z_VERSION_ERROR if the version of zlib.h and the
   version of the library linked do not match, or Z_ERRNO if there is
   an error reading or writing the files. */
bool Misc::deflate(const uint8_t* in, size_t inlen, std::ostream& dest, string& err, int CHUNK, int level)
{
  int ret, flush;
  unsigned have;
  z_stream strm;
  if ( level == -1 ) level = Z_BEST_COMPRESSION;
  if ( CHUNK == -1 ) CHUNK = CL_Z_DEFAULT_CHUNK;
  uint8_t* out = (uint8_t*)malloc(CHUNK);

  /* allocate deflate state */
  strm.zalloc = Z_NULL;
  strm.zfree = Z_NULL;
  strm.opaque = Z_NULL;
  ret = deflateInit(&strm, level);
  if (ret != Z_OK){
    free(out);
    zerr(ret, err);
    return false;
  }

  /* compress until end of file */
  do {
    strm.avail_in = inlen;
    strm.next_in = (uint8_t*)in;
    flush = Z_FINISH;

    /* run deflate() on input until output buffer not full, finish
       compression if all of source has been read in */
    do {
      strm.avail_out = CHUNK;
      strm.next_out = out;
      ret = ::deflate(&strm, flush);  /* no bad return value */
      assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
      have = CHUNK - strm.avail_out;
      dest.write( (char*)out,have);
      if ( dest.fail() ) {
        (void)deflateEnd(&strm);
        free(out);
        zerr(Z_ERRNO, err);
        return false;
      }
    } while (strm.avail_out == 0);
    assert(strm.avail_in == 0);   /* all input will be used */

    /* done when last data in file processed */
  } while (flush != Z_FINISH);
  assert(ret == Z_STREAM_END);    /* stream will be complete */

  /* clean up and return */
  (void)deflateEnd(&strm);
  free(out);
  return true;
}
示例#17
0
bool S3D::WriteColor( std::ostream& aFile, const SGCOLOR& aColor )
{
    float r, g, b;
    aColor.GetColor( r, g, b );
    aFile.write( (char*)&r, sizeof(float) );
    aFile.write( (char*)&g, sizeof(float) );
    aFile.write( (char*)&b, sizeof(float) );

    if( aFile.fail() )
        return false;

    return true;
}
示例#18
0
bool S3D::WriteVector( std::ostream& aFile, const SGVECTOR& aVector )
{
    double x, y, z;
    aVector.GetVector( x, y, z );
    aFile.write( (char*)&x, sizeof(double) );
    aFile.write( (char*)&y, sizeof(double) );
    aFile.write( (char*)&z, sizeof(double) );

    if( aFile.fail() )
        return false;

    return true;
}
示例#19
0
bool WriteBinaryVertex(Vertex vertex, std::ostream& stream)
{
    IOUtils::WriteBinaryFloat(vertex.coord.x, stream);
    IOUtils::WriteBinaryFloat(vertex.coord.y, stream);
    IOUtils::WriteBinaryFloat(vertex.coord.z, stream);
    IOUtils::WriteBinaryFloat(vertex.normal.x, stream);
    IOUtils::WriteBinaryFloat(vertex.normal.y, stream);
    IOUtils::WriteBinaryFloat(vertex.normal.z, stream);
    IOUtils::WriteBinaryFloat(vertex.texCoord.x, stream);
    IOUtils::WriteBinaryFloat(vertex.texCoord.y, stream);

    return !stream.fail();
}
示例#20
0
 bool server_response::write(std::ostream &os) {
     // Set "content-length" header
     auto i=headers.find("content-length");
     if (i==headers.end()) {
         headers.insert(std::make_pair("Content-Length", boost::lexical_cast<std::string>(get_content_length())));
     } else {
         i->second.assign(boost::lexical_cast<std::string>(get_content_length()));
     }
     // Write headers
     if (!write_header(os)) return false;
     // Write body
     os.write(&(raw_body_stream_.vector()[0]), raw_body_stream_.vector().size());
     return !os.eof() && !os.fail() && !os.bad();
 }
示例#21
0
 bool server_response::write_header(std::ostream &os) {
     std::string ka;
     if (keep_alive) {
         ka="keep-alive";
     } else {
         ka="close";
     }
     auto i=headers.find("connection");
     if (i==headers.end()) {
         headers.insert(std::make_pair("Connection", ka));
     } else {
         i->second.assign(ka);
     }
     if (!common::response::write_header(os)) return false;
     return !os.eof() && !os.fail() && !os.bad();
 }
示例#22
0
bool ObjectLux::serialize(std::ostream& os) const
{
	const std::istream::pos_type startPos = os.tellp();

	ibeo::writeLE(os, m_id);
	ibeo::writeLE(os, m_age);
	ibeo::writeLE(os, m_predictionAge);
	ibeo::writeLE(os, m_relativeTimestamp);
	m_refPoint.serialize(os);
	m_refPointSigma.serialize(os);
	m_closestPoint.serialize(os);
	m_boundingBoxCenter.serialize(os);

	ibeo::writeLE(os, m_boundingBoxWidth);
	ibeo::writeLE(os, m_boundingBoxLength);

	m_objectBoxCenter.serialize(os);
	ibeo::writeLE(os, m_objectBoxSizeX);
	ibeo::writeLE(os, m_objectBoxSizeY);
	ibeo::writeLE(os, m_objectBoxOrientation);

	m_absVelocity.serialize(os);
	ibeo::writeLE(os, m_absVelSigmaX);
	ibeo::writeLE(os, m_absVelSigmaY);

	m_relVelocity.serialize(os);

	const UINT16 c=m_class;
	ibeo::writeLE(os, c);

	ibeo::writeLE(os, m_classAge);
	ibeo::writeLE(os, m_classCertainty);

	if (m_numContourPointsIsValid)
		ibeo::writeLE(os, m_numContourPoints);
	else
		ibeo::writeLE(os, ObjectLux::contourIsInvalid);

	std::vector<Point2d>::const_iterator cpIter = m_contourPoints.begin();
	for (; cpIter != m_contourPoints.end(); ++cpIter) {
		cpIter->serialize(os);
	}

	return !os.fail() && ((os.tellp() - startPos) == this->getSerializedSize());
}
示例#23
0
bool ObjectListEcu::serialize(std::ostream& os) const
{
	const std::istream::pos_type startPos = os.tellp();

	lock();

	ibeo::writeBE(os, m_scanStartTimestamp);
	const UINT16 nbOfObjects = this->m_objects.size();
	ibeo::writeBE(os, nbOfObjects);

	std::vector<ObjectEcu>::const_iterator objIter = m_objects.begin();
	for (; objIter != m_objects.end(); ++objIter) {
		objIter->serialize(os);
	}

	unlock();

	return !os.fail() && ((os.tellp() - startPos) == this->getSerializedSize());
}
示例#24
0
bool WriteTextMaterial(const Material& material, std::ostream& stream)
{
    stream << "dif " << material.diffuse.r
           << " " << material.diffuse.g
           << " " << material.diffuse.b
           << " " << material.diffuse.a;

    stream << " amb " << material.ambient.r
           << " " << material.ambient.g
           << " " << material.ambient.b
           << " " << material.ambient.a;

    stream << " spc " << material.specular.r
           << " " << material.specular.g << " "
           << material.specular.b << " "
           << material.specular.a;

    stream << std::endl;

    return !stream.fail();
}
示例#25
0
void MagickImageExporter::saveToStream(const ImageRawData& image, std::ostream& os) {
    if (image.isNull())
        throw Exception("[MagickImageExporter::save] null image given");

    if (os.fail())
        throw Exception("[MagickImageExporter::save] invalid stream");

    Magick::Blob blob(image.data(), image.dataSize());
    try {
        Magick::Image image;
        image.verbose(true);
        image.magick("DIB");
        image.read(blob);
        image.magick(formatToString(format()));
        image.write(&blob);
        os.write((char*) blob.data(), blob.length());
    } catch (Magick::Exception &e) {
        std::cerr << e.what() << "\n";
        throw Exception("MagickImageExporter::load failed");
    }
}
示例#26
0
bool ScanPointEcu::serialize(std::ostream& os) const
{
	const std::istream::pos_type startPos = os.tellp();

	ibeo::writeBE(os, m_posX);
	ibeo::writeBE(os, m_posY);
	ibeo::writeBE(os, m_posZ);

	ibeo::writeBE(os, m_epw);

	ibeo::writeBE(os, m_deviceId);
	ibeo::writeBE(os, m_layer);
	ibeo::writeBE(os, m_echo);

	ibeo::writeBE(os, m_reserved);

	ibeo::writeBE(os, m_timeOffset);
	ibeo::writeBE(os, m_flags);

	ibeo::writeBE(os, m_segmentId);

	return !os.fail() && ((os.tellp() - startPos) == this->getSerializedSize());
}
示例#27
0
bool MTrk::Write(std::ostream & o) const
{
    if(o.fail()) return false;

    o.write(ID_MTRK, 4);

    u32 size = 0;
    std::list<Event *>::const_iterator it1 = events.begin();
    std::list<Event *>::const_iterator it2 = events.end();
    for(; it1 != it2; ++it1) if(*it1) size += (*it1)->Size();

    u32 x = size;
    SwapBE32(x);
    o.write(reinterpret_cast<char *>(&x), 4);

    if(events.size())
    {
	it1 = events.begin();
	it2 = events.end();
	for(; it1 != it2; ++it1) if(*it1) (*it1)->Write(o);
    }

    return true;
}
void LLFilterSD2XMLRPC::streamOut(std::ostream& ostr, const LLSD& sd)
{
	ostr << "<value>";
	switch(sd.type())
	{
	case LLSD::TypeMap:
	{
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(map) BEGIN" << llendl;
#endif
		ostr << "<struct>";
		if(ostr.fail())
		{
			llinfos << "STREAM FAILURE writing struct" << llendl;
		}
		LLSD::map_const_iterator it = sd.beginMap();
		LLSD::map_const_iterator end = sd.endMap();
		for(; it != end; ++it)
		{
			ostr << "<member><name>" << xml_escape_string((*it).first)
				<< "</name>";
			streamOut(ostr, (*it).second);
			if(ostr.fail())
			{
				llinfos << "STREAM FAILURE writing '" << (*it).first
						<< "' with sd type " << (*it).second.type() << llendl;
			}
			ostr << "</member>";
		}
		ostr << "</struct>";
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(map) END" << llendl;
#endif
		break;
	}
	case LLSD::TypeArray:
	{
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(array) BEGIN" << llendl;
#endif
		ostr << "<array><data>";
		LLSD::array_const_iterator it = sd.beginArray();
		LLSD::array_const_iterator end = sd.endArray();
		for(; it != end; ++it)
		{
			streamOut(ostr, *it);
			if(ostr.fail())
			{
				llinfos << "STREAM FAILURE writing array element sd type "
						<< (*it).type() << llendl;
			}
		}
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(array) END" << llendl;
#endif
		ostr << "</data></array>";
		break;
	}
	case LLSD::TypeUndefined:
		// treat undefined as a bool with a false value.
	case LLSD::TypeBoolean:
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(bool)" << llendl;
#endif
		ostr << "<boolean>" << (sd.asBoolean() ? "1" : "0") << "</boolean>";
		break;
	case LLSD::TypeInteger:
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(int)" << llendl;
#endif
		ostr << "<i4>" << sd.asInteger() << "</i4>";
		break;
	case LLSD::TypeReal:
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(real)" << llendl;
#endif
		ostr << "<double>" << sd.asReal() << "</double>";
		break;
	case LLSD::TypeString:
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(string)" << llendl;
#endif
		ostr << "<string>" << xml_escape_string(sd.asString()) << "</string>";
		break;
	case LLSD::TypeUUID:
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(uuid)" << llendl;
#endif
		// serialize it as a string
		ostr << "<string>" << sd.asString() << "</string>";
		break;
	case LLSD::TypeURI:
	{
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(uri)" << llendl;
#endif
		// serialize it as a string
		ostr << "<string>" << xml_escape_string(sd.asString()) << "</string>";
		break;
	}
	case LLSD::TypeBinary:
	{
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(binary)" << llendl;
#endif
		// this is pretty inefficient, but we'll deal with that
		// problem when it becomes one.
		ostr << "<base64>";
		LLSD::Binary buffer = sd.asBinary();
		if(!buffer.empty())
		{
			// *TODO: convert to LLBase64
			int b64_buffer_length = apr_base64_encode_len(buffer.size());
			char* b64_buffer = new char[b64_buffer_length];
			b64_buffer_length = apr_base64_encode_binary(
				b64_buffer,
				&buffer[0],
				buffer.size());
			ostr.write(b64_buffer, b64_buffer_length - 1);
			delete[] b64_buffer;
		}
		ostr << "</base64>";
		break;
	}
	case LLSD::TypeDate:
#if LL_SPEW_STREAM_OUT_DEBUGGING
		llinfos << "streamOut(date)" << llendl;
#endif
		// no need to escape this since it will be alpha-numeric.
		ostr << "<dateTime.iso8601>" << sd.asString() << "</dateTime.iso8601>";
		break;
	default:
		// unhandled type
		llwarns << "Unhandled structured data type: " << sd.type()
			<< llendl;
		break;
	}
	ostr << "</value>";
}
示例#29
0
 // Write a C/C++ numerical type
 template <class T> bool 
 WriteAttrNum(std::ostream& os, T n)
 {
   os << attB << n << attE;
   return (!os.fail());  
 } 
示例#30
0
bool CModelFile::WriteTextModel(std::ostream& stream)
{
    if (m_triangles.size() == 0)
    {
        GetLogger()->Error("Empty model\n");
        return false;
    }

    NewModelHeader header;

    header.version        = 1;
    header.totalTriangles = m_triangles.size();

    stream << "# Colobot text model" << std::endl;
    stream << std::endl;
    stream << "### HEAD" << std::endl;
    stream << "version " << header.version << std::endl;
    stream << "total_triangles " << header.totalTriangles << std::endl;
    stream << std::endl;
    stream << "### TRIANGLES" << std::endl;

    for (int i = 0; i < static_cast<int>( m_triangles.size() ); ++i)
    {
        NewModelTriangle1 t;

        t.p1 = m_triangles[i].p1;
        t.p2 = m_triangles[i].p2;
        t.p3 = m_triangles[i].p3;
        t.material = m_triangles[i].material;
        t.tex1Name = m_triangles[i].tex1Name;
        t.tex2Name = m_triangles[i].tex2Name;
        t.variableTex2 = m_triangles[i].variableTex2;
        t.state = m_triangles[i].state;

        switch (m_triangles[i].lodLevel)
        {
            case LOD_Constant: t.lodLevel = 0; break;
            case LOD_Low:      t.lodLevel = 1; break;
            case LOD_Medium:   t.lodLevel = 2; break;
            case LOD_High:     t.lodLevel = 3; break;
        }

        stream << "p1 ";
        WriteTextVertexTex2(t.p1, stream);
        stream << "p2 ";
        WriteTextVertexTex2(t.p2, stream);
        stream << "p3 ";
        WriteTextVertexTex2(t.p3, stream);
        stream << "mat ";
        WriteTextMaterial(t.material, stream);

        stream << "tex1 " << t.tex1Name << std::endl;
        stream << "tex2 " << t.tex2Name << std::endl;
        stream << "var_tex2 " << (t.variableTex2 ? 'Y' : 'N') << std::endl;
        stream << "lod_level " << t.lodLevel << std::endl;
        stream << "state " << t.state << std::endl;

        stream << std::endl;

        if (stream.fail())
        {
            GetLogger()->Error("Error writing model file\n");
            return false;
        }
    }

    return true;
}