grust 0.3.2

GObjectIntrospection bindings for Rust. This is the core library providing basic functionality to all generated crates.
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

// This file is part of Grust, GObject introspection bindings for Rust
//
// Copyright (C) 2015  Mikhail Zabaluev <mikhail.zabaluev@gmail.com>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

use gtype::GType;
use types::guint;

use std::error::Error as ErrorTrait;
use std::fmt;

pub trait IntrospectedFlags : Sized {
    fn from_uint(v: guint) -> Result<Self, UnknownFlags>;
    fn to_uint(&self) -> guint;
}

pub trait FlagsType : IntrospectedFlags {
    fn get_type() -> GType;
}

#[derive(Copy, Clone)]
pub struct UnknownFlags {
    actual: guint,
    known_mask: guint
}

impl UnknownFlags {
    pub fn new(flags: guint, known_mask: guint) -> UnknownFlags {
        UnknownFlags { actual: flags, known_mask: known_mask }
    }

    pub fn actual(&self) -> guint { self.actual }
    pub fn unknown(&self) -> guint { self.actual & !self.known_mask }
    pub fn known(&self) -> guint { self.actual & self.known_mask }
}

pub mod prelude {
    pub use super::{IntrospectedFlags, FlagsType, UnknownFlags};
    pub use gtype::GType;
    pub use types::guint;
}

impl ErrorTrait for UnknownFlags {
    fn description(&self) -> &str {
        "unknown bit flags encountered"
    }
}

impl fmt::Display for UnknownFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "unsupported bit flag value 0b{:b} (unknown flags: 0b{:b})",
               self.actual(), self.unknown())
    }
}

impl fmt::Debug for UnknownFlags {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "UnknownFlags {{ actual: 0b{:b}, known_mask: 0b{:b} }}",
               self.actual, self.known_mask)
    }
}

pub fn from_uint<F>(v: guint) -> Result<F, UnknownFlags>
    where F: IntrospectedFlags
{
    IntrospectedFlags::from_uint(v)
}

pub fn type_of<F>() -> GType where F: FlagsType {
    <F as FlagsType>::get_type()
}