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

// Copyright (c) 2013-2015 Sandstorm Development Group, Inc. and contributors
// Licensed under the MIT License:
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

//! UTF-8 encoded text.

use std::{convert, str, ops, ptr};

use {Error, Result};

#[derive(Copy, Clone)]
pub struct Owned(());

impl<'a> ::traits::Owned<'a> for Owned {
    type Reader = Reader<'a>;
    type Builder = Builder<'a>;
}

pub type Reader<'a> = &'a str;

pub fn new_reader<'a>(v : &'a [u8]) -> Result<Reader<'a>> {
    match str::from_utf8(v) {
        Ok(v) => Ok(v),
        Err(e) => Err(Error::failed(
            format!("Text contains non-utf8 data: {:?}", e))),
    }
}

impl <'a> ::traits::FromPointerReader<'a> for Reader<'a> {
    fn get_from_pointer(reader : &::private::layout::PointerReader<'a>) -> Result<Reader<'a>> {
        reader.get_text(ptr::null(), 0)
    }
}

pub struct Builder<'a> {
    bytes: &'a mut [u8],
    pos: usize,
}

impl <'a> Builder <'a> {
    pub fn new<'b>(bytes: &'b mut [u8], pos: u32) -> Result<Builder<'b>> {
        if pos != 0 {
            match str::from_utf8(bytes) {
                Err(e) => return Err(Error::failed(
                    format!("Text contains non-utf8 data: {:?}", e))),
                _ => {}
            }
        }
        Ok(Builder { bytes: bytes, pos: pos as usize })
    }

    pub fn push_ascii(&mut self, ascii: u8) {
        assert!(ascii < 128);
        self.bytes[self.pos] = ascii;
        self.pos += 1;
    }

    pub fn push_str(&mut self, string: &str) {
        let bytes = string.as_bytes();
        for ii in 0..bytes.len() {
            self.bytes[self.pos + ii] = bytes[ii];
        }
        self.pos += bytes.len();
    }

    pub fn clear(&mut self) {
        for ii in 0..self.pos {
            self.bytes[ii] = 0;
        }
        self.pos = 0;
    }
}

impl <'a> ops::Deref for Builder <'a> {
    type Target = str;
    fn deref<'b>(&'b self) -> &'b str {
        str::from_utf8(self.bytes)
            .expect("text::Builder contents are checked for utf8-validity upon construction")
    }
}

impl <'a> convert::AsRef<str> for Builder<'a> {
    fn as_ref<'b>(&'b self) -> &'b str {
        str::from_utf8(self.bytes)
            .expect("text::Builder contents are checked for utf8-validity upon construction")
    }
}

impl <'a> ::traits::FromPointerBuilder<'a> for Builder<'a> {
    fn init_pointer(builder: ::private::layout::PointerBuilder<'a>, size: u32) -> Builder<'a> {
        builder.init_text(size)
    }
    fn get_from_pointer(builder: ::private::layout::PointerBuilder<'a>) -> Result<Builder<'a>> {
        builder.get_text(::std::ptr::null(), 0)
    }
}

impl <'a> ::traits::SetPointerBuilder<Builder<'a>> for Reader<'a> {
    fn set_pointer_builder<'b>(pointer: ::private::layout::PointerBuilder<'b>, value: Reader<'a>)
                               -> Result<()>
    {
        pointer.set_text(value);
        Ok(())
    }
}