#include <sstream>
#include <string>


//
//Template function to convert any numerical type 
//into a stl string.
//
template<typename To, typename From> 
std::wstring string_cast(From value) 
{
	std::wostringstream os;
	os << value;
	return os.str();
}

//
//Template function to convert any string that contains 
//a numerical value into its intrinsic value.
//
template<typename To> 
T lexical_cast(const std::wstring& str) 
{
	std::wistringstream is(str);
	T value;
	is >> value;
	return value;
}


int main()
{

    //
    //Start off with any numerical value as a string
    //
    std::wstring srcStringFloat = L"23.45";
    
    //
    //Cast it into the destination type.
    //
    float destFloatValue = 0.0f;
    destFloatValue = lexical_cast<float>(srcStringFloat);
   
    //
    // Now go the other way.
    //
     
    //
    // Start off with any numerical value.
    //
    float srcFloat = -0.00004F;
    
    //
    //Cast the value into a string.
    //
    std::wstring dstStringValue;
    dstStringValue = string_cast<std::wstring>(srcFloat);
    
    return 0;
}

#include <strstream>
#include <string>

int main()
{
    //
    //Initial string.
    //
    std::string str("-s er -d ss -t a s");
	
    //
    //String to hold each token.
    //
    std::string value;
    std::istringstream  token(str);

    //
    //Run through the string breaking at every space
    //
    while(std::getline(token, value, ' '))
    {
        std::cout << value << std::endl;
    }
}

#include "wchar.h"
#include "stdarg.h"

namespace std
{

static int __cdecl getFormatedLength( const wchar_t* format, va_list args ) throw()
{
	return _vscwprintf( format, args );
}

static int __cdecl formatV( wchar_t* pszBuffer, const wchar_t* pszFormat, va_list args ) throw()
{
	return vswprintf( pszBuffer, pszFormat, args );
}

class format
{
	std::wstring m_formatted;
public:

	format(const wchar_t* format, ...)
	{
		va_list argList;
		va_start( argList, format );

		int length = getFormatedLength(format, argList);
		wchar_t* tempString = (wchar_t*)_alloca( length * sizeof(wchar_t) +1);
		
		formatV( tempString, format, argList );

		va_end( argList );

		tempString[length] = 0;
		m_formatted = tempString;

	}
 
        //
        //We must return a copy of the formatted string.
        //
	operator const std::wstring () const
	{
		return m_formatted;
	}

};


};

//Usage Example
std::wstring theFormatStr = std::format(L"%S now %d", __FUNCTION__, __LINE__);

class ErrHelper
{
public:

	static std::wstring getString(HRESULT hr)
	{
		WCHAR* wszError;

	    //Check if it is a window's error
		if(HRESULT_FACILITY(hr) == FACILITY_WINDOWS)
		{
			//translate the code.
			hr = HRESULT_CODE(hr);
		}
		
		::FormatMessageW( FORMAT_MESSAGE_ALLOCATE_BUFFER | 
						FORMAT_MESSAGE_FROM_SYSTEM, 
						NULL, 
						hr, 
						MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), 
						(LPWSTR)&wszError, 0, NULL);

		std::wstring wstr = L"Unknown Error";
		if (wszError) 
			wstr = wszError;
		LocalFree(wszError);
		return wstr;
	}
};

//Usage 
//ErrHelper::getString(hr).data();


template < typename T >
class Seal
{
Seal(){}
friend typename T;
};


// Usage:
// Derive your sealed class from Seal
// In the following manner:
// class YourClass : virtual private Seal YourClass
// This will prevent anyone from deriving from your class.

Example:


class Cat : virtual private Seal < Cat >
{	
public:
	Cat(){}	
};

class CopyCat // : public Cat  
{
public:	// This is what happens when the class heiarchy is uncommented.
    CopyCat(){}  // error C2248: 'Seal < T > ::Seal' : cannot  access private member declared in class 'Seal < T >'

};

In this tutorial we will attempt to use NOP to create a more useful string class. In the first tutorial I tried to extract out the structural component of the String class. We ended up with a data structure that acts like a string literal, only it cleans itself up when it destroyed.

Let's add some more functionality to this class. Suppose we want to add concatenation to our string. The standard way of doing this in OOP would be to add a methods or operator to the class so that anybody using the class has this functionality. So let us think about this for a second. Should the concatenation function be part of the String class? OOP tells us it is so, because after all isn't the string class more knowing of it data than anything else? I would say this is true, however if I were measure the amount of information needed by the concatenation algorithm about the string class, vs the amount of information needed by the string class about concatenation.... The greater knowledge might be needed by the concatenation.

So, the OOP people were right all along. However, since I am a NOP person, I have to prove the OOP people wrong. Or at least I want to provide you with another point of view. So, lets say I want to add search functionality to our String class. Let's use the same argument as before, about whether our String class needs to know more about searching, or our algorithm needs to know more about the String class. Again a close call. But if we look at the big picture, now NOP makes a little more sense. Our String class now has to know about concatenation and searching, and any other functionality we want to add to it. So, that's enough to convince me that there must be a way to nip this thing in the butt. NOP preaches (mostly me) that we should separate behavior from structure. Since concatenation is behavior, let's make it separate.

As always our first step is to figure out the namespace and the location of the code. Since our Domain is the “String”, lets put everything related to strings in the same namespace. I like to call this "Namespace Encapsulation"

namespace String_01
{

};

We want to be able to use our string class like the following:

1. strTest1 = “String”;

2. strTest1 += “One”;

and also:

3. Str strTest2 = strTest + “Two”;

4. Str strTest3 = strTest1 + strTest2;

Line 1, was taken care of in the first tutorial.
Line 2, we need the following function

Str += “literal”

or in C++

Str& operator+=(Str& lhs, const wchar_t* rhs)

Line 3, we need the following function.
String = String + “literal”
or in C++

Str operator+(const Str& lhs, const wchar_t* rhs)

and
String = String + String

Str operator+(const Str& lhs, const Str& rhs)

So our concatenation behavior would now look like the following:

namespace String_01
{
	Str& operator+=(Str& lhs, const wchar_t* rhs);
	Str operator+(const Str& lhs, const wchar_t* rhs);
	Str operator+(const Str& lhs, const Str& rhs);
};

The implementation:

//since it was aliased from String_01 (see tutorial #1)
using namespace String; 

Str& operator+=(Str& lhs, const wchar_t* rhs)
{
	size_t appendLen = length(rhs);
	size_t len = lhs.len + appendLen + 1;
	wchar_t* str = new wchar_t[len];
	::memcpy(str, (const wchar_t*)(lhs), lhs.len * sizeof(wchar_t));
	::memcpy(&str[lhs.len], rhs, (appendLen + 1) * sizeof(wchar_t));
	lhs = str;
	delete [] str;
	return lhs;
}

Str operator+(const Str& lhs, const wchar_t* rhs)
{
	Str final = lhs;
	final += rhs;
	return final;
}


Str operator+(const Str& lhs, const Str& rhs)
{
	Str final = lhs;
	final += rhs;
	return final;
}

Conclusion
So that's it. Without recompiling our Structural component, we added some behaviors that will operate on our string class like it was part of it. Also, the person using the string class in his project may not need the functionality, that we just added. Another advantage, is the fact that our original string class remains small and comprehensible. This gives us two very important advantages: The algoritm can be changed or modified without effecting the the Src class, and the Str class can be changed without modifying the algorithm (which we will do later).

What are the disadvantages of doing it this way? I can only think of a couple. One disadvantage is that we now have disjoint code, our behavior is seperated from our structural (very procedural). However the behaviors are still encapsulated by the namespace. Also it appears that the behaviors seem to know a lot about the internals of our Str class. I knew this from the start, and like I said earlier, it could probably go either way.

Next Tutorial:
Adding Search Capabilities

Will add this soon.....

1. If you have any application specific questions.
2. Or theoretical questions related to NOP.