// 色を表現する構造体 RGB
#[derive(Copy,Clone,PartialEq)]
struct RGB{
  r:i32,g:i32,b:i32
}
impl RGB{
  fn New(R:i32,G:i32,B:i32)->RGB{return RGB{r:R,g:G,b:B};}
}

//////////////////////////////////////////////////

// 色を表現する構造体 HSV
#[derive(Copy,Clone,PartialEq)]
struct HSV{
  h:f32,s:f32,v:f32
}
impl HSV{
  fn New(H:f32,S:f32,V:f32)->HSV{return HSV{h:H,s:S,v:V};}
}

//////////////////////////////////////////////////

// 画像のピクセルを入れる型
// RGBの任意の値、HSVの任意の値　に加え、定数Invalid　のどれかを入れることができる
// Invalid(i32) と書き直すと少し理解がし易いが、入るのはInvalid一つだけなので意味的には違う
// 　　　　　　　（概念的にはInvalidがたまたまi32にキャストできるだけで、i32を入れられるわけではないので）
#[derive(Copy,Clone,PartialEq)]
enum PixelInfo{
  ColorRGB(RGB),    // RGBを入れる場合 RGB型の変数ColorRGB
  ColorHSV(HSV),    // HSVを入れる場合 HSV型の変数ColorHSV
  Invalid,          // 定数を定義  RGBが無効のときはこれを入れておく事
}

//////////////////////////////////////////////////

fn main() {

  let mut pixel:PixelInfo;

  // ピクセルを使うかどうかを決める
  let unuse:bool = false;

  if unuse {
    // 使わないときはInvalidを入れておく
    pixel = PixelInfo::Invalid;
  }
  else{
    // 色を指定
    pixel = 
      PixelInfo::ColorRGB(
        RGB::New(
          255,
          0,
          0,
        )
      );

  }



  if pixel == PixelInfo::Invalid{
    // ピクセルが無効なら対応した処理を行う
    println!("the pixel is invalid");
  }
  else if let PixelInfo::ColorHSV(c) = pixel{
    // ピクセルが有効ならパターンマッチでcを定義して色を取得
    println!("color HSV = ({} {} {})",c.h,c.s,c.v);
  }
  else if let PixelInfo::ColorRGB(c) = pixel{
    // ピクセルが有効ならパターンマッチでcを定義して色を取得
    println!("color RGB = ({} {} {})",c.r,c.g,c.b);
  }

}

#include <iostream>

struct RGB {int r, g, b;};
struct HSV {float h,s,v; };

union PixelInfo {
  RGB rgb;
  HSV hsv;

  // この定数も取れるようにする
  enum {
    INVALID,
  }Invalid;
};

int main()
{
  PixelInfo pi;

  pi.rgb = { 255, 255, 255 }; // 他の物を入れると無効になる

  pi.Invalid = PixelInfo::INVALID;

  std::cout << pi.Invalid;
}

// Rust の enum は、C言語のenumのように特定の値を持つ定数のみを取れる型を定義するように使用できる。
// ただし、指定できるのは整数のみで、f32やstring等は不可
enum AsciiCode{
  AsciiA = 65,
  AsciiB = 66,
  AsciiC = 67,
}


fn main() {

  // cu を定義。入れられるのはAsciiA,B,Cのいずれかのみ
  let mut cu:AsciiCode = AsciiCode::AsciiA;

  cu = AsciiCode::AsciiB;

  // この場合もパターンマッチで比較する
  if let AsciiCode::AsciiA=cu{
    println!("AsciiA is used." );
  }
  else{
    println!("Not A." );    
  }

  // 数値を取り出すときは as をつける
  println!("cu is {}",cu as i32);

}

// 変数同士を比較するときは、==を使うためにPartialEqを指定
#[derive(PartialEq)]
enum AsciiCode{
  AsciiA = 65,
  AsciiB = 66,
  AsciiC = 67,
}


fn main() {

  // cu を定義。入れられるのはAsciiA,B,Cのいずれかのみ
  let cu:AsciiCode = AsciiCode::AsciiA;

  let rs:AsciiCode=AsciiCode::AsciiB;

  // == で比較できる
  if rs == cu{
    println!("same");
  }
  else{
    println!("not same");
  }

}

// 型も値も指定しないバリアントを持てる。
// ==を使うためにPartialEqを指定
// as i32をするとmoveされてしまうのでCopyも指定。CopyのためにCloneも指定。
#[derive(Copy,Clone,PartialEq)]
enum AsciiCode{
  AsciiA,
  AsciiB,
  AsciiC,
}


fn main() {


  println!("A as int {}",AsciiCode::AsciiA as i32);
  println!("B as int {}",AsciiCode::AsciiB as i32);
  println!("C as int {}",AsciiCode::AsciiC as i32);

  // cu,rs を定義。入れられるのはAsciiA,B,Cのいずれかのみ
  let cu:AsciiCode = AsciiCode::AsciiA;
  let rs:AsciiCode = AsciiCode::AsciiB;

  // == で比較した例
  if rs == cu{
    println!("same");
  }
  else{
    println!("not same {} vs {}",cu as i32,rs as i32);
  }

}