Beispiel #1
1
void get_check_for_nan(CppAD::vector<Base>& vec, const std::string& file_name)
{	//
	size_t n = vec.size();
	size_t char_size = sizeof(Base) * n;
	char* char_ptr   = reinterpret_cast<char*>( vec.data() );
	//
	std::fstream file_in(file_name.c_str(), std::ios::in|std::ios::binary );
	file_in.read(char_ptr, char_size);
	//
	return;
}
void KeyComputeShader::loadComputeShader() {
    std::stringstream compute_shader_buffer;

    // lines to be updated
    std::string define_tile_size_x = "#define TILE_SIZE_X ";
    std::string str_tile_size_x = std::to_string(tile_size.x);
    bool tile_size_x_updated = false;

    std::string define_tile_size_y = "#define TILE_SIZE_Y ";
    std::string str_tile_size_y = std::to_string(tile_size.y);
    bool tile_size_y_updated = false;

    // construct shader internally
    std::ifstream file_in(KEY_COMPUTE_SHADER_PATH, std::ifstream::in);

    for (std::string line; std::getline(file_in, line);) {
        if (!tile_size_x_updated &&
                line.compare(0, define_tile_size_x.size(), define_tile_size_x) == 0) {
            compute_shader_buffer << define_tile_size_x << str_tile_size_x << std::endl;
            tile_size_x_updated = true;
        } else if (!tile_size_y_updated &&
                   line.compare(0, define_tile_size_y.size(), define_tile_size_y) == 0) {
            compute_shader_buffer << define_tile_size_y << str_tile_size_y << std::endl;
            tile_size_y_updated = true;
        } else {
            compute_shader_buffer << line << std::endl;
        }
    }

    this->key_compute_shader = createComputeProgram(compute_shader_buffer.str());
}
int main( int argc, char** argv )
{
    std::string codec_in("XML"),
                codec_out("Bach");

    while (1) {
        int c = getopt(argc, argv, "fs:i:o:");
        if (c == -1) {
            break;
        } else if (c == 'f') {
            option_format = 1;
        } else if (c == 's') {
            option_spacing = strtol(optarg, NULL, 0);
        } else if (c == 'i') {
            codec_in = optarg;
        } else if (c == 'o') {
            codec_out = optarg;
        }
    }

    if ((argc - optind) != 2) {
        usage(argv[0]);
        return 1;
    }

    std::string file_in(argv[argc - 2]);
    std::string file_out(argv[argc - 1]);

    std::cout << "Reading from " << file_in << " to " << file_out << std::endl << std::flush;

    // convert file
    return convert(file_in, codec_in, file_out, codec_out);
}
Beispiel #4
0
void EditorWidget::setSmileList(QString filename, QString sep, QString path_smile)
{
	QFile file_in( filename );

	if (file_in.exists()) {
		if (file_in.open(QIODevice::ReadOnly) != 0) {
			QString line;
			QStringList list;
			QTextStream in(&file_in);
			in.setCodec("UTF-8");
			list_smile->clear();
		//	editor_rich_text->document()->clear();
			while ( !in.atEnd() ) {
				line = in.readLine();
				if (!line.isEmpty()) {
					list = line.split( sep );
					if (QFile::exists(path_smile + list.at(1))) {
						QListWidgetItem *item = new QListWidgetItem(list_smile);
						item->setData(Qt::UserRole, list.at(1));
						item->setText( list.at(0) );
						item->setIcon(QIcon(path_smile + list.at(1)));
						editor_rich_text->document()->addResource(QTextDocument::ImageResource, QUrl("smile_rs_"+ list.at(0) +"_"+ list.at(1)), QImage(path_smile + list.at(1)));
					}
				}
			}
		}
	}
}
QVariant RequestManager::requestFileTransfer(QTcpSocket *& caller, QVariant params)
{
    // VIDEO TRANSFER COMING SOON
    // get the video name
    QJsonObject jobject = params.toJsonObject();
    QJsonValue file_name_value = jobject["FileName"];
    QString file_name;
    if(file_name_value.isString())
        file_name = file_name_value.toString("");
    else
    {
        qDebug() << "VideoTransfer function passed invalid paramter VideoName: " << file_name_value;
        return QVariant();
    }
    QFile file_in(file_name,this);
    qint64 file_size = file_in.size();
    qDebug() << "Preparing to send file: " << file_name << " of size " << file_size;
    //get pointer to main ui object
    QWidget * mainwindow = qobject_cast<QWidget *>(parent()->parent());
    // spwan off stream transfer video
    QAbstractSocket * caller_socket = qobject_cast< QAbstractSocket *>(caller);
    StreamTransferThread * file_transfer = new StreamTransferThread(qobject_cast<QObject *>(this),mainwindow,
            file_name,caller_socket,file_size);
    connect(file_transfer, &StreamTransferThread::finishedTransferingStream,
            this,       &RequestManager::videoTransferThreadFinished);
    file_transfer->start();
    return QVariant();

}
	//Assumes larva_scores is already sorted
	void write_larva_scores(std::string name, int score) {
		bool is_it_too_big = false; //assume false
		if(larva_scores.size() != 0) {
			std::tuple<std::string, int> last_entry = larva_scores.at(larva_scores.size()-1);
			if((score < std::get<1>(last_entry)) && larva_scores.size() == 9) {
				is_it_too_big = false;
				larva_scores.pop_back();
			}
			else if((score > std::get<1>(last_entry)) && larva_scores.size() == 9) {
				is_it_too_big = true;
			}
			//else { is_it_too_big = false; }
		}
		if(is_it_too_big == true) {
			std::cout << "Sorry " + name + " your score isn't good enough to make the high scores :(" << std::endl;
		}
		else {
			if(name.size() < 10) {
				int initial_size = name.size();
				for(int i=initial_size; i<10; i++) {
					name += " "; //FORMATTING
				}
			}
			larva_scores.push_back(std::make_tuple(name, score));
			//http://stackoverflow.com/questions/23030267/custom-sorting-a-vector-of-tuples
			std::sort(larva_scores.begin(), larva_scores.end(), 
				[](std::tuple<std::string, int> const &t1, std::tuple<std::string, int> const &t2) {
				return std::get<1>(t1) < std::get<1>(t2);
				});

			std::string file_lines[23];
			std::string line;
			std::ifstream file_in (scores_file);
			if(file_in.is_open()) {
				int count = 0; 
				while(std::getline(file_in, line)) {
					file_lines[count] = line;
					count++;
				}
				file_in.close();
			}
			else { std::cout << "Unable to open file." << std::endl; }
		
			std::ofstream file_out (scores_file);
			if(file_out.is_open()) { 
				for(int i=0; i<23; i++) {
					int bound = larva_scores.size();
					if((i > 1 && i < 11) && ((i-2)<bound)) {
						std::tuple<std::string, int> temp = larva_scores.at(i-2);
						int place = i-1;
						file_out << place << ".   " + std::get<0>(temp) + "     " << std::get<1>(temp) << "\n"; 
					}
					else { file_out << file_lines[i] + "\n"; } 
				}
				file_out.close();
			}	
			else { std::cout << "Unable to open file." << std::endl; }
		}
	}
Beispiel #7
0
qint64 PrintTask::getFileRealSize(const QString &fileName)
{
    QFile file_in(fileName);
    if (!file_in.open(QIODevice::ReadOnly) ){
        return 0;
    }
    file_in.close();
    return file_in.size();
}
static void DumpFileData(Transaction *query, Transaction *t,
                         String *file, FileData &data)
{
  TOperandBoolean *var_res = query->LookupBoolean(data.processed_var);
  if (var_res->IsTrue()) {
    // already handled this file somewhere else.
    return;
  }

  const char *file_name = file->Value();

  // get the preprocessed file contents.
  TOperandString *preproc_arg =
    new TOperandString(t, data.contents->base,
                       data.contents->pos - data.contents->base);

  // get the source file contents.
  TOperandString *source_arg = NULL;

  // don't look for the source for special compiler files.
  if (file_name[0] != '<') {
    // reconstruct the absolute filename from the normalized name.
    Buffer abs_name;
    if (file_name[0] != '/') {
      abs_name.Append(g_base_directory, strlen(g_base_directory));
      abs_name.Append("/", 1);
    }
    abs_name.Append(file_name, strlen(file_name) + 1);

    const char *abs_str = (const char*) abs_name.base;

    // compress and store the source file contents.
    FileInStream file_in(abs_str);
    if (file_in.IsError()) {
      logout << "WARNING: Could not find source file: " << abs_str << endl;
    }
    else {
      Buffer *buf = new Buffer();
      t->AddBuffer(buf);

      ReadInStream(file_in, buf);
      source_arg = new TOperandString(t, buf->base, buf->pos - buf->base);
    }
  }

  // if we didn't get the source file contents, use the preprocessed
  // contents instead.
  if (!source_arg)
    source_arg = preproc_arg;

  // write out the file contents.
  t->PushAction(
    Backend::BlockWriteFile(t, file_name, source_arg, preproc_arg));
}
Beispiel #9
0
void Sudoku::loadFromFile(std::string filename)
{
	std::ifstream file_in(filename.c_str());
	if(!file_in.is_open())
		std::cout << "File not found" << std::endl;
  
	for(int i = 0; i < 9; ++i){
		for(int j = 0; j < 9; ++j){
			file_in >> grid[i][j];
		}
	}
}
Beispiel #10
0
int Pass1(queue<string> oFiles, map<string, string, string> symbolTable, valueTable values, queue<string> segments){
    
   /* //open all of the object files
    for (int i = 0; i < oFiles.size(); i++){
        string filename = "in_file";
        filename += i;

        ifstream file_in(filename.c_str(), ifstream::in);
    }
    */ //not necessary at all?


    //get program name for first segment. put in valueTable->progName
    
    //read them all into the segments data structure
    for (unsigned int i = 0; i < oFiles.size(); i++){
        string filename = "in_file";
        filename += i;
		filename += ".o";

		ifstream file_in(filename.c_str(), ifstream::in);//open the i-th oFile
        while (!file_in.eof()){
			string line;
            getline(file_in, line);
            segments.push(line);
        }
    }
    
    //check that they are all relocatable
    for (unsigned int i = 0; i < oFiles.size(); i++){
 //       check that load address is 0;
    }
    
    //calculate program size
    int segSize = 0;
    for (unsigned int i = 0; i < oFiles.size(); i++){
 //       segSize = length in header record of segment//////////////////
        values.programSize += segSize;
    }
    
    //caluclate page
    string page = segments.front(); //get header record from first segment
    //do some manipulation to get page value out/////////////////////////
    values.page = to_int(page);
    /*
    detect page boundary errors;
    for (each segment){
        calculate PLA;
        add ENT symbols to symbol table;
        warn id duplicates found;
    }*/
	return 0;
}
Beispiel #11
0
int main (const int argc, char* argv[]) {
    string usage = string(argv [0]) + " <k> <fasta_file>";
    if (argc < 3) {
        cout << usage << endl;
        return 1;
    }
    cerr << vector <int>().max_size() << endl;
    struct rlimit stack_limit;
    getrlimit(RLIMIT_STACK, &stack_limit);
    stack_limit.rlim_cur = RLIM_INFINITY;
    if (setrlimit(RLIMIT_STACK, &stack_limit) != 0) {
        cerr << "Unlimiting stack size failed, might crash.\n";
    }
    int k = atol(argv [1]);
    boost::filesystem::path orig_file = boost::filesystem::path(argv [2]);
    ifstream file_in(orig_file.string(), ifstream::in);
    string seq;
    file_in >> seq; file_in >> seq;
    file_in.close();
    
    SR_index index(k, seq.size());
    index.construct(orig_file.string());
    index.print_superstring();
    string query;

    file_in.open(orig_file.string(), ifstream::in);
    int counter = 0;
    while (file_in >> seq) {
        file_in >> seq;
        bool ok = false;
        string q = seq.substr(rand()%(seq.size() - k + 1), k);
        vector <int> results = index.find_reads(q, false);
        for (auto x : results) {
            if (x == counter) {
                ok = true;
                break;
            }
        }
        if (!ok) {
            cerr << "String not found where expected!\n";
            cerr << q << ' ' << counter << endl;
        }
        counter++;
    } 
    cerr << "finish" << endl;
    while (cin >> query) {
        for (auto x : index.find_reads(query, false)) {
            cout << x << ' ';
        }
        cout << endl;
    } 

} 
Beispiel #12
0
RScope* InliningDatabase::lookup_and_remove(LookupKey* outer, LookupKey* inner) {
  if (table_no == 0) return NULL;  // Skim the cream

  unsigned int index = index_for(outer, inner);
  if (!table[index].is_filled()) return NULL; 
  while (!table[index].equal(outer, inner)) {
    index = next_index(index);
    if (table[index].is_empty()) return NULL;
  }
  table[index].set_deleted();
  table_no--;
  return file_in(outer, inner);
}
Beispiel #13
0
problem Flexible_vector::Read_file_without_index(std::string filename)
{
    std::cout<<"IN Read_file_without_index"<<std::endl;
    std::ifstream file_in(filename.c_str());
    std::string e,line;
    problem prob;
    int elements, max_index, inst_max_index;
	
    char *endptr;

	prob.l = 0;
	elements = 0;
    max_index = 0;
    while (std::getline(file_in, line))
    {
        //std::cout<<std::endl;
        inst_max_index = 0;
        std::stringstream  lineStream(line);

        std::getline(lineStream, e,',');   //label
        if(e.empty())  //empty line
            exit_input_error(prob.l+1);
        prob.y.push_back(stringToNum<double>(e));
        //std::cout<<prob.y[prob.y.size()-1]<<',';
        //prob.y.push_back(atof(e));
        //if(endptr == e || *endptr != '\0')
        //    exit_input_error(prob.l+1);

        prob.x_ptr.push_back(elements);
        //feature
        while(std::getline(lineStream, e,','))
        {
            inst_max_index++;
            node x_tmp;
            x_tmp.index = inst_max_index;
            x_tmp.value = stringToNum<double>(e);
            //x_tmp.value = atof(e);
            prob.x.push_back(x_tmp);
            //std::cout<<prob.x[prob.x.size()-1].value<<',';
            elements++;
        }
        prob.x_interval.push_back(inst_max_index);
        if(inst_max_index > max_index)
            max_index = inst_max_index;
        prob.l++;
    }
    prob.max_feature = max_index;
    return prob;
}
int _tmain(int argc, _TCHAR* argv[])
{
	ifstream file_in("in.txt");		//in.txt,链表数据输入文件
	List<int> L;
	int EndTag;		//链表数据输入的结束符
	file_in >> EndTag;
	L.PreInput(EndTag, file_in);		//前插法建立单链表
	bool k1;		//判断是顺序输出还是反序输出单链表
	file_in >> k1;
	FactList_Output(L.getHead(), k1);
	bool k2;
	file_in >> k2;
	FactList_Output(L.getHead(), k2);
	return 0;
}
Beispiel #15
0
RScope* InliningDatabase::select_and_remove(bool* end_of_table) {
  if (table_no == 0) return NULL;  // Skim the cream

  for (unsigned int index = 0 ; index < table_size; index++) {
    if (table[index].is_filled() && table[index].is_outer()) {
      RScope* result = file_in(&table[index].outer);
      table[index].set_deleted();
      table_no--;
      *end_of_table = false;
      return result;
    }
  }
  *end_of_table = true;
  return NULL;
}
Beispiel #16
0
/**
 * @brief Restores the state of the last simulation or places the particles in
 *the shape of a cube if no state is found.
 *
 * @param[out] buffer        Points to the particles buffer to be filled
 * @param[in] parameters    Contains the simulation parameters
 *
 */
void sph_simulation::init_particles(particle* buffer,
                                    const simulation_parameters& parameters) {
  int particles_per_cube_side = ceil(cbrtf(parameters.particles_count));
  float side_length = cbrtf(initial_volume);
  float spacing = side_length / (float)particles_per_cube_side;

  std::cout << "volume: " << initial_volume << " side_length: " << side_length
            << " spacing: " << spacing << std::endl;

  // Last simualtion serialized its last frame
  // Lets load that and pick up where it let off
  std::filebuf fb;
  if (fb.open("last_frame.bin", std::ios::in)) {
    std::istream file_in(&fb);

    cereal::BinaryInputArchive archive(file_in);
    archive.loadBinary(buffer, sizeof(particle) * parameters.particles_count);

    fb.close();
  }
  // No serialized particle array was found
  // Initialize the particles in their default position
  else {
    for (unsigned int i = 0; i < parameters.particles_count; ++i) {
      // Arrange the particles in the form of a cube
      buffer[i].position.s[0] =
          (float)(i % particles_per_cube_side) * spacing - side_length / 2.f;
      buffer[i].position.s[1] =
          ((float)((i / particles_per_cube_side) % particles_per_cube_side) *
           spacing);
      buffer[i].position.s[2] =
          (float)(i / (particles_per_cube_side * particles_per_cube_side)) *
              spacing -
          side_length / 2.f;

      buffer[i].velocity.s[0] = 0.f;
      buffer[i].velocity.s[1] = 0.f;
      buffer[i].velocity.s[2] = 0.f;
      buffer[i].intermediate_velocity.s[0] = 0.f;
      buffer[i].intermediate_velocity.s[1] = 0.f;
      buffer[i].intermediate_velocity.s[2] = 0.f;

      buffer[i].density = 0.f;
      buffer[i].pressure = 0.f;
    }
  }
}
Beispiel #17
0
qint32 PrintTask::getFileRealSize(const QString &fileName)
{
    QVariant max_fsize(0);

    QFile file_in(fileName);
    if (!file_in.open(QIODevice::ReadOnly) ){
        return 0;
    }
    file_in.close();
    max_fsize = file_in.size();
    bool ok;
    qint32 fsize = max_fsize.toInt(&ok);
    if (ok){
        return fsize;
    }
    return 0;
}
Beispiel #18
0
void LLSpellChecker::addToDictFile(const std::string& dict_path, const std::string& word)
{
	std::vector<std::string> word_list;

	if (gDirUtilp->fileExists(dict_path))
	{
		llifstream file_in(dict_path.c_str(), std::ios::in);
		if (file_in.is_open())
		{
			std::string word; int line_num = 0;
			while (getline(file_in, word))
			{
				// Skip over the first line since that's just a line count
				if (0 != line_num)
				{
					word_list.push_back(word);
				}
				line_num++;
			}
		}
		else
		{
			// TODO: show error message?
			return;
		}
	}

	word_list.push_back(word);

	llofstream file_out(dict_path.c_str(), std::ios::out | std::ios::trunc);	
	if (file_out.is_open())
	{
		file_out << word_list.size() << std::endl;
		for (std::vector<std::string>::const_iterator itWord = word_list.begin(); itWord != word_list.end(); ++itWord)
		{
			file_out << *itWord << std::endl;
		}
		file_out.close();
	}
}
Beispiel #19
0
bool BFile::copy ( const BAsciiString &filename, const BAsciiString &new_filename ) {
    if ( !exists ( filename ) || exists ( new_filename ) ) {
        return false;
    }

    BFile file_in ( filename );
    if ( !file_in.open ( BIODevice::ReadOnly ) ) {
        return false;
    }

    BFile file_out ( new_filename );
    if ( !file_out.open ( BIODevice::WriteOnly ) ) {
        return false;
    }

    file_out.write ( file_in.Buffer );

    file_in.close();
    file_out.close();

    return true;
}
Beispiel #20
0
int initialize(char *filename, fileptr *metadata)
{
        DIR             *dip;
        struct dirent   *dit;
        int             i = 0;
	char 		md5[32+1];
 
	//anoigma katalogou
        if ((dip = opendir(filename)) == NULL)
        {
                perror("opendir");
                return -1;
        }
        // struct dirent *readdir(DIR *dir);
	// Read in the files from argv[1] and print 
        while ((dit = readdir(dip)) != NULL)
        {
                i++;
		if ( dit->d_type != DT_REG )
			continue;
		if ( !strcmp(dit->d_name,".") || !strcmp(dit->d_name,"..") )
			continue;
		if ( MD5Sum_File(dit->d_name,md5)<0 )
		{
			fprintf(stderr,"MD5Sum_File error\n");
			continue;
		}
		//upadate listas 
		if ( !file_in(*metadata,dit->d_name, md5) )
			add_file(metadata,dit->d_name, md5);
        }
        // int closedir(DIR *dir);
        if (closedir(dip) == -1)
        {
                perror("closedir");
                return -1;
        }
        return 0;
}
bool file_io::file_load() {
    const char * file_name = File_name;
    short line = 0;
    if (has_ran) {
        file_info.clear();
    }
    std::string local_buffer;
    std::ifstream file_in(file_name, std::ios::in | std::ios::binary);

    if (file_in.is_open()) {
        while (getline(file_in, local_buffer)) {
            file_info.push_back(local_buffer);
           // std::cout << file_info.at(line) << std::endl;
            ++line;
        }
        has_ran = true;
        return true;
    } else {
        std::cerr << "file_io error, could not open" << std::endl;
        has_ran = true;
        return false;
    }
}
int main(int argc, char *argv[])
{
    char infile_name[256],outfile_name[256];
    
    if (argc > 1) strcpy(infile_name,argv[1]);
    else strcpy(infile_name,"course_inf.txt");
    ifstream file_in(infile_name);    //  声明与打开输入流

    if (file_in == 0) {
        cout << "不能打开课程信息文件 " << infile_name << endl;
        exit (1);
    }
   
    if (argc > 2) strcpy(outfile_name,argv[2]);
    else strcpy(outfile_name,"curriculum_scedule.txt");
    ofstream file_out(outfile_name);   //  声明与打开输出流

    if (file_out == 0) {
        cout << "不能打开课程请文件 " << outfile_name << endl;
        exit (1);
    }

    cout<<"课程信息文件为: "<<infile_name<<endl<<endl;
    cout<<"正在排课,请稍候..."<<endl<<endl;

    //Range_Course<8,1000>表示排8学期课(从第1学期到第8学期),最多能对1000门课进行排课
    Range_Course<8,1000> rc(&file_in, &file_out);

    rc.read();               //输入课程信息
    rc.topological_order();  //用拓扑排的思进行排课
    rc.write();              //输出课表

    cout<<"排课结束,课表文件为: "<<outfile_name<<endl;
    cout<<"按任意退出"<<endl;

    return 0;
}
Beispiel #23
0
    Bundle(const std::string filename, const char delimiter='\t',
        int ignoreRows=0) : _columns(0)
    {
        // Abre o arquivo para leitura
        std::ifstream file_in(filename);
        if (!file_in.good())
        throw WUPException(cat("Could not open file: ", filename));

        // Carrega linha a linha
        int rows = 0;
        std::string line;
        std::vector<std::string> cells;

        while(!file_in.eof())
        {
            getline(file_in, line);
            ++rows;

            // Ignora cabecalhos e linhas em branco
            if (line.empty()) continue;
            if (rows <= ignoreRows) continue;

            // Quebra a linha em celulas
            split(cells, line, delimiter);

            // Guarda o numero de colunas
            if (_columns == 0)
                _columns = cells.size();

            // Guarda os dados
            for (uint i=0;i<cells.size();++i)
                _data.push_back( parse_double(cells[i]) );
        }

        file_in.close();
    }
int main(int argc, char* argv[]) {
	if (argc < 4 || argc > 6) {
		std::cout << "Usage: embedfile [-wx] [-text] <inout> <output> <fieldname>" << std::endl;

		return error_invalidargs;
	}

	bool wxWidgets_image = false;
	bool text_content = false;

	int argc_offset = 1;

	if (casecmp(argv[argc_offset], "-wx")) {
		wxWidgets_image = true;

		argc_offset++;
	}

	if (casecmp(argv[argc_offset], "-text")) {
		text_content = true;

		argc_offset++;
	}

	std::string input_file(argv[argc_offset]);
	std::string output_basename(argv[argc_offset + 1]);
	std::string field_name(argv[argc_offset + 2]);

	std::ios::openmode mode = std::ios::in;
	if (!text_content) {
		mode |= std::ios::binary;
	}

	std::ifstream file_in(input_file.c_str(), mode);
	if (file_in.bad()) {
		std::cout << "ERROR: Error opening input file: " << input_file << std::endl;
		return error_cantopenfile;
	}

	// Get the size of the input stream
	size_t input_size;
	file_in.seekg(0, std::ios::end);

	if ((int) file_in.tellg() != -1) {
		input_size = (size_t) file_in.tellg();
	}
	else {
		std::cout << "ERROR: Failed to get size of input file: " << input_file << std::endl;
		file_in.close();
		return error_ioerror;
	}

	file_in.seekg(0, std::ios::beg);

	// Generates two files, one header and one source file
	std::string headerName = output_basename + ".h";
	std::string sourceName = output_basename + ".cpp";

	std::ofstream source_out(sourceName.c_str());
	if (source_out.bad()) {
		std::cout << "ERROR: Error opening output file: " << sourceName << std::endl;
		return error_cantoutputfile;
	}

	std::ofstream header_out(headerName.c_str());
	if (header_out.bad()) {
		std::cout << "ERROR: Error opening output file: " << headerName << std::endl;
		return error_cantoutputfile;
	}

	if (text_content) {
		do_text_content(file_in, source_out, field_name, input_size);
	}
	else {
		do_binary_content(file_in, source_out, field_name, input_size, wxWidgets_image);
	}

	write_header(header_out, field_name, text_content, wxWidgets_image);

	file_in.close();

	source_out.close();
	header_out.close();

	return error_none;
}
Beispiel #25
0
int main()
{
    remove(sr_go_1);
    remove(sr_go_2);
    remove(kl_stop_1);
    remove(kl_stop_2);
    int ready1,ready2;
    //new_game
     new_game();
     countpoints();
    //in file
    file_in();
    fkl1= fopen(kl_1,"w"); fclose(fkl1);
    fkl2= fopen(kl_2,"w"); fclose(fkl1);
    if((fstop1 = fopen(kl_stop_1,"w"))==0){ printf("\nstopfile(1) error"); Sleep(3000);exit(1);}
    else fclose(fstop1);
    if((fstop2 = fopen(kl_stop_2,"w"))==0){ printf("\nstopfile(2) error"); Sleep(3000);exit(1);}
    else fclose(fstop2);
    while(1)
    { printf("1");
            remove(sr_go_1); remove(sr_go_2);
            while((fstop1 = fopen(kl_stop_1,"w"))==0) printf("\nTry open kl_stop_1"); 
            while((fstop2 = fopen(kl_stop_2,"w"))== 0) printf("\nTry open kl_stop_2") ; 
            fclose(fstop1);
            fclose(fstop2);
            ready1= 0; ready2= 0;
            while(ready1*ready2 == 0)
            { 
               //printf("2");
               Sleep(500);
                 if(ready1 == 0) 
                 { 
                           srgo1 = fopen(sr_go_1,"r"); 
                           if(srgo1!= 0)
                             {
                                   check_file(1);
                                   ready1 = 1; 
                                   printf("\nready 1");
                                   fclose(srgo1);
                                   if(remove(sr_go_1) !=0) printf("\ncant del sr_go_1");
                             }
                           
                 }
                 if(ready2 == 0)
                 {
                           srgo2 = fopen(sr_go_2,"r"); 
                           if(srgo2!=0)
                           {
                                      check_file(2);
                                      ready2 = 1;
                                      printf("\nready 2");
                                      fclose(srgo2);  
                                      if(remove(sr_go_2) !=0) printf("\ncant del sr_go_2");
                           }
                           
                 }
            }
            //countwar
            WarCount();
            countmaps();
            if(countpoints()== 1); // конец игры
            file_in();
    }
}
Beispiel #26
0
std::string DecodeText(std::string file_name)
{
  ifstream file_in(file_name, std::ios::binary);
  if (!file_in.is_open()) return "NA";
  map<string, string, StringComparer> codes_map;
  // read sequence length
  int sequence_length;
  file_in.read(reinterpret_cast<char*>(&sequence_length), sizeof(int));
  // read max_code_length
  int max_code_length;
  file_in.read(reinterpret_cast<char*>(&max_code_length), sizeof(int));
  // read codes num
  int num_codes;
  file_in.read((char*)&num_codes, sizeof(int));
  // read codes one by one
  char* str = new char[sequence_length+1];
  char* code = new char[max_code_length+1];
  for (int i = 0; i < num_codes; ++i) {
    file_in.read(str, sizeof(char)*(sequence_length+1));
    file_in.read(code, sizeof(char)*(max_code_length+1));
    codes_map[string(code)] = string(str);
  }
  delete [] str;
  delete [] code;

  // read num bytes to read
  int num_data_bytes;
  file_in.read((char*)&num_data_bytes, sizeof(int));
  // read data
  string* data = new string();
  for (int i = 0; i < num_data_bytes; ++i) {
    char byte;
    file_in.read((char*)&byte, sizeof(char));
    (*data) += ULongToBinaryString(byte);
  }

  // retrive decoded text
  string decoded_text = "";
  int offset = 0;
  bool no_more = false;
  while (offset < data->size() && !no_more) {
    for (int i = 1; i <= max_code_length; ++i) {
      string probable_code = data->substr(offset, i);
      if (codes_map.find(probable_code) != codes_map.end()) {
        string s = codes_map[probable_code];
        decoded_text += s;
        offset += i;
        break;
      }
      if (i == max_code_length) no_more = true;
    }
  }
  cout << "================ " << file_name << " ================";
  cout << "\nCoded file size=" << file_in.tellg();
  cout << "\n\tNum of codes=" << num_codes;
  cout << "\n\tMax. code length=" << max_code_length;
  cout << "\n\tCharacter sequence length=" << sequence_length << endl;

  file_in.close();
  return decoded_text;
}
void fileTransmitter::convertFileToMsg(const QString &unicFileId,const QString &fileName)
{
    if ( unicFileId.isEmpty ()){
        emit error(VPrn::InternalAppError,
                   QObject::trUtf8("Отсутствует индетификатор файла.\n%1:%2")
                   .arg( __FILE__ )
                   .arg( __LINE__ )
                   );
        return;
    }

    if ( !QFile::exists(fileName) ){
        return;
    }

    QFile file_in(fileName);

    if (!file_in.open(QIODevice::ReadOnly) ){
        emit error(VPrn::FileIOError,
                   QObject::trUtf8("Не могу открыть запрошенный файл: %1.\n%2:%3")
                   .arg(fileName)
                   .arg( __FILE__ )
                   .arg( __LINE__ )
                   );
        return ;
    }

    qint64 fSize64 = file_in.size();


    if (fSize64 > m_MaxInt32 - sizeof(qint32) ){
        emit error(VPrn::FileIOError,
                   QObject::trUtf8("Файл %1 имеет слишком большой размер:[%2 байт].\n%3:%4")
                   .arg(fileName)
                   .arg(fSize64,0,10)
                   .arg( __FILE__ )
                   .arg( __LINE__ )
                   );
        return ;
    }


    QByteArray data = qCompress( file_in.readAll() );
    file_in.close();

    if (data.isEmpty()){
        emit error(VPrn::FileIOError,
                   QObject::trUtf8("Файл %1 не содержит данных или ошибка чтения.\n%2:%3")
                   .arg(fileName)
                   .arg( __FILE__ )
                   .arg( __LINE__ )
                   );
        return ;
    }

    QByteArray task_data;
    QDataStream out(&task_data, QIODevice::WriteOnly );
    out.setVersion(QDataStream::Qt_3_0);
    out << unicFileId;          // уникальный индетификатор отправляемого файла
    out << (qint32) fSize64;    // Размер не сжатого файла
    out << data;                // Файл для печати в формате QByteArray (сжатый)

    // Формируем сообщение Msg
    Message message;
    message.setType(VPrn::Que_ReciveFile);
    message.setMessageData (task_data);
    emit fileReadyToSend(message);
}
Beispiel #28
0
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    // Open the installer file
    QString name_in = "full_installer_script.nsi";
    QString name_out = name_in + "temp";
    QFile file_in(name_in);
    QFile file_out(name_out);
    file_in.open(QIODevice::ReadOnly | QIODevice::Text);
    file_out.open(QIODevice::WriteOnly | QIODevice::Truncate);
    QTextStream in_enc(&file_in);
    QTextStream out_enc(&file_out);
    out_enc.setCodec("UTF-8");
    while(!in_enc.atEnd())
    {
        QString line = in_enc.readLine();
        // Update to current revision
        if(line.contains("  !define REVISION "))
        {
            QStringList temp = line.split("\"");
            temp[1] = QString::number(getLocalVersion());
            line = temp.join("\"");
        }

        // Update translations lines (including commented ones)
        QString langString = "LangString ";
        if(line.startsWith("; LangString")){
            langString = "; LangString ";
        }

        if(line.startsWith(langString)){
            QString backup = line;

            // Get language infos
            QStringList temp_lang = line.replace("{","|").replace("}","|").split("|");
            QStringList temp_lang_name = temp_lang[1].split("_");
            QString langName = temp_lang_name[1];
            QString langCode = getLanguageCodeFromName(langName);

            // Get tag
            QStringList temp_tag = temp_lang[0].split(" ");
            QString tag = temp_tag[1];
            if(backup.startsWith(";"))
            { // Pick the second char as the first is a comment
                tag = temp_tag[2];
            }
            QString translation = getTranslation(langCode, tag);
            if (!translation.isEmpty())
            {
                line = langString + tag + " ${LANG_" + langName + "} " + "\"" + translation + "\"";
            }
            else
            {
                line = backup;
            }
        }

        out_enc << line << "\n";
    }
    file_in.close();
    file_out.close();
    QFile::remove(name_in);
    QFile::rename(name_out,name_in);
    return 0;
}
Beispiel #29
0
void LLSpellChecker::initHunspell(const std::string& dict_name)
{
	if (mHunspell)
	{
		delete mHunspell;
		mHunspell = NULL;
		mDictName.clear();
		mDictFile.clear();
		mIgnoreList.clear();
	}

	const LLSD dict_entry = (!dict_name.empty()) ? getDictionaryData(dict_name) : LLSD();
	if ( (!dict_entry.isDefined()) || (!dict_entry["installed"].asBoolean()) || (!dict_entry["is_primary"].asBoolean()))
	{
		sSettingsChangeSignal();
		return;
	}

	const std::string app_path = getDictionaryAppPath();
	const std::string user_path = getDictionaryUserPath();
	if (dict_entry.has("name"))
	{
		const std::string filename_aff = dict_entry["name"].asString() + ".aff";
		const std::string filename_dic = dict_entry["name"].asString() + ".dic";
		if ( (gDirUtilp->fileExists(user_path + filename_aff)) && (gDirUtilp->fileExists(user_path + filename_dic)) )
			mHunspell = new Hunspell((user_path + filename_aff).c_str(), (user_path + filename_dic).c_str());
		else if ( (gDirUtilp->fileExists(app_path + filename_aff)) && (gDirUtilp->fileExists(app_path + filename_dic)) )
			mHunspell = new Hunspell((app_path + filename_aff).c_str(), (app_path + filename_dic).c_str());
		if (!mHunspell)
			return;

		mDictName = dict_name;
		mDictFile = dict_entry["name"].asString();

		if (dict_entry["has_custom"].asBoolean())
		{
			const std::string filename_dic = user_path + mDictFile + DICT_CUSTOM_SUFFIX + ".dic";
			mHunspell->add_dic(filename_dic.c_str());
		}

		if (dict_entry["has_ignore"].asBoolean())
		{
			llifstream file_in(user_path + mDictFile + DICT_IGNORE_SUFFIX + ".dic", std::ios::in);
			if (file_in.is_open())
			{
				std::string word; int idxLine = 0;
				while (getline(file_in, word))
				{
					// Skip over the first line since that's just a line count
					if (0 != idxLine)
					{
						LLStringUtil::toLower(word);
						mIgnoreList.push_back(word);
					}
					idxLine++;
				}
			}
		}

		for (dict_list_t::const_iterator it = mDictSecondary.begin(); it != mDictSecondary.end(); ++it)
		{
			const LLSD dict_entry = getDictionaryData(*it);
			if ( (!dict_entry.isDefined()) || (!dict_entry["installed"].asBoolean()) )
				continue;

			const std::string filename_dic = dict_entry["name"].asString() + ".dic";
			if (gDirUtilp->fileExists(user_path + filename_dic))
				mHunspell->add_dic((user_path + filename_dic).c_str());
			else if (gDirUtilp->fileExists(app_path + filename_dic))
				mHunspell->add_dic((app_path + filename_dic).c_str());
		}
	}

	sSettingsChangeSignal();
}
Beispiel #30
0
eventor::eventor(std::vector<std::string> iinput_fname, int imin_per, 
				 FP_TYPE imin_len, FP_TYPE imin_dev, FP_TYPE isr,
				 int ievent_t_steps, FP_TYPE ioverlap, 
				 std::vector<std::string> mslp_file_name, std::string mslp_field_name,
				 std::vector<std::string> wind_file_name, std::string wind_field_name,
				 std::string lsm_file_name, std::string mesh_file) :
				 min_per(imin_per), min_len(imin_len), min_dev(imin_dev),
				 sr(isr), event_t_steps(ievent_t_steps), min_overlap(ioverlap),
				 lsm(NULL), mslp_footprint(NULL), wind_footprint(NULL)
{
	// initialise here but should be command line argument
	hours_per_t_step = 6;
	// check that there are enough netCDF files to go with the extrema files
	if (iinput_fname.size() != mslp_file_name.size() ||
		iinput_fname.size() != wind_file_name.size())
		throw (std::string("Number of input netCDF files do not equal the number of extrema files"));

	// load the extrema
	for (unsigned int i=0; i<iinput_fname.size(); i++)
	{
	    std::ifstream file_in(iinput_fname[i].c_str(), std::ios::in);
		std::cout << "# Reading data" << std::endl;
		if (!file_in.is_open())
			throw (std::string("File " + iinput_fname[i] + " could not be opened."));
		ex_list.load(iinput_fname[i], mv, i>0);
		file_in.close();
	}
	
	// load the MSLP netCDF files
	for (unsigned int i=0; i<mslp_file_name.size(); i++)
	{
		mslp_field.push_back(new ncdata(mslp_file_name[i], mslp_field_name));
	}

	// load the wind speed netCDF files
	for (unsigned int i=0; i<wind_file_name.size(); i++)
	{
		wind_speed_field.push_back(new ncdata(wind_file_name[i], wind_field_name));
	}
	
	// load the time netCDF files
	for (unsigned int i=0; i<mslp_file_name.size(); i++)
	{
		NcFile* nc_file = new NcFile(mslp_file_name[i].c_str());
		// get the time netCDF variable
		NcVar* nc_t_var = nc_file->get_var(mslp_field[0]->get_time_dim_name().c_str());
		int t_len = nc_t_var->get_dim(0)->size();
		FP_TYPE* time_data = new FP_TYPE[t_len];
		nc_t_var->get(time_data, t_len);
		time_field.push_back(time_data);
		time_length.push_back(t_len);
		// if this is the first netCDF file then get the reference time
		if (i==0)
			mslp_field[0]->get_reference_time(ref_year, ref_month, ref_day, ref_day_sc, ref_ndays_py);
	}
	
	// create the wind and mslp footprints
	footprint_width = mslp_field[0]->get_lon_len();
	footprint_height = mslp_field[0]->get_lat_len();
	wind_footprint = new FP_TYPE[footprint_height*footprint_width];
	mslp_footprint = new FP_TYPE[footprint_height*footprint_width];
	
	if (lsm_file_name != "")
		lsm = new ncdata(lsm_file_name, "lsm");
		
	// load the triangular mesh file
	tg.load(mesh_file);
}