Example #1
0
void LA_ProjList::SaveBin( lem::Stream &bin ) const
{
 bin.write(&Char,sizeof(Char));
 Collect<LA_WordProjection>::SaveBin(bin);
 return;
}
void ExportCoordFunction_Add::SaveBin(lem::Stream & bin) const
{
    ExportCoordFunction::SaveBin(bin);
    bin.write(&pair, sizeof(pair));
    return;
}
void WordEntries_File::LoadBin(lem::Stream &bin)
{
    ml_ref.LoadBin(bin);

    Delete_Entries();

    entry_pos.clear();

    coord_ref.LoadBin(bin);

    /*
     LEM_CHECKIT_Z( group.empty() );
     const int n_group = bin.read_int();
     for( int i=0; i<n_group; ++i )
      {
       SG_EntryGroup *g = new SG_EntryGroup(bin);
       group.insert( std::make_pair( g->GetKey(), g ) );
      }
    */
    lookup_table.LoadBin(bin);

    /*
    // #if LEM_DEBUGGING==1
     lem::mout->eol();
     for( int kkk=0; kkk<lookup_table.lexem_slot.size(); ++kkk )
      {
       WordEntries_LookUpItem xxx = lookup_table.lexem_slot[kkk];
       lem::mout->printf( "x[%d]=%d,%d ", kkk, xxx.start_index, xxx.len );
      }
     lem::mout->eol();
    // #endif
    */

    ientry.LoadBin(bin);

    u_entry.LoadBin(bin);

    ML_entry_key_list.LoadBin(bin);
    ML_entry_lex_list.LoadBin(bin);
    ML_entry_pre_list.LoadBin(bin);

    bin.read(&max_ml_len, sizeof(max_ml_len));
    bin.read(predefined_entry, sizeof(predefined_entry));

    const int n_entry = bin.read_int();
    entry.resize(n_entry);

    // загрузили все обязательные данные, теперь опциональная загрузка.
    lem::Stream::pos_type epos_begin_pos = 0;
    lem::Stream::pos_type entries_begin_pos = 0;
    lem::Stream::pos_type end_pos = 0;

    bin.read(&epos_begin_pos, sizeof(epos_begin_pos));
    bin.read(&entries_begin_pos, sizeof(entries_begin_pos));
    bin.read(&end_pos, sizeof(end_pos));

    if (lazy_load)
    {
        // статьи пока не загружаем.

        entry.Nullify();

        // прочитаем только список позиций начала каждой статьи.
        bin.seekp(epos_begin_pos);
        entry_pos.LoadBin(bin);

        lem::MCollect< std::pair<int, int> > key_to_index_tmp;
        key_to_index_tmp.LoadBin(bin);
        for (lem::Container::size_type i = 0; i < key_to_index_tmp.size(); ++i)
            key_to_index.insert(key_to_index_tmp[i]);

        lem::MCollect<Lexem> ML_tmp;
        ML_tmp.LoadBin(bin);
        for (lem::Container::size_type i = 0; i < ML_tmp.size(); ++i)
            ML_fronts.insert(ML_tmp[i]);

        ML_tmp.LoadBin(bin);
        for (lem::Container::size_type i = 0; i < ML_tmp.size(); ++i)
            ML_ML.insert(ML_tmp[i]);
    }
    else
    {
        bin.seekp(entries_begin_pos);

        entry_pos.clear();

        // список словарных статей загружаем сразу целиком в память.
        for (int i0 = 0; i0 < n_entry; i0++)
        {
            entry[i0] = new SG_Entry;
            entry[i0]->LoadBin(bin);

            if (entry[i0] != bogus_entry)
                entry[i0]->ReattachToRefs(*sg);
        }

        for (lem::Container::size_type ie = 0; ie < entry.size(); ie++)
        {
            key_to_index.insert(std::make_pair(entry[ientry[ie]]->GetKey(), ie));
        }

        coord_ref.AllAttached();

#if defined SOL_LOADTXT && defined SOL_COMPILER
        for (lem::Container::size_type k = 0; k < entry.size(); ++k)
        {
            const SG_Entry & e = GetWordEntry(k);
            entry_class_lookup.insert(std::make_pair(std::make_pair(lem::to_upper(e.GetName()), e.GetClass()), e.GetKey()));
    }
#endif

        for (lem::Container::size_type i = 0; i < ML_entry_key_list.size(); ++i)
        {
            const int ik = ML_entry_key_list[i];
            const SG_Entry &e = GetEntryByKey(ik);

            for (lem::Container::size_type j = 0; j < e.forms().size(); ++j)
            {
                const Lexem & form = e.forms()[j].name();

                if (form.Count_Lexems() > 1)
                {
                    UCStringSet list;
                    form.Split(list);
                    ML_fronts.insert(list.front());
                    ML_ML.insert(form);
                }
            }
        }
}

    bin.seekp(end_pos);

    return;
}
Example #4
0
void LA_ProjList::LoadBin( lem::Stream &bin )
{
 bin.read(&Char,sizeof(Char));
 Collect<LA_WordProjection>::LoadBin(bin);
 return;
}
void ExportCoordFunction::SaveBin( lem::Stream & bin ) const
{
 bin.write_int(type);
}
void WordEntries_File::SaveBin(lem::Stream &bin) const
{
#if defined SOL_SAVEBIN
    ml_ref.SaveBin(bin);

    coord_ref.SaveBin(bin);

    lookup_table.SaveBin(bin);
    /*
    // #if LEM_DEBUGGING==1
     lem::mout->eol();
     for( int kkk=0; kkk<lookup_table.lexem_slot.size(); ++kkk )
      {
       WordEntries_LookUpItem xxx = lookup_table.lexem_slot[kkk];
       lem::mout->printf( "x[%d]=%d,%d ", kkk, xxx.start_index, xxx.len );
      }
     lem::mout->eol();
    // #endif
    */

    ientry.SaveBin(bin);
    u_entry.SaveBin(bin);

    ML_entry_key_list.SaveBin(bin);
    ML_entry_lex_list.SaveBin(bin);
    ML_entry_pre_list.SaveBin(bin);

    bin.write(&max_ml_len, sizeof(max_ml_len));
    bin.write(predefined_entry, sizeof(predefined_entry));

    bin.write_int(CastSizeToInt(entry.size()));

    lem::Stream::pos_type p1 = bin.tellp();

    lem::Stream::pos_type epos_begin_pos = 0;
    lem::Stream::pos_type entries_begin_pos = 0;
    lem::Stream::pos_type end_pos = 0;

    bin.write(&epos_begin_pos, sizeof(epos_begin_pos)); // сюда впишем позицию списка позиций статей
    bin.write(&entries_begin_pos, sizeof(entries_begin_pos)); // а сюда - начало списка статей
    bin.write(&end_pos, sizeof(end_pos)); // а сюда - позицию после лексикона, чтобы другие модули могли продолжить загрузку из бинарного файла

    lem::MCollect<lem::Stream::pos_type> entry_pos_tmp;
    entry_pos_tmp.resize(entry.size());
    epos_begin_pos = bin.tellp();
    entry_pos_tmp.SaveBin(bin);

    lem::MCollect< std::pair<int, int> > key_to_index_tmp;
    key_to_index_tmp.reserve(key_to_index.size());
    for (std::map< int/*entry_key*/, int/*entry_index*/ >::const_iterator it = key_to_index.begin(); it != key_to_index.end(); ++it)
    {
        key_to_index_tmp.push_back(*it);
    }
    key_to_index_tmp.SaveBin(bin);

    lem::MCollect<Lexem> ML_fronts_tmp;
    ML_fronts_tmp.reserve(ML_fronts.size());
    for (std::set<Lexem>::const_iterator it = ML_fronts.begin(); it != ML_fronts.end(); ++it)
        ML_fronts_tmp.push_back(*it);
    ML_fronts_tmp.SaveBin(bin);


    lem::MCollect<Lexem> ML_ML_tmp;
    ML_ML_tmp.reserve(ML_ML.size());
    for (std::set<Lexem>::const_iterator it = ML_ML.begin(); it != ML_ML.end(); ++it)
        ML_ML_tmp.push_back(*it);
    ML_ML_tmp.SaveBin(bin);

    entries_begin_pos = bin.tellp();

    for (lem::Container::size_type i = 0; i < entry.size(); i++)
    {
        entry_pos_tmp[i] = bin.tellp();
        entry[i]->SaveBin(bin);
    }

    end_pos = bin.tellp();

    bin.seekp(p1);
    bin.write(&epos_begin_pos, sizeof(epos_begin_pos));
    bin.write(&entries_begin_pos, sizeof(entries_begin_pos));
    bin.write(&end_pos, sizeof(end_pos));
    entry_pos_tmp.SaveBin(bin);
    bin.seekp(end_pos);

#endif

    return;
}
Example #7
0
void LEMM_Compiler::SaveBin( lem::Stream & bin ) const
{
 bin.write_bool(true);

 const lem::uint32_t model_flags = 0x0000000E;
 bin.write( &model_flags, sizeof(model_flags) );
 bin.write_int( suffix_len );

 bin.write_int( CastSizeToInt(suffices.size()) );
 for( lem::Container::size_type i=0; i<suffices.size(); ++i )
  {
   bin.write( &suffices[i].first, sizeof(suffices[i].first) );
   lem::Save_Packed(suffices[i].second,bin);
  }

 bin.write_int( CastSizeToInt(words.size()) );
 for( lem::Container::size_type i=0; i<words.size(); ++i )
  {
   bin.write( &words[i].first, sizeof(words[i].first) );
   lem::Save_Packed(words[i].second,bin);
  }

 bin.write_int( CastSizeToInt(ngram2.size()) );
 for( lem::Container::size_type i=0; i<ngram2.size(); ++i )
  bin.write( &ngram2[i], sizeof(ngram2[i]) );

 bin.write_int( CastSizeToInt(ngram2_1.size()) );
 for( lem::Container::size_type i=0; i<ngram2_1.size(); ++i )
  bin.write( &ngram2_1[i], sizeof(ngram2_1[i]) );

 bin.write_int( CastSizeToInt(ngram3.size()) );
 for( lem::Container::size_type i=0; i<ngram3.size(); ++i )
  bin.write( &ngram3[i], sizeof(ngram3[i]) );

 bin.write_int( CastSizeToInt(ngram3_1.size()) );
 for( lem::Container::size_type i=0; i<ngram3_1.size(); ++i )
  bin.write( &ngram3_1[i], sizeof(ngram3_1[i]) );

 bin.write_int( CastSizeToInt(ngram3_2.size()) );
 for( lem::Container::size_type i=0; i<ngram3_2.size(); ++i )
  bin.write( &ngram3_2[i], sizeof(ngram3_2[i]) );


 bin.write_int( CastSizeToInt(ngram4.size()) );
 for( lem::Container::size_type i=0; i<ngram4.size(); ++i )
  bin.write( &ngram4[i], sizeof(ngram4[i]) );

 return;
}
Example #8
0
void TrFun_Var::LoadBin( lem::Stream& bin )
{
    TrFunCall::LoadBin(bin);
    bin.read( &var_name, sizeof(var_name) );
    return;
}
Example #9
0
void TrFun_Var::SaveBin( lem::Stream& bin ) const
{
    TrFunCall::SaveBin(bin);
    bin.write( &var_name, sizeof(var_name) );
    return;
}
Example #10
0
void TrType::LoadBin( lem::Stream& bin )
{
    bin.read( &is_const, sizeof(is_const) );
    bin.read( &type, sizeof(type) );
    return;
}
Example #11
0
void TrType::SaveBin( lem::Stream& bin ) const
{
    bin.write( &is_const, sizeof(is_const) );
    bin.write( &type, sizeof(type) );
    return;
}