repos/Represent/Represent.cpp

// Represent
//
// Douglas Thrift
//
// $Id$

#include <iostream>
#include <string>
#include <vector>

#include <foreach.hpp>

class Binary
{
private:
        std::vector<char> bytes;
public:
        Binary(std::string& string, bool signed_ = false);
        template <typename Type>
        Binary(const Type& type);
        template <typename Type>
        Type convert(bool signed_ = false);
        operator std::string() const;
};

Binary::Binary(std::string& string, bool signed_) : bytes(string.size() / 8, 0)
{
        std::string::size_type off(string.size() % 8);

        if (off != 0)
        {
                bytes.push_back(0);
                string.insert(0, 8 - off, signed_ && string[0] == '1' ? '1' : '0');
        }

        std::string::size_type index(0);

        _rmforeach (std::vector<char>, byte, bytes)
        {
                _rfor (char, bit, 0, 8)
                {
                        *byte |= (string[index++] == '1') << bit;
                }
        }
}

template <typename Type>
Binary::Binary(const Type& type) : bytes(sizeof (type))
{
        char* type_(reinterpret_cast<char*>(const_cast<Type*>(&type)));

        _mforeach (std::vector<char>, byte, bytes) *byte = *type_++;
}

template <typename Type>
Type Binary::convert(bool signed_)
{
        Type type;

        if (sizeof (type) != bytes.size()) bytes.resize(sizeof (type), signed_ && bytes.back() >> 7 ? ~0 : 0);

        char* type_(reinterpret_cast<char*>(&type));

        _foreach (std::vector<char>, byte, bytes) *type_++ = *byte;

        return type;
}

Binary::operator std::string() const
{
        std::string string;

        _rforeach (std::vector<char>, byte, bytes) _rfor (char, bit, 0, 8) string +=1 & *byte >> bit ? '1' : '0';

        return string;
}

inline std::ostream& operator<<(std::ostream& out, const Binary& binary)
{
        return out << std::string(binary);
}

int main(int argc, char* argv[])
{
        std::string hello("Hello, World!");

        _foreach (std::string, atom, hello)
        {
                std::cout << Binary(*atom) << " = " << *atom << std::endl;
        }

        _fori (index, -10, 11)
        {
                std::cout << Binary(index) << " = " << index << std::endl;
        }

        _foru (index, -10, 11)
        {
                std::cout << Binary(index) << " = " << index << std::endl;
        }

        for (float index(-1.0); index < 1.0; index += 0.1)
        {
                std::cout << Binary(index) << " = " << index << std::endl;
        }

        for (double index(-1.0); index < 1.0; index += 0.1)
        {
                std::cout << Binary(index) << " = " << index << std::endl;
        }

        std::string string("101001101001");
        Binary binary(string, true);

        std::cout << binary << " = " << string << std::endl;

        float value(binary.convert<float>());

        std::cout << binary << " = " << value << std::endl << Binary(value) << " = " << value << std::endl;

        return 0;
}
Revision:	365
Committed:	2004-12-21T03:21:00-08:00 (20 years, 6 months ago) by douglas
Original Path:	*Represent/represent.cpp*
File size:	2507 byte(s)
Log Message:	Moof!
#	User	Rev	Content
1	douglas	362	// Represent
2			//
3			// Douglas Thrift
4			//
5			// $Id$
6
7			#include <iostream>
8			#include <string>
9			#include <vector>
10
11			#include <foreach.hpp>
12
13			class Binary
14			{
15			private:
16			std::vector<char> bytes;
17			public:
18	douglas	365	Binary(std::string& string, bool signed_ = false);
19	douglas	362	template <typename Type>
20			Binary(const Type& type);
21	douglas	365	template <typename Type>
22			Type convert(bool signed_ = false);
23	douglas	362	operator std::string() const;
24			};
25
26	douglas	365	Binary::Binary(std::string& string, bool signed_) : bytes(string.size() / 8, 0)
27	douglas	362	{
28	douglas	365	std::string::size_type off(string.size() % 8);
29
30			if (off != 0)
31			{
32			bytes.push_back(0);
33			string.insert(0, 8 - off, signed_ && string[0] == '1' ? '1' : '0');
34			}
35
36			std::string::size_type index(0);
37
38			_rmforeach (std::vector<char>, byte, bytes)
39			{
40			_rfor (char, bit, 0, 8)
41			{
42			*byte \|= (string[index++] == '1') << bit;
43			}
44			}
45	douglas	362	}
46
47			template <typename Type>
48			Binary::Binary(const Type& type) : bytes(sizeof (type))
49			{
50			char* type_(reinterpret_cast<char>(const_cast<Type>(&type)));
51
52			_mforeach (std::vector<char>, byte, bytes) byte = type_++;
53			}
54
55	douglas	365	template <typename Type>
56			Type Binary::convert(bool signed_)
57			{
58			Type type;
59
60			if (sizeof (type) != bytes.size()) bytes.resize(sizeof (type), signed_ && bytes.back() >> 7 ? ~0 : 0);
61
62			char* type_(reinterpret_cast<char*>(&type));
63
64			_foreach (std::vector<char>, byte, bytes) type_++ = byte;
65
66			return type;
67			}
68
69	douglas	362	Binary::operator std::string() const
70			{
71			std::string string;
72
73	douglas	365	_rforeach (std::vector<char>, byte, bytes) _rfor (char, bit, 0, 8) string +=1 & *byte >> bit ? '1' : '0';
74	douglas	362
75			return string;
76			}
77
78	douglas	365	inline std::ostream& operator<<(std::ostream& out, const Binary& binary)
79	douglas	362	{
80			return out << std::string(binary);
81			}
82
83			int main(int argc, char* argv[])
84			{
85			std::string hello("Hello, World!");
86
87			_foreach (std::string, atom, hello)
88			{
89			std::cout << Binary(atom) << " = " << atom << std::endl;
90			}
91
92			_fori (index, -10, 11)
93			{
94			std::cout << Binary(index) << " = " << index << std::endl;
95			}
96
97	douglas	365	_foru (index, -10, 11)
98	douglas	362	{
99			std::cout << Binary(index) << " = " << index << std::endl;
100			}
101
102			for (float index(-1.0); index < 1.0; index += 0.1)
103			{
104			std::cout << Binary(index) << " = " << index << std::endl;
105			}
106
107			for (double index(-1.0); index < 1.0; index += 0.1)
108			{
109			std::cout << Binary(index) << " = " << index << std::endl;
110			}
111
112	douglas	365	std::string string("101001101001");
113			Binary binary(string, true);
114
115			std::cout << binary << " = " << string << std::endl;
116
117			float value(binary.convert<float>());
118
119			std::cout << binary << " = " << value << std::endl << Binary(value) << " = " << value << std::endl;
120
121	douglas	362	return 0;
122			}