repos/Represent/Binary.cpp

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

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

#include <foreach.hpp>

/*template <typename Type>
std::string binary(const Type& type)
{
        std::ostringstream string;

        _rforu (index, 0, 8 * sizeof (type))
        {
                bool bit(1 & type >> index);

                string << bit;
        }

        return string.str();
}*/

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

Binary::Binary(const std::string& string)
{
        throw;
}

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_++;
}

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;
}

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;
        }

        return 0;
}
Revision:	362
Committed:	2004-12-21T01:12:18-08:00 (20 years, 6 months ago) by douglas
Original Path:	*Represent/represent.cpp*
File size:	1725 byte(s)
Log Message:	There!
#	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			/*template <typename Type>
14			std::string binary(const Type& type)
15			{
16			std::ostringstream string;
17
18			_rforu (index, 0, 8 * sizeof (type))
19			{
20			bool bit(1 & type >> index);
21
22			string << bit;
23			}
24
25			return string.str();
26			}*/
27
28			class Binary
29			{
30			private:
31			std::vector<char> bytes;
32			public:
33			Binary(const std::string& string);
34			template <typename Type>
35			Binary(const Type& type);
36			operator std::string() const;
37			};
38
39			Binary::Binary(const std::string& string)
40			{
41			throw;
42			}
43
44			template <typename Type>
45			Binary::Binary(const Type& type) : bytes(sizeof (type))
46			{
47			char* type_(reinterpret_cast<char>(const_cast<Type>(&type)));
48
49			_mforeach (std::vector<char>, byte, bytes) byte = type_++;
50			}
51
52			Binary::operator std::string() const
53			{
54			std::string string;
55
56			_rforeach (std::vector<char>, byte, bytes)
57			{
58			_rfor (char, bit, 0, 8)
59			{
60			string += 1 & *byte >> bit ? '1' : '0';
61			}
62			}
63
64			return string;
65			}
66
67			std::ostream& operator<<(std::ostream& out, const Binary& binary)
68			{
69			return out << std::string(binary);
70			}
71
72			int main(int argc, char* argv[])
73			{
74			std::string hello("Hello, World!");
75
76			_foreach (std::string, atom, hello)
77			{
78			std::cout << Binary(atom) << " = " << atom << std::endl;
79			}
80
81			_fori (index, -10, 11)
82			{
83			std::cout << Binary(index) << " = " << index << std::endl;
84			}
85
86			_foru (index, -10, 11)
87			{
88			std::cout << Binary(index) << " = " << index << std::endl;
89			}
90
91			for (float index(-1.0); index < 1.0; index += 0.1)
92			{
93			std::cout << Binary(index) << " = " << index << std::endl;
94			}
95
96			for (double index(-1.0); index < 1.0; index += 0.1)
97			{
98			std::cout << Binary(index) << " = " << index << std::endl;
99			}
100
101			return 0;
102			}