C++ TFileStream::Read方法代码示例

void Global::LoadIniFile(AnsiString asFileName)
{
    int i;
    for (i = 0; i < 10; ++i)
    { // zerowanie pozycji kamer
        pFreeCameraInit[i] = vector3(0, 0, 0); // wspó³rzêdne w scenerii
        pFreeCameraInitAngle[i] = vector3(0, 0, 0); // k¹ty obrotu w radianach
    }
    TFileStream *fs;
    fs = new TFileStream(asFileName, fmOpenRead | fmShareCompat);
    if (!fs)
        return;
    AnsiString str = "";
    int size = fs->Size;
    str.SetLength(size);
    fs->Read(str.c_str(), size);
    // str+="";
    delete fs;
    TQueryParserComp *Parser;
    Parser = new TQueryParserComp(NULL);
    Parser->TextToParse = str;
    // Parser->LoadStringToParse(asFile);
    Parser->First();
    ConfigParse(Parser);
    delete Parser; // Ra: tego jak zwykle nie by³o wczeœniej :]
};

//---------------------------------------------------------------------------
//Carga una lista de funciones desde archivo
bool TFunciones::LoadFromFile(AnsiString FileName)
{
  int InfoSize;
  TInfoFuncion F;
  TInfoInt I;
  TFCabecera FCabecera;
  TFFuncion FFuncion;
  TFIntervalo FIntervalo;
  TFileStream *Archivo;
  try{
    if( !FileExists(FileName) )
      return false;
    else{
      Archivo = new TFileStream(FileName, fmOpenRead|fmShareExclusive);
      Archivo->Seek(0, soFromBeginning);
      InfoSize = sizeof(TFCabecera);
      Archivo->Read(&FCabecera, InfoSize);
      if(strcmp(FCabecera.ID, ID) != 0)
        throw Exception("Archivo desconocido");
      //FCabecera.Version; Contiene la versión del archivo
      for( int i = 0; i < FCabecera.NFunciones; i++){
        InfoSize = sizeof(TFFuncion);
        Archivo->Read(&FFuncion, InfoSize);
        strcpy(F.Nombre, FFuncion.Nombre);
        F.Graficar = FFuncion.Graficar;
        F.Intervalo = NULL;
        InfoSize = sizeof(TFIntervalo);
        for( int j = 0; j < FFuncion.NIntervalos; j++){
          Archivo->Read(&FIntervalo, InfoSize);
          I.Min = FIntervalo.Min;
          I.Max = FIntervalo.Max;
          strcpy(I.Expresion, FIntervalo.Expresion);
          I.TipoGrafico = FIntervalo.TipoGrafico;
          I.Color = FIntervalo.Color;
          I.Grosor = FIntervalo.Grosor;
          uIntervaloH::Add(F.Intervalo, I);}
        Add(F);
      }
      FModificado = false;
      delete Archivo;
      return true;}
    }
  catch(...){
    return false;}
}

// ---------------------------------------------------------------------------
//
void __fastcall TForm1::DisplayFromFile(TGdViewer *gv, String sFilePath) {
	FullPath = sFilePath;
	TFileStream *fs = new TFileStream(sFilePath, fmShareDenyNone);
	char *buf = new char[fs->Size];
	fs->Read(buf, fs->Size);
	long g = fs->Size;
	gv->DisplayFromMemory((long) buf, &g);
	delete fs;
	delete[]buf;
}

//---------------------------------------------------------------------------
//Agrega una nueva funcion contenida en archivo
bool TFunciones::ImportFunction(AnsiString FileName)
{
  int InfoSize;
  TInfoFuncion F;
  TInfoInt I;
  TFFuncion FFuncion;
  TFIntervalo FIntervalo;
  TFileStream *Archivo;
  try{
    if( !FileExists(FileName) )
      return false;
    else{
      Archivo = new TFileStream(FileName, fmOpenRead|fmShareExclusive);
      Archivo->Seek(0, soFromBeginning);
      InfoSize = sizeof(TFFuncion);
      Archivo->Read(&FFuncion, InfoSize);
      strcpy(F.Nombre, FFuncion.Nombre);
      F.Graficar = FFuncion.Graficar;
      F.Intervalo = NULL;
      InfoSize = sizeof(TFIntervalo);
      for( int i = 0; i < FFuncion.NIntervalos; i++){
        Archivo->Read(&FIntervalo, InfoSize);
        I.Min = FIntervalo.Min;
        I.Max = FIntervalo.Max;
        strcpy(I.Expresion, FIntervalo.Expresion);
        I.TipoGrafico = FIntervalo.TipoGrafico;
        I.Color = FIntervalo.Color;
        I.Grosor = FIntervalo.Grosor;
        uIntervaloH::Add(F.Intervalo, I);}
      Add(F);
      delete Archivo;
      return true;}
    }
  catch(...){
    return false;}
}

AnsiString StringFromFile(const AnsiString FileName, __int64& FileSize)
{
  TFileStream* fs = new TFileStream(FileName, fmOpenRead);
  AnsiString Result;
  try
  {
    FileSize = fs->Size;
    Result.SetLength(FileSize);
    if (fs->Size > 0)
      fs->Read(Result.c_str(), FileSize);
  }
  __finally
  {
    delete fs;
  }
  return Result;
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
AnsiString Load_Base(AnsiString aFileName, TTreeView *tv1, TTreeView *tv2, TTreeView *tv3, TTreeView *tv4)
{
     TDateTime t1= Now();
 // -------------
     TFileStream* FileStream;
     try {
        FileStream = new TFileStream(aFileName, fmOpenRead);
     } catch ( ... ) {
        MessageBox(NULL, " Невозможно открыть файл 'Estimate.dat' \n\n Данные файла не будут загружены", " Ошибка открытия файла ...", MB_ICONERROR);
        return FloatToStrF((Now().Val - t1.Val)*3600.0*24.0, ffFixed, 15, 3) + "c.";
     }
 // -------------
      ShortString tempString;
      int FileVersion = 0;
      FileStream->Read(&tempString[0], 1);   FileStream->Read(&tempString[1], tempString[0]);
      FileStream->Read(&tempString[0], 1);   FileStream->Read(&tempString[1], tempString[0]);
      FileStream->Read(&tempString[0], 1);   FileStream->Read(&tempString[1], tempString[0]);
      FileStream->Read(&tempString[0], 1);   FileStream->Read(&tempString[1], tempString[0]);
      FileStream->Read(&tempString[0], 1);   FileStream->Read(&tempString[1], tempString[0]);

      FileStream->Read(&FileVersion, sizeof(FileVersion));
      Load_(FileStream, tv1, &GlobalElementCounter );
      Load_(FileStream, tv2, &GlobalMaterialCounter);
      Load_(FileStream, tv3, &GlobalMashineCounter );
      Load_(FileStream, tv4, &GlobalEnergoCounter  );


   // ----------- Создаю список материалов и другой фиговины ---------
         PrepareSpecificallArrays();

         CreateMaterialList (tv1);
         CreateRashodnikList(tv1);
         CreateMashineList  (tv1);
         CreateEnergoList   (tv1);
         CreateServiseList  (tv1);

      
/*      Load_2004_07_14(FileStream, tv1, &GlobalElementCounter);
      Load_2004_07_14(FileStream, tv2, &GlobalMaterialCounter);
      Load_2004_07_14(FileStream, tv3, &GlobalMashineCounter);
      Load_2004_07_14(FileStream, tv4, &GlobalEnergoCounter);*/

 // -------------

  delete FileStream;
  return FloatToStrF((Now().Val - t1.Val)*3600.0*24.0, ffFixed, 15, 3) + "c.";
}

bool TCurve::LoadFromFile(AnsiString asName)
{
    DecimalSeparator = '.';
    TFileStream *fs;
    fs = new TFileStream(asName, fmOpenRead | fmShareCompat);
    AnsiString str = "xxx";
    int size = fs->Size;
    str.SetLength(size);
    fs->Read(str.c_str(), size);
    str += "";
    delete fs;
    TQueryParserComp *Parser;
    Parser = new TQueryParserComp(NULL);
    Parser->TextToParse = str;
    Parser->First();
    Load(Parser);

    delete Parser;
    DecimalSeparator = ',';
}

//===========================================================================
//スレッド実行
//===========================================================================
void __fastcall TAttacheCaseFileDecrypt1::Execute()
{

int i, c, len;
float ProgressPercentNumF;  //進捗パーセンテージ（浮動小数点）

// バッファ
char buffer[BUF_SIZE];
char source_buffer[BUF_SIZE];
char temp_buffer[BUF_SIZE];
char output_buffer[LARGE_BUF_SIZE];
char *headerbuffer;

//パスワード
bool fPasswordOk;

String FilePath, FileName;

// ファイルストリーム
TFileStream *fsIn;
TFileStream *fsOut;
bool fInputFileOpen = false;
bool fOutputFileOpen = false;

float free_space_required;
__int64 CurrentPos, TotalSize;
__int64 CurrentDriveFreeSpaceSize;

//処理する合計サイズ
AllTotalSize = 0;

int ret;	//バッファ出力の返値
int FileIndex = 0;

//Blowfish
CBlowFish *bf;

char token[17] = {0, };
const String PrefixString      = "Fn_";
const char charTokenString[17] = "_AttacheCaseData";         //復号の正否に使う
String AtcFileTokenString;                                   //暗号化ファイルのトークン（文字列）
String AtcFileCreateDateString;                              //暗号化ファイルの生成日時（文字列）

//同名ファイル/フォルダーはすべて上書きして復号する
//（ユーザーがダイアログで「すべてはい」を選択したとき = true ）
fOverwirteYesToAll = false;
//「復号したファイルを関連付けされたソフトで開く」一時的な設定
fTempOpenFile = fOpenFile;
//フォルダーを一度開いたか（深いフォルダーすべてを開かないように）
fOpenFolderOnce = false;

// 出力するディレクトリ
OutDirPath = IncludeTrailingPathDelimiter(OutDirPath);

String TempRelativePath;


// 暗号化部分のヘッダサイズ
int EncryptHeaderSize = 0;

int DataVersion;        // ver.2.00～は "5", ver.2.70～は "6"

int flush, status;      // zlib
z_stream z;             // zlibライブラリとやりとりするための構造体
bool fInputEnd = false; // 入力ストリームの終了

//ヘッダデータから必要情報を取り出すための
TMemoryStream *pms;     // メモリストリーム

int idx;
TStringList *DataList;
TStringList *tsv;

TStringList *FileList = new TStringList();  // 0: ファイル名
__int64 *FileSizeList = 0;                  // 1: ファイルサイズ（フォルダは-1）
int *FileAttrList     = 0;                  // 2: 属性
int *FileAgeList      = 0;                  // 3: タイムスタンプ

int rest;
int buf_size;

//----------------------------------------------------------------------
// 平文のヘッダ内容チェック
try {
	fsIn = new TFileStream(AtcFilePath, fmOpenRead | fmShareDenyNone);
}
catch(...) {
	//'復号するファイルを開けません。他のアプリケーションが使用中の可能性があります。'
	MsgText = LoadResourceString(&Msgdecrypt::_MSG_ERROR_FILE_OPEN);
	MsgType = mtError;
	MsgButtons = TMsgDlgButtons() << mbOK;
	MsgDefaultButton = mbOK;
	Synchronize(&PostConfirmMessageForm);
	goto LabelError;
}

fInputFileOpen = true;
//.........这里部分代码省略.........

//.........这里部分代码省略.........
//-----------------------------------
//'暗号化しています...'
ProgressStatusText = LoadResourceString(&Msgencrypt::_LABEL_STATUS_TITLE_ENCRYPTING);
ProgressMsgText = ExtractFileName(OutFilePath);

TotalSize = 0;

try{
	fsOut = new TFileStream(OutFilePath, fmCreate);
	fOpenOut = true;
}
catch(...){
	//'保存する先のファイルが開けません。他のアプリケーションが使用中の可能性があります。'
	MsgText = LoadResourceString(&Msgencrypt::_MSG_ERROR_OUT_FILE_OPEN) + "\n" + OutFilePath;
	MsgType = mtError;
	MsgButtons = TMsgDlgButtons() << mbOK;
	MsgDefaultButton = mbOK;
	Synchronize(&PostConfirmMessageForm);
	delete pms;
	goto LabelError;
}

//-----------------------------------
// 実行可能形式の出力
//-----------------------------------
if ( fExeOutputOption == true ){

	//-----------------------------------
	// 自分のお尻から実行データを抽出
	//-----------------------------------

	//自分自身の実行ファイルを開く
	try{
		fsExe = new TFileStream(Application->ExeName, fmOpenRead | fmShareDenyWrite);
	}
	catch(...){
		//'実行可能形式出力に失敗しました。暗号化処理を中止します。'
		MsgText = LoadResourceString(&Msgencrypt::_MSG_ERROR_EXEOUT_FAILED);
		MsgType = mtError;
		MsgButtons = TMsgDlgButtons() << mbOK;
		MsgDefaultButton = mbOK;
		Synchronize(&PostConfirmMessageForm);
		delete pms;
		goto LabelError;
	}

	//切り出すサイズを取得
	fsExe->Seek(-(__int64)sizeof(__int64), TSeekOrigin::soEnd);
	fsExe->Read(&ExeAllSize, sizeof(__int64));

	//処理する合計サイズに実行形式分を加える
	AllTotalSize += ExeAllSize;

	//自己実行可能形式データの境界へ
	fsExe->Seek(-(__int64)ExeAllSize-sizeof(__int64), TSeekOrigin::soEnd);

	while(fsExe->Read(read_buffer, BUF_SIZE) != 0 ){
		ExeSize+=BUF_SIZE;
		//書き込む
		if ( ExeSize < ExeAllSize ){
			fsOut->Write(read_buffer, BUF_SIZE);
			TotalSize += BUF_SIZE;
		}
		else{
			fsOut->Write(read_buffer, ExeSize-ExeAllSize);
			TotalSize += (ExeSize-ExeAllSize);

//===========================================================================
//スレッド実行
//===========================================================================
void __fastcall TAttacheCaseFileDecrypt2::Execute()
{

int i, c, len;
float ProgressPercentNumF;  //進捗パーセンテージ（浮動小数点）

// バッファ
char source_buffer[BUF_SIZE];
char temp_buffer[BUF_SIZE];
char chain_buffer[BUF_SIZE];
char output_buffer[LARGE_BUF_SIZE];
char *headerbuffer;

//パスワード
bool fPasswordOk;
//const int KeyArrayNum = sizeof(key)/sizeof(key[0]);

String FilePath, FileName;

// ファイルストリーム
TFileStream *fsIn;
TFileStream *fsOut;

bool fInputFileOpen = false;
bool fOutputFileOpen = false;

float free_space_required;
__int64 CurrentPos, TotalSize;
__int64 CurrentDriveFreeSpaceSize;

//処理する合計サイズ
AllTotalSize = 0;

int ret;	//バッファ出力の返値
int FileIndex = 0;

char token[17] = {0, };
const char charTokenString[17] = "_AttacheCaseData";         //復号の正否に使う
const char charBrokenToken[17] = "_Atc_Broken_Data";         //ファイルが破壊されていることを示すトークン
String AtcFileTokenString;                                   //暗号化ファイルのトークン（文字列）
String AtcFileCreateDateString;                              //暗号化ファイルの生成日時（文字列）

//「復号したファイルを関連付けされたソフトで開く」一時的な設定
fTempOpenFile = fOpenFile;
//フォルダーを一度開いたか（深いフォルダーすべてを開かないように）
fOpenFolderOnce = false;

// 出力するディレクトリ
OutDirPath = IncludeTrailingPathDelimiter(OutDirPath);

String TempRelativePath;


// 平文ヘッダサイズ（データサブバージョン、破壊設定など）
int PlainHeaderSize = 0;
// 暗号化部分のヘッダサイズ
int EncryptHeaderSize = 0;

int DataVersion;        // ver.2.00～は "5", ver.2.70～は "6"
int AlgorismType;

char reserved;          // 0
//int TypeLimits;       // ミスタイプ回数 0～10  （グローバル:public宣言とした）
//bool fDestroy;        // 破壊するか否か 0 or 1 （グローバル:public宣言とした）

String PrefixString;	  //ファイルリストの接頭辞（Fn_*, U_*）

int flush, status;      // zlib
z_stream z;             // zlibライブラリとやりとりするための構造体
bool fInputEnd = false; // 入力ストリームの終了

//ヘッダデータから必要情報を取り出すための
TMemoryStream *pms;     // メモリストリーム

int idx;
TStringList *DataList;
TStringList *tsv;

TStringList *FileList = new TStringList();  // 0: ファイル名
__int64 *FileSizeList = 0;               // 1: ファイルサイズ（フォルダは-1）
int *FileAttrList     = 0;               // 2: 属性
int *FileDtChangeList = 0;               // 3: 更新日
int *FileTmChangeList = 0;               // 4: 更新時
int *FileDtCreateList = 0;               // 5: 作成日
int *FileTmCreateList = 0;               // 6: 作成時

int rest;
int buf_size;

//----------------------------------------------------------------------
// 平文のヘッダ内容チェック

try {
	fsIn = new TFileStream(AtcFilePath, fmOpenRead | fmShareDenyNone);
}
catch(...) {
	//'復号するファイルを開けません。他のアプリケーションが使用中の可能性があります。'
//.........这里部分代码省略.........

//---------------------------------------------------------------------------
//暗号化ファイルを破壊する
//---------------------------------------------------------------------------
bool __fastcall TForm1::DestroyAtcFile(void)
{

int i;
int fh;

String MsgText;

char buffer[BUF_SIZE];

for ( i = 0; i < BUF_SIZE; i++ ){
	buffer[i]=NULL;
}

TFileStream *fsIn;

char token[16];
const char charTokenString[16] = "_AttacheCaseData";         //復号の正否に使う
const char charDestroyTokenString[16] = "_Atc_Broken_Data";  //破壊されているとき
String AtcFileTokenString;                                   //暗号化ファイルのトークン（文字列）
String AtcFileCreateDateString;                              //暗号化ファイルの生成日時（文字列）

__int64 AllTotalSize;
int PlaneHeaderSize;
int HeaderBufSize;

try {
	fsIn = new TFileStream(Application->ExeName, fmShareDenyNone);
}
catch(...) {
	//'ファイルを開けません。他のアプリケーションで使用中の可能性があります。'
	MsgText = LoadResourceString(&Msgexeout::_MSG_FILE_OPEN_ERROR);
	ShowConfirmMassageForm(MsgText, mtError, TMsgDlgButtons()<<mbOK, mbOK);
	return(false);
}

//総サイズ取得
AllTotalSize = fsIn->Seek((__int64)0, TSeekOrigin::soEnd);
fsIn->Seek((__int64)0, TSeekOrigin::soBeginning);

//-----------------------------------
//ヘッダ情報のチェック
//-----------------------------------

// サイズを取得
fsIn->Seek(-(__int64)sizeof(__int64), TSeekOrigin::soEnd);
fsIn->Read(&AllTotalSize, sizeof(__int64));
// 位置を戻す
fsIn->Seek(-(AllTotalSize + sizeof(__int64)), TSeekOrigin::soEnd);
// 平文ヘッダサイズを読み込む
fsIn->Read(&PlaneHeaderSize, sizeof(int));
// トークンを取得
fsIn->Read(token, 16);

// トークンを再チェック
if (memcmp(token, charTokenString, 16) != 0 ) {
	//すでに壊れている？　サイレントに処理終了
	delete fsIn;
	return(true);
}
else{
	fsIn->Seek((__int64)-16, TSeekOrigin::soCurrent);
	//"_Atc_Broken_Data"を書き込む
	fsIn->Write(charDestroyTokenString, 16);
}

//「データバージョン」「アルゴリズムの種類」分だけ進める
fsIn->Seek((__int64)(sizeof(int)*2), TSeekOrigin::soCurrent);
//暗号部ヘッダサイズを取得する
fsIn->Read(&HeaderBufSize, sizeof(int));
//暗号部ヘッダのIVを書き換えて破壊する
fsIn->Write(buffer, BUF_SIZE);
//「暗号部ヘッダサイズ」分だけ進める
fsIn->Seek((__int64)(HeaderBufSize-BUF_SIZE), TSeekOrigin::soCurrent);

// IV部分を書き換えて破壊する
fsIn->Write(buffer, BUF_SIZE);

delete fsIn;

return(true);


}

bool TMainForm::PerformCtlFileTransfer(void)
{
   PCHAR buf;
   TFileStream *fStream;
   bool success;

   LONG bufLen;
   String tmp;

   fStream = new TFileStream(FileSpec,fmOpenRead | fmShareDenyWrite);

   if (fStream) {
     LONG fSize = fStream->Size;

     FX2Device->ControlEndPt->TimeOut = 25000;
     FX2Device->ControlEndPt->Index = 0;

     if (fSize <= MAX_CTLXFER_SIZE) {   // Small file

       FX2Device->ControlEndPt->Value = 0;  // The destination address

       buf = new UCHAR[fSize];
       fStream->Read(buf, fSize);
       success = FX2Device->ControlEndPt->Write(buf, fSize);

       if (!success)
         Application->MessageBox("File transfer failed.","Write to Device");

       delete[] buf;

     } else {                           // Big file
       LONG bufLen;

       buf = new UCHAR[MAX_CTLXFER_SIZE];

       success = true;
       do {
         FX2Device->ControlEndPt->Value = fStream->Position;  // Dest address

         bufLen = fSize - fStream->Position;
         if (bufLen > MAX_CTLXFER_SIZE) bufLen = MAX_CTLXFER_SIZE;

         fStream->Read(buf, bufLen);
         success &= FX2Device->ControlEndPt->Write(buf, bufLen);

       } while (success && (fStream->Position < fSize));

       if (!success)
         Application->MessageBox("File transfer failed.","Write to Device");

       delete[] buf;

     } // if (fSize <= 4096)

     FX2Device->ControlEndPt->TimeOut = 5000;
     delete fStream;

   } else // if (fStream)
     Application->MessageBox("Could not read from file.", "File Xfer Error");


   return success;

}

//---------------------------------------------------------------------------
//загрузка проекта из файла, действия аналогичные, что и в сохранении, только
//в обратном порядке(парсим JSON объект и заполняем пустой проект)
Project & ProjectManager::loadProject(UnicodeString fileName)
{
    TFileStream *fs = new TFileStream(fileName, fmOpenRead);
	try {
		int n = fs->Size;
		char *chars = new char[n+1];

		fs->Read(chars, n);
		chars[n] = '\0';
		UnicodeString str(chars);

		TJSONObject *js = (TJSONObject*) TJSONObject::ParseJSONValue(str);

		closeProject();
		currentProject = new Project();

		TJSONArray *criteriaNamesJSON = (TJSONArray*) js->Get(L"criteriaNames")->JsonValue;
		vector<UnicodeString> &criteriaNames= getCurrentProject().getCriteriaNames();
		for (int i = 0; i < criteriaNamesJSON->Size(); ++i) {
			criteriaNames.push_back(criteriaNamesJSON->Get(i)->Value());
		}

		TJSONArray *alternativeNamesJSON = (TJSONArray*) js->Get(L"alternativeNames")->JsonValue;
		vector<UnicodeString> &alternativeNames = getCurrentProject().getAlternativeNames();
		for (int i = 0; i < alternativeNamesJSON->Size(); ++i) {
			alternativeNames.push_back(alternativeNamesJSON->Get(i)->Value());
		}

		TJSONObject *crteriaEstimatesJSON = (TJSONObject*) js->Get(L"criteriaEstimates")->JsonValue;
		TJSONArray *crteriaEstimatesArray = (TJSONArray*) crteriaEstimatesJSON->Get(L"priorities")->JsonValue;
		Estimates &criteriaEstimates = currentProject->getCriteriaEstimates();
		vector<double> &priorities = criteriaEstimates.getPriorities();
		for (int i = 0; i < crteriaEstimatesArray->Size(); ++i) {
			priorities.push_back(StrToFloat(crteriaEstimatesArray->Get(i)->Value()));
		}

		TJSONArray *crteriaRatesTable = (TJSONArray*) crteriaEstimatesJSON->Get(L"rates")->JsonValue;
		vector< vector<int> > &rates = criteriaEstimates.getRates();
		for (int i = 0; i < crteriaRatesTable->Size(); ++i) {
			vector<int> v;
			TJSONArray *crteriaRatesRow = (TJSONArray*) crteriaRatesTable->Get(i);

			for (int j = 0; j < crteriaRatesRow->Size(); ++j) {
				v.push_back(StrToInt(crteriaRatesRow->Get(j)->Value()));
			}

			rates.push_back(v);
		}

		TJSONArray *alternativeEstimatesJSON = (TJSONArray*) js->Get(L"alternativeEstimates")->JsonValue;
		vector<Estimates> &alternativeEstimates = getCurrentProject().getAlternativeEstimates();
		for (int i = 0; i < alternativeEstimatesJSON->Size(); ++i) {
			TJSONObject *alternativeJSON = (TJSONObject*) alternativeEstimatesJSON->Get(i);
			alternativeEstimates.push_back(Estimates());

			TJSONArray *prioritiesJSON = (TJSONArray*) alternativeJSON->Get(L"priorities")->JsonValue;
			vector<double> &priorities = alternativeEstimates[i].getPriorities();
			for (int j = 0; j < prioritiesJSON->Size(); ++j) {
				UnicodeString str = prioritiesJSON->Get(j)->Value();
				priorities.push_back(StrToFloat(str));
			}

			TJSONArray *alternativeRatesTable = (TJSONArray*) alternativeJSON->Get(L"rates")->JsonValue;
			vector< vector<int> > &rates = alternativeEstimates[i].getRates();
			for (int j = 0; j < alternativeRatesTable->Size(); ++j) {
				vector<int> v;
				TJSONArray *alternativeRatesRow = (TJSONArray*) alternativeRatesTable->Get(j);

				for (int k = 0; k < alternativeRatesRow->Size(); ++k) {
					v.push_back(StrToInt(alternativeRatesRow->Get(k)->Value()));
				}

				rates.push_back(v);
			}
		}

		getCurrentProject().setName(js->Get(L"projectName")->JsonValue->Value());
		getCurrentProject().setMethod(StrToInt(js->Get(L"method")->JsonValue->Value()));

		delete [] chars;
		js->Free();

		setIsProjectOpen(true);
		setIsCurrentProjectSaved(true);
		return getCurrentProject();
	} __finally {
		fs->Free();
	}

	return getCurrentProject();
}