NSString from bool array

A bool is not a character. If something isn't a character, then it can't be turned into an NSString simply by putting it into NSData first. All you'll get is misinterpreted binary data.

You have to convert the binary data to a character representation first.

I suggest analyzing a simpler version of the problem:

Code:

bool simple[ 5 ];

That's right, a bool array containing only 5 values.

What is the sizeof(simple)? Using the %x format specifier for NSLog, what are the values displayed? After seeing the values, are those binary values representable in a NSString? Is the NSString data containing those binary values transmittable by whatever mechanism you plan to use to transmit it?

Personally, if I had to choose a simple character representation for booleans, it would be '0' for 0/NO, and '1' for 1/YES. The simplest reason is because those are characters, whereas the bool binary values themselves are not. Or you could use any other two distinct characters, such as the pair 'N'/'Y' or '-'/'+'.

 

Your logic is flawed: you can't store arbitrary sequences of bits as UTF-8. The UTF-8 encoding has specific rules that must be followed. Certain byte sequences are allowed, and are meaningful. Other byte sequences are forbidden, because they are meaningless. You should read up on UTF-8, such as its Wikipedia article.

Your strategy is also flawed: premature optimization. If you want minimal size, and the booleans are sparsely asserted, you might do better with a compression scheme such as Run-Length Encoding. In any case, that's all still premature optimization.

The first problem to solve is how to encode and decode single-bit representations of bool.
In short, how to pack and unpack bits into bytes.


So given a simple array of 8 bools, how do you think you'd pack them into the 8 low bits of a byte. Assume for now that you're packing them into the low bits of an int. Once you get 8 bits packed into an int, you can store that into a char, or append a char to an NSMutableData.

The basic mechanism for accessing bits is shifting and masking.
The shift operators in C (hence, Objective-C) are << and >>.
The bitwise masking operators are & and | (AND and OR).

Once you have code written, tested, and working for 8 bits, expand it to work with 20 bits. That means you'll have to deal with multiple 8-bit bytes of output. You'll also have to deal with the fact that 20 is not an exact multiple of 8. So you'll have to figure out something for padding the last bits.

 

NSLog the wallData in your original code. Or NSLog sizeof(wall) as %d.

You're right: it's not complex at all.

Any compression other than bits-into-bytes does add complexity, but save that for later. There are any number of libraries (such as gzip) that could be used to compress a sequence of bytes.

The problem is you don't see how to convert a bool into a single bit. Or given a single bit, such as 1 or 0 in the LSB of an int, you don't see how to shift the new bit into place in a byte.

Here's a function to return a single LSB 1 or 0 depending on the bool value:

Code:

int bitForBool( bool b )
{  return ( b ? 1 : 0 );  }

It's simple enough it really doesn't even need to be a function.

Here's the code to shift up an existing int, and combine with the LSB from another int:

Code:

int bits;
int newBit = bitForBool( yourBoolArray[ someArrayIndex ] );
bits = ( bits << 1 ) | (newBit & 1);

Obviously, the accumulation of bits should be in a loop, and you should write the total of 8 bits after accumulating a byte.

I will leave the unpacking (decoding) of the bits as an exercise.

If you don't understand the code, it suggests you should study the bit-oriented operations.


If you'd asked about storing a series of integers, I would have asked what format.

Same question applies here for the bits.

You haven't identified how you're transmitting the 8-bits-per-byte. If it's over an HTTP POST or some other protocol that might restrict the characters, or might somehow mangle them in transit, then you need to choose a representation that won't be mangled. For example BASE64 (look it up on Wikipedia).

If you're just transmitting plain bytes, then there is no purpose in converting the NSData into NSString. The NSData holding the bits packed into bytes already holds exactly the sequence of bytes to transmit.

If you're having to encode the plain bytes, then you have to pick an encoding that's reversible. This may be dictated by whatever protocol or transport method you're using.