byte.h

Go to the documentation of this file.

// -*- Socket Streams -*-

// Copyright (C) 2005 Pedro Lamarão <pedro.lamarao@mndfck.org>

// This file is part of the Socket Streams Library.  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; see the file COPYING. If not, write to the Free
// Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
// USA

#include <string>

namespace ss {

        class byte {
        public:

                byte () : value(0) {}

                byte (byte const& that) : value(that.value) {}

                byte (int i) : value(static_cast<unsigned char>(i)) {}

                byte
                operator= (byte const& that) {
                        value = that.value;
                        return *this;
                }

                bool
                operator== (byte const& that) const {
                        return value == that.value;
                }

                bool
                operator< (byte const& that) const {
                        return value < that.value;
                }

                operator unsigned int() const {
                        return static_cast<unsigned int>(value);
                }

        private:
                unsigned char value;
        };

}

namespace std {

        template <>
        struct char_traits<ss::byte> {

                typedef ss::byte char_type;

                typedef unsigned int int_type;

                typedef streampos pos_type;
                typedef streamoff off_type;
                typedef mbstate_t state_type;

                static void
                assign (char_type& c1, char_type const& c2) {
                        c1 = c2;
                }

                static bool
                eq (char_type const& c1, char_type const& c2) {
                        return c1 == c2;
                }

                static bool
                lt (char_type const& c1, char_type const& c2) {
                        return c1 < c2;
                }

                static int
                compare (char_type const* s1, char_type const* s2, size_t n) {
                        for (size_t i = 0; i < n; ++i)
                                if (!eq(s1[i], s2[i]))
                                        return lt(s1[i], s2[i]) ? -1 : 1;
                        return 0;
                }

                static size_t
                length (char_type const* s) {
                        char_type const* p = s;
                        while (*p) ++p;
                        return (p - s);
                }

                static char_type const*
                find (char_type const* s, size_t n, char_type const& c) {
                        for (char_type const* p = s; size_t(p - s) < n; ++p)
                                if (*p == c)
                                        return p;
                        return 0;
                }

                static char_type*
                move (char_type* s1, char_type const* s2, size_t n) {
                        return reinterpret_cast<char_type*>(
                                memmove(s1, s2, n * sizeof(char_type))
                        );
                }

                static char_type*
                copy (char_type* s1, char_type const* s2, size_t n) {
                        return reinterpret_cast<char_type*>(
                                memcpy(s1, s2, n * sizeof(char_type))
                        );
                }

                static char_type*
                assign (char_type* s, size_t n, char_type const& c) {
                        for  (char_type* p = s; p < s + n; ++p)
                                assign(*p, c);
                        return s;
                }

                static char_type
                to_char_type (int_type const& c) { return char_type(c); }

                static int_type
                to_int_type (char_type const& c) { return int_type(c); }

                static bool
                eq_int_type (int_type const& c1, int_type const& c2) {
                        return c1 == c2;
                }

                static int_type
                eof () { return static_cast<int_type>(-1); }

                static int_type
                not_eof (int_type const& c) {
                        return eq_int_type(c, eof()) ? int_type(0) : c;
                }

        };

}

---