Пример #1
0
/**
 * Write out the header information as text.
 * @param ofs The output file stream.
 * @param Dimensions[] The dimensions of the data.
 * @param Origin[] The origin.
 * @param Spacing[] The spacing.
 * @param Increment[] The increment.
 * @param ScalarType The scalar type.
 * The scalar type is defined as follows:
 * \code
 * #define VTK_VOID            0
 * #define VTK_BIT             1
 * #define VTK_CHAR            2
 * #define VTK_SIGNED_CHAR    15
 * #define VTK_UNSIGNED_CHAR   3
 * #define VTK_SHORT           4
 * #define VTK_UNSIGNED_SHORT  5
 * #define VTK_INT             6
 * #define VTK_UNSIGNED_INT    7
 * #define VTK_LONG            8
 * #define VTK_UNSIGNED_LONG   9
 * #define VTK_FLOAT          10
 * #define VTK_DOUBLE         11
 * #define VTK_ID_TYPE        12
 * \endcode
 */
void WriteHeader(std::ofstream & ofs,
   int Dimensions[3], double Origin[3], double Spacing[3],
   int Increment[3], int & ScalarType)
{
//  ofs.seekg(0,std::ios::beg);
  std::ios::fmtflags flags = ofs.setf(std::ios::fmtflags());
  ofs << std::fixed << std::setprecision(2);

  ofs << "Dimensions:  ";
  for ( int i = 0; i < 3; ++i ) ofs << Dimensions[i] << " ";
  ofs << std::endl;
  ofs << "Origin:      ";
  for ( int i = 0; i < 3; ++i ) ofs << Origin[i] << " ";
  ofs << std::endl;
  ofs << "Spacings:    ";
  for ( int i = 0; i < 3; ++i ) ofs << Spacing[i] << " ";
  ofs << std::endl;
  ofs << "Increments:  ";
  for ( int i = 0; i < 3; ++i ) ofs << Increment[i] << " ";
  ofs << std::endl;
  ofs << "Scalar type: " << ScalarType << std::endl;

  ofs << std::setprecision(6) << std::endl;
  std::ios::fmtflags newflags = ofs.setf(std::ios::fmtflags());
  ofs.setf(flags,newflags);
}
Пример #2
0
void DTMImage::WriteTextScalars(std::ofstream &ofs, int const & precision,
                        bool const &DisplayI, bool const &DisplayJ, bool const DisplayK)
{
  if ( this->scalars->size() != (std::size_t)(this->pointProduct[2]) )
  {
    std::cerr << "Dimensions do not match." << std::endl;
    std::cerr << "Number of Scalars:" << this->scalars->size() << " expected: " << this->pointProduct[2] << std::endl;
    return;
  }

  std::ios::fmtflags flags = ofs.setf(std::ios::fmtflags());
  ofs << std::fixed << std::setprecision(precision);

  int choice = (DisplayK << 2) + (DisplayJ << 1) + DisplayI;
  if ( choice & 4  ) choice = 4;
  if ( choice & 2  ) choice = 2;
  if ( choice & 1  ) choice = 1;

  if ( choice == 0 )
  {
    for ( ufDTMScalarTypeBase::iterator p = this->scalars->begin(); p != this->scalars->end(); ++p )
      ofs << *p << "\n";
    return;
  }

  ufDTMScalarTypeBase::iterator p = this->scalars->begin();
  int i = 0;
  int j = 0;
  int k = 0;
  for ( i = 0; i < this->dimensions[0]; ++i )
  {
    if ( choice & 1 )
      ofs << "(" << i << ",...,...) ";
    for ( j = 0; j < this->dimensions[1]; ++j )
    {
      if( choice & 2 )
      {
        ofs << "(" << i << "," << j << ",...) ";
      }
      for ( k = 0; k < this->dimensions[2]; ++k )
      {
        if ( choice & 4 )
          ofs << "(" << i << "," << j << "," << k << ") ";
        ofs << *p++ << " ";
        if ( choice & 4 )
          ofs << std::endl;
      }
      if( choice & 2 )
        ofs << std::endl;
    }
    if ( choice & 1 )
      ofs << std::endl;
  }

  ofs << std::setprecision(6) << std::endl;
  std::ios::fmtflags newflags = ofs.setf(std::ios::fmtflags());
  ofs.setf(flags,newflags);
}
Пример #3
0
  void WriteScalars(std::ofstream &ofs, std::vector<T> & Scalars, int Dimensions[3],
     bool const &DisplayI = false, bool const &DisplayJ = false, bool const DisplayK = false)
{
  std::ios::fmtflags flags = ofs.setf(std::ios::fmtflags());
  ofs << std::fixed << std::setprecision(2);

  int choice = (DisplayK << 2) + (DisplayJ << 1) + DisplayI;
  if ( choice & 4  ) choice = 4;
  if ( choice & 2  ) choice = 2;
  if ( choice & 1  ) choice = 1;

  if ( choice == 0 )
    {
      for ( typename std::vector<T>::iterator p = Scalars.begin(); p != Scalars.end(); ++p )
        ofs << *p << "\n";
      return;
    }
  if ( Scalars.size() != (size_t)(Dimensions[0]*Dimensions[1]*Dimensions[2]) )
    {
    std::cerr << "Dimensions do not match." << std::endl;
    return;
    }

  typename std::vector<T>::iterator p = Scalars.begin();
  for ( int i = 0; i < Dimensions[0]; ++i )
    {
    if ( choice & 1 )
      ofs << "(" << i << ",...,...) ";
    for ( int j = 0; j < Dimensions[1]; ++j )
      {
      if( choice & 2 )
      {
        ofs << "(" << i << "," << j << ",...) ";
      }
      for ( int k = 0; k < Dimensions[2]; ++k )
        {
        if ( choice & 4 )
          ofs << "(" << i << "," << j << "," << k << ") ";
        ofs << *p++ << " ";
        if ( choice & 4 )
          ofs << std::endl;
        }
      if( choice & 2 )
        ofs << std::endl;
      }
    if ( choice & 1 )
    ofs << std::endl;
    }


  ofs << std::setprecision(6) << std::endl;
  std::ios::fmtflags newflags = ofs.setf(std::ios::fmtflags());
  ofs.setf(flags,newflags);
}
Пример #4
0
        void pluginLoad()
        {
            if (notifyFrequency > 0)
            {
                // number of cells on the current CPU for each direction
                const DataSpace<simDim> nrOfGpuCells = Environment<simDim>::get().SubGrid().getLocalDomain().size;

                // create as much storage as cells in the direction we are interested in:
                // on gpu und host
                sliceDataField = new GridBuffer<float3_X, DIM1 >
                        (DataSpace<DIM1 > (nrOfGpuCells.y()));

                Environment<>::get().PluginConnector().setNotificationPeriod(this, notifyFrequency);

                const int rank = Environment<simDim>::get().GridController().getGlobalRank();

                // open output file
                std::stringstream oFileName;
                oFileName << "lineSliceFields_" << rank << ".txt";

                outfile.open(oFileName.str().c_str(), std::ofstream::out | std::ostream::trunc);
                outfile.precision(8);
                outfile.setf(std::ios::scientific);
            }
        }
Пример #5
0
int main(int argc, CHAR *argv[])
{
    PIN_InitSymbols();

    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }
    
    TRACE_AddInstrumentFunction(Trace, 0);

    PIN_AddFiniFunction(Fini, 0);

    IMG_AddUnloadFunction(ImageUnload, 0);

    out.open(KnobOutputFile.Value().c_str());
    out.setf(ios::showbase);
    out << hex;

    // Never returns

    PIN_StartProgram();
    
    return 0;
}
Пример #6
0
int main(int argc, char *argv[])
{
    // Initialize pin & symbol manager
    PIN_InitSymbols();
    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }
    
    // Write to a file since cout and cerr maybe closed by the application
    TraceFile.open(KnobOutputFile.Value().c_str());
    TraceFile << hex;
    TraceFile.setf(ios::showbase);
    
    // Register Image to be called to instrument functions.
    IMG_AddInstrumentFunction(Image, 0);

	// RTN_AddInstrumentFunction(Routine, 0);

	// Register ImageUnload to be called when an image is unloaded
    // IMG_AddUnloadFunction(ImageUnload, 0);

	// Register Fini to be called when the application exits
    PIN_AddFiniFunction(Fini, 0);

    // Never returns
    PIN_StartProgram();
    
    return 0;
}
Пример #7
0
int main(int argc, char *argv[])
{
    // Initialize pin & symbol manager
    PIN_InitSymbols();
    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }

    pinplay_engine.Activate(argc, argv,
      KnobPinPlayLogger, KnobPinPlayReplayer);
    
    // Write to a file since cout and cerr maybe closed by the application
    TraceFile.open(KnobOutputFile.Value().c_str());
    TraceFile << hex;
    TraceFile.setf(ios::showbase);
    cout << hex;
    cout.setf(ios::showbase);
    // Register Image to be called to instrument functions.
    IMG_AddInstrumentFunction(Image, 0);
    PIN_AddFiniFunction(Fini, 0);

    // Never returns
    PIN_StartProgram();
    
    return 0;
}
Пример #8
0
int main(int argc, char *argv[])
{
    string trace_header = string("#\n"
                                 "# Memory Access Trace Generated By Pin\n"
                                 "#\n");
    
    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }
    
    TraceFile.open(KnobOutputFile.Value().c_str());
    TraceFile.write(trace_header.c_str(),trace_header.size());
    TraceFile.setf(ios::showbase);
    
    INS_AddInstrumentFunction(Instruction, 0);
    PIN_AddFiniFunction(Fini, 0);

    // Never returns

    PIN_StartProgram();
    
    RecordMemWrite(0);
    RecordWriteAddrSize(0, 0);
    
    return 0;
}
Пример #9
0
int  main(int argc, char *argv[])
{
    
    PIN_InitSymbols();

    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }
    

    TraceFile.open(KnobOutputFile.Value().c_str());

    TraceFile << hex;
    TraceFile.setf(ios::showbase);
    
    string trace_header = string("#\n"
                                 "# Call Trace Generated By Pin\n"
                                 "#\n");
    

    TraceFile.write(trace_header.c_str(),trace_header.size());
    
    TRACE_AddInstrumentFunction(Trace, 0);
    PIN_AddFiniFunction(Fini, 0);

    // Never returns

    PIN_StartProgram();
    
    return 0;
}
Пример #10
0
int main(int argc, char *argv[])
{
    // Initialize pin & symbol manager
    PIN_InitSymbols();
    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }
    
    // Write to a file since cout and cerr maybe closed by the application
    outFile.open(KnobOutputFile.Value().c_str());
    outFile << hex;
    outFile.setf(ios::showbase);

    
    // Register Image to be called to instrument functions.
    IMG_AddInstrumentFunction(Image, 0);
    INS_AddInstrumentFunction(Instruction, 0);
    PIN_AddFiniFunction(Fini, 0);

    // Never returns
    PIN_StartProgram();
    
    return 0;
} 
Пример #11
0
int main(int argc, char *argv[])
{
    // Initialize pin & symbol manager
    PIN_InitSymbols();
    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }
    thread_init();
    
    PIN_AddFollowChildProcessFunction(FollowChild, 0);    
    
    // Write to a file since cout and cerr maybe closed by the application
    TraceFile.open(KnobOutputFile.Value().c_str());
    TraceFile << hex;
    TraceFile.setf(ios::showbase);
    
    // Register Image to be called to instrument functions.
    IMG_AddInstrumentFunction(ImageLoad, 0);
    IMG_AddUnloadFunction(ImageUnLoad, 0);
    TRACE_AddInstrumentFunction(trace_instrument, 0);

    PIN_AddFiniFunction(Fini, 0);

    // Never returns
    PIN_StartProgram();
    
    return 0;
}
Пример #12
0
int main(int argc, char *argv[])
{
    PIN_InitSymbols();

    if( PIN_Init(argc,argv) )
    {
        return Usage();
    }
    

    TraceFile.open(KnobOutputFile.Value().c_str());

    TraceFile << hex;
    TraceFile.setf(ios::showbase);

    cout << hex;
    cout.setf(ios::showbase);
    
    IMG_AddInstrumentFunction(Image, 0);
    PIN_AddFiniFunction(Fini, 0);

    // Never returns
    PIN_StartProgram();
    
    return 0;
}
Пример #13
0
void LasWell::WriteLasLine(std::ofstream     & file,
                           const std::string & mnemonic,
                           const std::string & units,
                           double              data,
                           const std::string & description)
{
  file.precision(3);
  file.setf(std::ios_base::fixed);

  file << mnemonic << " ." << units << " " << data << " : " << description << "\n";
}
Пример #14
0
	void DiskFromCFD::PrepareOutputFile(const boost::filesystem::path file_name, std::ofstream& fOutput)
	{
		fOutput.open(file_name.c_str(), std::ios::out);
		fOutput.setf(std::ios::scientific);

		unsigned int count = 1;
		OpenSMOKE::PrintTagOnASCIILabel(22, fOutput, "x[mm]", count);
		OpenSMOKE::PrintTagOnASCIILabel(22, fOutput, "T[K]", count);
		for (unsigned int j = 0; j < thermodynamicsMap_.NumberOfSpecies(); j++)
			OpenSMOKE::PrintTagOnASCIILabel(22, fOutput, thermodynamicsMap_.NamesOfSpecies()[j] + "_w", count);
		fOutput << std::endl;
	}
Пример #15
0
void write_cams(std::ofstream &file, CameraArray& cam_list)
{
	file.precision(10);
	file.setf(std::ios_base::scientific);

	size_t n_cams = cam_list.size();
	for (size_t i = 0; i < n_cams; ++i) {
		Camera &cam = *(std::dynamic_pointer_cast<Camera>(cam_list[i]));
		file << cam.focal[0] << " " << cam.disto_coeffs[0] << " " << cam.disto_coeffs[1] << std::endl;
		file << cam.rotation.toRotationMatrix() << std::endl;
		file << cam.translation.transpose() << std::endl;
	}
}
Пример #16
0
void DTMImage::WriteTextHeader( std::ofstream & ofs, int const & precision )
{
  std::ios::fmtflags flags = ofs.setf(std::ios::fmtflags());
  ofs << std::fixed << std::setprecision(precision);

  ofs << "Dimensions:  ";
  for ( int i = 0; i < 3; ++i ) ofs << this->dimensions[i] << " ";
  ofs << std::endl;
  ofs << "Origin:      ";
  for ( int i = 0; i < 3; ++i ) ofs << this->origin[i] << " ";
  ofs << std::endl;
  ofs << "Spacings:    ";
  for ( int i = 0; i < 3; ++i ) ofs << this->spacing[i] << " ";
  ofs << std::endl;
  ofs << "Increments:  ";
  for ( int i = 0; i < 3; ++i ) ofs << this->indexIncrement[i] << " ";
  ofs << std::endl;
  ofs << "Scalar type: " << this->scalarType << std::endl;

  ofs << std::setprecision(6) << std::endl;
  std::ios::fmtflags newflags = ofs.setf(std::ios::fmtflags());
  ofs.setf(flags,newflags);
}
Пример #17
0
void write_points(std::ofstream &file, std::vector<Point> &point_list)
{
	size_t n_points = point_list.size();
	for (size_t i = 0; i < n_points; ++i) {
		Point &pt = point_list[i];

		file.precision(10);
		file.setf(std::ios_base::scientific);

		file << pt.position.transpose() << std::endl;
		file << pt.color.transpose() << std::endl;

		write_visibility_list(file, pt);
	}
}
int main(int argc, char *argv[])
{
    // Initialize pin & symbol manager
    PIN_InitSymbols();
    PIN_Init(argc,argv);

    TraceFile.open(KnobOutputFile.Value().c_str());
    TraceFile << hex;
    TraceFile.setf(ios::showbase);

    // Register Image to be called to instrument functions.
    IMG_AddInstrumentFunction(Image,0);
    //RTN_AddInstrumentFunction(InstrumentRoutine, 0);
    // Never returns
    PIN_StartProgram();
    return 0;
}
Пример #19
0
/**
 * \brief     Internal conversion function, writes given timestamp to output file stream
 * \param     timestamp timestamp for current message
 * \param     stream Output file stream
 *
 */
void CBlfLogConverter::WriteTimestamp(ULONGLONG timestamp, std::ofstream& stream) const
{
    // Be careful: in this function milliseconds uses for 10^-4 sec
    ULONGLONG hours = timestamp;
    hours /= 100000;
    ULONGLONG millisecond = hours % 10000;
    hours /= 10000;
    ULONGLONG seconds = hours % 60;
    hours /= 60;
    ULONGLONG minutes = hours % 60;
    hours /= 60;

    stream << std::dec << hours <<":" << minutes << ":" << seconds << ":" ;
    // Outputs milliseconds with adjusting by zero
    stream.setf(ios::right, ios::adjustfield);
    stream.fill('0');
    stream << std::setw(4)<< std::dec << millisecond;
}
Пример #20
0
void write_visibility_list(std::ofstream &file, Point& pt)
{
	file.precision(4);
	file.unsetf(std::ios_base::scientific);
	file.setf(std::ios_base::fixed, std::ios_base::floatfield);

	size_t n_vis = pt.visibility_list.size();
	file << n_vis << " ";

	for (size_t i = 0; i < n_vis; ++i) {
		Visibility &vis = pt.visibility_list[i];

		file << vis.camera_idx << " " << vis.keypoint_idx << " " << vis.position.transpose() << " ";
	}

	file.unsetf(std::ios_base::fixed);
	file.unsetf(std::ios_base::floatfield);
	file << std::endl;
}
Пример #21
0
int main(int argc, char *argv[])
{
    PIN_InitSymbols();
    PIN_Init(argc, argv);

    TraceFile.open("args.out");

    TraceFile << hex;
    TraceFile.setf(ios::showbase);

    IMG_AddInstrumentFunction(Image, 0);
    INS_AddInstrumentFunction(Ins, 0);
    PIN_AddFiniFunction(Fini, 0);

    // Never returns
    PIN_StartProgram();
    
    return 0;
}
Пример #22
0
static VOID EmitMem(VOID * ea, INT32 size)
{
    if (!KnobValues)
        return;
    
    switch(size)
    {
      case 0:
        TraceFile << setw(1);
        break;
        
      case 1:
        TraceFile << static_cast<UINT32>(*static_cast<UINT8*>(ea));
        break;
        
      case 2:
        TraceFile << *static_cast<UINT16*>(ea);
        break;
        
      case 4:
        TraceFile << *static_cast<UINT32*>(ea);
        break;
        
      case 8:
        TraceFile << *static_cast<UINT64*>(ea);
        break;
        
      default:
        TraceFile.unsetf(ios::showbase);
        TraceFile << setw(1) << "0x";
        for (INT32 i = 0; i < size; i++)
        {
            TraceFile << static_cast<UINT32>(static_cast<UINT8*>(ea)[i]);
        }
        TraceFile.setf(ios::showbase);
        break;
    }
}
Пример #23
0
void InitObjFile()
{
	if (g_obj.is_open())
	{
		return;
	}

	std::ofstream file;
	file.open("logger.obj");

	if (file.is_open())
	{
		file.close();
	}

	g_obj.open("logger.obj", std::ios::app);

	g_obj.setf(std::ios::fixed, std::ios::floatfield);

	g_objFrameIndex = 0;
	g_objObjectIndex = 0;
	g_objVertexBaseIndex = 1;
	g_objVertexIndex = 1;
}
Пример #24
0
 bool Mesh::SaveVRML2(std::ofstream & fout, const Material & material) const
 {
     if (fout.is_open())
     {
         fout.setf(std::ios::fixed, std::ios::floatfield);
         fout.setf(std::ios::showpoint);
         fout.precision(6);
         size_t nV = m_points.Size();
         size_t nT = m_triangles.Size();
         fout << "#VRML V2.0 utf8" << std::endl;
         fout << "" << std::endl;
         fout << "# Vertices: " << nV << std::endl;
         fout << "# Triangles: " << nT << std::endl;
         fout << "" << std::endl;
         fout << "Group {" << std::endl;
         fout << "    children [" << std::endl;
         fout << "        Shape {" << std::endl;
         fout << "            appearance Appearance {" << std::endl;
         fout << "                material Material {" << std::endl;
         fout << "                    diffuseColor " << material.m_diffuseColor[0] << " "
             << material.m_diffuseColor[1] << " "
             << material.m_diffuseColor[2] << std::endl;
         fout << "                    ambientIntensity " << material.m_ambientIntensity << std::endl;
         fout << "                    specularColor " << material.m_specularColor[0] << " "
             << material.m_specularColor[1] << " "
             << material.m_specularColor[2] << std::endl;
         fout << "                    emissiveColor " << material.m_emissiveColor[0] << " "
             << material.m_emissiveColor[1] << " "
             << material.m_emissiveColor[2] << std::endl;
         fout << "                    shininess " << material.m_shininess << std::endl;
         fout << "                    transparency " << material.m_transparency << std::endl;
         fout << "                }" << std::endl;
         fout << "            }" << std::endl;
         fout << "            geometry IndexedFaceSet {" << std::endl;
         fout << "                ccw TRUE" << std::endl;
         fout << "                solid TRUE" << std::endl;
         fout << "                convex TRUE" << std::endl;
         if (nV > 0)
         {
             fout << "                coord DEF co Coordinate {" << std::endl;
             fout << "                    point [" << std::endl;
             for (size_t v = 0; v < nV; v++)
             {
                 fout << "                        " << m_points[v][0] << " "
                     << m_points[v][1] << " "
                     << m_points[v][2] << "," << std::endl;
             }
             fout << "                    ]" << std::endl;
             fout << "                }" << std::endl;
         }
         if (nT > 0)
         {
             fout << "                coordIndex [ " << std::endl;
             for (size_t f = 0; f < nT; f++)
             {
                 fout << "                        " << m_triangles[f][0] << ", "
                     << m_triangles[f][1] << ", "
                     << m_triangles[f][2] << ", -1," << std::endl;
             }
             fout << "                ]" << std::endl;
         }
         fout << "            }" << std::endl;
         fout << "        }" << std::endl;
         fout << "    ]" << std::endl;
         fout << "}" << std::endl;
         return true;
     }
     return false;
 }
Пример #25
0
/**
 * \brief     Internal conversion function, uses already prepared blf library and output file
 * \param     pBlfLib blf library with loaded input file
 * \param     stream Output file stream
 * \return    Result code
 *
 */
HRESULT CBlfLogConverter::WriteToLog(BLF::IBlfLibrary* pBlfLib, std::ofstream& stream) const
{
    if(pBlfLib == NULL)
    {
        return E_INVALIDARG;
    }

    SYSTEMTIME startTime = pBlfLib->GetStartTime();
    size_t objectsCount = pBlfLib->GetBlfObjectsCount();

    if(objectsCount <= 0)
    {
        return ERR_PROTOCOL_NOT_SUPPORTED;
    }

    AddFunctionHeader(stream, startTime.wDay, startTime.wMonth, startTime.wYear, startTime.wHour, startTime.wMinute, startTime.wSecond);

    for(size_t i = 0; i < objectsCount; i++)
    {
        BLF::IBlfObject* object = pBlfLib->GetBlfObject(i);
        if(object == NULL)
        {
            continue;
        }

        if(object->GetKind() == BLF::bokCanMessage)
        {
            BLF::ICanMessage* canMessage = object->GetICanMessage();
            // It is should be impossible, that object has CanMessage type, but return NULL for GetICanMessage()
            ASSERT(canMessage != NULL);
            if(canMessage == NULL)
            {
                continue;
            }

            WriteTimestamp(canMessage->GetTimestamp(), stream);

            if(canMessage->GetDirection()==BLF::mdRx)
            {
                stream << " Rx ";
            }
            else
            {
                stream << " Tx ";
            }
            stream << canMessage->GetChannelNo() << " ";
            // suppress extended message bit
            stream << std::hex << (canMessage->GetId() & 0x7FFFFFFF ) << " ";

            stream.setf(ios::uppercase);
            // checks extended bit
            if((canMessage->GetId() & 0x80000000) == 0)
            {
                stream << "s ";    // Standard message
            }
            else
            {
                stream << "x ";    // Extended message
            }
            stream << (int)canMessage->GetDLC();
            for (int i = 0 ; (i < canMessage->GetDLC()) ; ++i)
            {
                stream << " ";
                if (canMessage->GetData()[i] <= 0xf)
                {
                    stream << '0';
                }
                stream << std::hex;
                stream <<  (int)canMessage->GetData()[i];
                stream.setf(ios::uppercase);
            }
            stream << "\n";
        }
    }
    stream << "***END DATE AND TIME ***\n";
    // Everythere above \n is used, but here \r\n like in asc to log parser
    stream << "***[STOP LOGGING SESSION]***\r\n";

    return S_OK;
}