Month: January 2025

use std::{fs::File, io::ErrorKind};

fn main(){
    let f = File::open("secret.pem");
    let f = match f {
        Ok(_) => (),
        Err(ref error) if error.kind() == ErrorKind::NotFound => println!("Not found"),
        Err(error) => {
            panic!("There was a problem opening the file: {:?}", error);
        } 
    };
    println!("OK");
}

何もしない場合は、Ok(_) => () と書いた。

まず、txtファイルに書き込まれているデータがあります。

hoge.txt

{"Name":"Apple","Id":1,"ItemIdList":[1000,1001],"RotData":{"Pitch":0.0,"Roll":0.0,"Yaw":32.0}}
{"Name":"Apple","Id":1,"ItemIdList":[1000,1001],"RotData":{"Pitch":0.0,"Roll":0.0,"Yaw":32.0}}

上記の最終行を読み込んで、その中のデータの一つから処理を行いたい。

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct Rotator {
    Pitch:f32,
    Roll:f32,
    Yaw:f32,
}

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct CharaParam {
    Name: String,
    Id: i32,
    ItemIdList: Vec<u32>,
    RotData: Rotator,
}

fn main(){

    let f = File::open("hoge.txt").unwrap();
    let reader = BufReader::new(f);
    let lines = reader.lines();

    let input_fn = lines.last().unwrap_or(Ok("".to_string())).unwrap();
    let param:CharaParam = serde_json::from_str(&input_fn).unwrap();

    println!("{:?}", param.Name);
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.24s
Running `target/debug/sample`
“Apple”

おおおおおおおお、やりたいことは出来ているっぽい。ここが出来ると、あらゆることが可能になる！

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct Rotator {
    Pitch:f32,
    Roll:f32,
    Yaw:f32,
}

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct CharaParam {
    Name: String,
    Id: i32,
    ItemIdList: Vec<u32>,
    RotData: Rotator,
}

fn main() -> std::io::Result<()>{

    let mut param =  CharaParam{Name:String::from("Apple"), Id:0x01, ItemIdList:vec![1000, 1001], RotData:Rotator{Pitch:0.0, Roll:0.0, Yaw:32.0} };
 
    let serialized: Vec<u8> = serde_json::to_vec(&param).unwrap();
    let mut fileRef = OpenOptions::new()
                        .append(true)
                        .open("hoge.txt")
                        .expect("Unable to open file");

    fileRef.write_all(&serialized).expect("write failed");
    fileRef.write_all(b"\n").expect("write failed");
    Ok(())
}

hoge.txt

{"Name":"Apple","Id":1,"ItemIdList":[1000,1001],"RotData":{"Pitch":0.0,"Roll":0.0,"Yaw":32.0}}
{"Name":"Apple","Id":1,"ItemIdList":[1000,1001],"RotData":{"Pitch":0.0,"Roll":0.0,"Yaw":32.0}}

書き込みはなんかこれでOKっぽいけど、問題は読み込みやな。

use serde::{Serialize, Deserialize};
use std::fs::File;
use std::io::prelude::*;

fn main() -> std::io::Result<()>{
    let mut file = File::open("foo.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    println!("{}", contents);
    assert_eq!(contents, "hello, world!");
    Ok(())
}

$ cargo run
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.49s
Running `target/debug/sample`
bytes bytes bytes 8bytes
asdfghjkl
1234567890
thread ‘main’ panicked at src/main.rs:11:5:
assertion `left == right` failed
left: “bytes bytes bytes 8bytes\nasdfghjkl\n1234567890”
right: “hello, world!”
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

これも同じ

fn main() -> std::io::Result<()>{
    let file = File::open("foo.txt")?;
    let mut buf_reader = BufReader::new(file);
    let mut contents = String::new();
    buf_reader.read_to_string(&mut contents)?;
    println!("{}", contents);
    assert_eq!(contents, "hello, world!");
    Ok(())
}

### 1行ずつ読み取る

use std::fs::File;
use std::io::{BufReader, BufRead, Error};

fn main() -> Result<(), Error>{
    let path = "foo.txt";
    let input = File::open(path)?;
    let buffered = BufReader::new(input);

    for line in buffered.lines() {
        println!("{}", line?);
    }

    Ok(())
}

### ファイルの書き込み

fn main() -> std::io::Result<()>{
    let mut buffer = File::create("hoge.txt")?;

    buffer.write_all(b"some bytes\n hogehoge")?;
    Ok(())
}

### 最終行に書き込み

use std::fs::OpenOptions;
use std::io::Write;

fn main() -> std::io::Result<()>{
    let mut fileRef = OpenOptions::new()
                        .append(true)
                        .open("hoge.txt")
                        .expect("Unable to open file");

    fileRef.write_all(b"last line\n").expect("write failed");
    Ok(())
}

改行コードを入れないと、同じ列になってしまう。
さて、Structでやりたい。

jsonデータを読み込んで、書き換え

use serde::{Serialize, Deserialize};
use std::fs;
use std::fs::File;
use std::io::prelude::*;

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct Rotator {
    Pitch:f32,
    Roll:f32,
    Yaw:f32,
}

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct CharaParam {
    Name: String,
    Id: i32,
    ItemIdList: Vec<u32>,
    RotData: Rotator,
}

fn main(){

    let input_fn = fs::read_to_string("test_input.json")
        .expect("JSON Read Failed.");
    
    let mut param_list: Vec<CharaParam> = serde_json::from_str(&input_fn).unwrap();

    let chara00 = CharaParam{Name:String::from("Apple"), Id:0x01, ItemIdList:vec![1000, 1001], RotData:Rotator{Pitch:0.0, Roll:0.0, Yaw:32.0} };
    let chara01 = CharaParam{Name:String::from("Banana"), Id:0x02, ItemIdList:vec![1002, 1003], RotData:Rotator{Pitch:0.0, Roll:-70.0, Yaw:66.0}};

    param_list.push(chara00);
    param_list.push(chara01);

    let output_fn = String::from("test_output.json");
    let result = output_json(&output_fn, param_list);
    match result {
        Ok(..) => { println!("Json output finished.【{}】", output_fn) }
        Err(err) => { println!("Error: {}", err)}
    }

}

fn output_json(output_fn: &str, charaparam_list: Vec<CharaParam>) -> std::io::Result<()>{

    let serialized: String = serde_json::to_string(&charaparam_list).unwrap();

    let mut file = File::create(output_fn)?;
    file.write_all(serialized.as_bytes())?;
    Ok(())
}

[{“Name”:”Kiwi”,”Id”:3,”ItemIdList”:[2000,2001],”RotData”:{“Pitch”:0.0,”Roll”:0.0,”Yaw”:0.0}},{“Name”:”Orange”,”Id”:4,”ItemIdList”:[2002,2003],”RotData”:{“Pitch”:1.0,”Roll”:50.2,”Yaw”:66.5}},{“Name”:”Apple”,”Id”:1,”ItemIdList”:[1000,1001],”RotData”:{“Pitch”:0.0,”Roll”:0.0,”Yaw”:32.0}},{“Name”:”Banana”,”Id”:2,”ItemIdList”:[1002,1003],”RotData”:{“Pitch”:0.0,”Roll”:-70.0,”Yaw”:66.0}}]

書き込みは出来ていますが、処理量が増えてくると処理が冗長になるように思います。

文字列の繰り返しは repeat()　を使用する

fn main() {
    let mut difficulty = 4;
    let str: String = "0".to_string();
    let target = str.repeat(difficulty);
    println!("{}", target);
}

$ cargo run
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.29s
Running `target/debug/crypt`
0000

リファクタリングする。

fn main() {
    let now = time::Instant::now();
    let previous_hash = "b9b9ee9ffc95fa4956b63b6043a99d0a8f04e0e52e687fc1958d3c6dff885f01";
    let mut num = rand::thread_rng().gen_range(0..1000000);
    let mut hash_num = format!("{}{}", previous_hash, num.to_string());
    let mut header = Sha256::digest(hash_num);
    let mut target: String  = (&hex::encode(header)[..4]).to_string();
    
    let mut cnt = 1;
    println!("count: {} {:x}", cnt, header);

    let mut difficulty = 4;
    let str: String = "0".to_string();
    let difficulty_str = str.repeat(difficulty);

    while target != difficulty_str {
        println!("count: {} {:x}", cnt, header);
        num = rand::thread_rng().gen_range(0..1000000);
        hash_num = format!("{}{}", previous_hash, num.to_string());
        header = Sha256::digest(hash_num);
        target = (&hex::encode(header)[..4]).to_string();
        cnt += 1;
    }
    println!("count: {} {:x}", cnt, header);
    println!("{:?}", now.elapsed());
}

$ cargo run
…
count: 60678 0000b49915dc1fbb5fc8660d285674dbbe9e8d06f31fc5040b6044b4fb3da86a
2.082390487s

問題ありません。なるほどね。これで、difficultyの値を自動調整できるようになりました。

### Jsonの読み込み

use serde::{Serialize, Deserialize};
use std::fs;
use std::io::prelude::*;

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct Rotator {
    Pitch:f32,
    Roll:f32,
    Yaw:f32,
}

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct CharaParam {
    Name: String,
    Id: i32,
    ItemIdList: Vec<u32>,
    RotData: Rotator,
}

fn main(){
    let input_fn = fs::read_to_string("test_input.json")
        .expect("JSON Read Failed.");
    let deserialized: Vec<CharaParam> = serde_json::from_str(&input_fn).unwrap();

    for data in &deserialized {
        println!("{:?}", data);
    }
}

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.67s
Running `target/debug/sample`
CharaParam { Name: “Kiwi”, Id: 3, ItemIdList: [2000, 2001], RotData: Rotator { Pitch: 0.0, Roll: 0.0, Yaw: 0.0 } }
CharaParam { Name: “Orange”, Id: 4, ItemIdList: [2002, 2003], RotData: Rotator { Pitch: 1.0, Roll: 50.2, Yaw: 66.5 } }

### Jsonの書き込み

use serde::{Serialize, Deserialize};
use std::fs::File;
use std::io::prelude::*;

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct Rotator {
    Pitch:f32,
    Roll:f32,
    Yaw:f32,
}

#[derive(Serialize, Deserialize, Debug)]
#[allow(non_snake_case)]
struct CharaParam {
    Name: String,
    Id: i32,
    ItemIdList: Vec<u32>,
    RotData: Rotator,
}

fn main(){
    let chara00 = CharaParam{Name:String::from("Apple"), Id:0x01, ItemIdList:vec![1000, 1001], RotData:Rotator{Pitch:0.0, Roll:0.0, Yaw:32.0} };
    let chara01 = CharaParam{Name:String::from("Banana"), Id:0x02, ItemIdList:vec![1002, 1003], RotData:Rotator{Pitch:0.0, Roll:-70.0, Yaw:66.0}};

    let mut param_list:Vec<CharaParam> = Vec::new();
    param_list.push(chara00);
    param_list.push(chara01);

    let output_fn = String::from("test_output.json");
    let result = output_json(&output_fn, param_list);
    match result {
        Ok(..) => { println!("Json output finished.【{}】", output_fn) }
        Err(err) => { println!("Error: {}", err)}
    }

}

fn output_json(output_fn: &str, charaparam_list: Vec<CharaParam>) -> std::io::Result<()>{

    let serialized: String = serde_json::to_string(&charaparam_list).unwrap();

    let mut file = File::create(output_fn)?;
    file.write_all(serialized.as_bytes())?;
    Ok(())
}

読み込み、書き込みはわかったが、書き込み時に、最終行にappendとしたい。。果たして出来るんか？？
単純にjsonファイルを読み取って、vectorにデータを追加してjsonファイルに保存で良い？