nsys-color-utils 0.1.1

Color utilities
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//! Color primitives

use derive_more::{From, TryInto};
use crate::constants::*;

#[derive(Clone, Copy, Debug, Eq, PartialEq, From, TryInto)]
pub enum Color {
  Named (Named),
  Raw   ([u8; 4])
}

impl_newtype!{
  Named { Monochrome, Hue }
}
impl_newtype!{
  Terminal { Monochrome, Primary, Secondary }
}
impl_newtype!{
  Hue { Primary, Secondary, Tertiary }
}

impl_primitive!{
  Monochrome {
    Black => BLACK,
    White => WHITE,
    Grey  => GREY
  }
}
impl_primitive!{
  Primary {
    Red   => RED,
    Green => GREEN,
    Blue  => BLUE
  }
}
impl_primitive!{
  Secondary {
    Cyan    => CYAN,
    Yellow  => YELLOW,
    Magenta => MAGENTA
  }
}
impl_primitive!{
  Tertiary {
    Azure      => AZURE,
    Viridian   => VIRIDIAN,
    Chartreuse => CHARTREUSE,
    Orange     => ORANGE,
    Rose       => ROSE,
    Violet     => VIOLET
  }
}

impl Color {
  pub const BLACK   : Self =
    Color::Named (Named::Monochrome (Monochrome::Black));
  pub const WHITE   : Self =
    Color::Named (Named::Monochrome (Monochrome::White));
  pub const GREY    : Self =
    Color::Named (Named::Monochrome (Monochrome::Grey));
  pub const RED     : Self =
    Color::Named (Named::Hue (Hue::Primary (Primary::Red)));
  pub const GREEN   : Self =
    Color::Named (Named::Hue (Hue::Primary (Primary::Green)));
  pub const BLUE    : Self =
    Color::Named (Named::Hue (Hue::Primary (Primary::Blue)));
  pub const CYAN    : Self =
    Color::Named (Named::Hue (Hue::Secondary (Secondary::Cyan)));
  pub const MAGENTA : Self =
    Color::Named (Named::Hue (Hue::Secondary (Secondary::Magenta)));
  pub const YELLOW  : Self =
    Color::Named (Named::Hue (Hue::Secondary (Secondary::Yellow)));

  pub fn raw (&self) -> [u8; 4] {
    match self {
      Color::Named (named) => (*named).into(),
      Color::Raw   (raw)   => *raw
    }
  }

  pub const fn named (&self) -> Option <Named> {
    match self {
      Color::Named (named) => Some (*named),
      Color::Raw   (_)     => None
    }
  }
}

macro impl_primitive {
  ( $primitive:ident {
      $($color:ident => $value:ident),+
    }
  ) => {
    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
    pub enum $primitive {
      $($color),+
    }
    impl From <$primitive> for [u8; 4] {
      fn from (primitive : $primitive) -> [u8; 4] {
        match primitive {
          $($primitive::$color => $value),+
        }
      }
    }
  }
}

macro impl_newtype {
  ( $newtype:ident {
      $($colors:ident),+
    }
  ) => {
    #[derive(Clone, Copy, Debug, Eq, PartialEq, From, TryInto)]
    pub enum $newtype {
      $($colors ($colors)),+
    }
    impl From <$newtype> for [u8; 4] {
      fn from (newtype : $newtype) -> [u8; 4] {
        match newtype {
          $($newtype::$colors (colors) => colors.into()),+
        }
      }
    }
  }
}