<?xml version="1.0"?>
<Animation Name="Explosion" FrameDelay="0.025">

	<Frame Index="0">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="0" Y="0" Width="64" Height="64" />
	</Frame>

	<Frame Index="1">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="64" Y="0" Width="64" Height="64" />
	</Frame>

	<Frame Index="2">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="128" Y="0" Width="64" Height="64" />
	</Frame>

	<Frame Index="3">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="192" Y="0" Width="64" Height="64" />
	</Frame>

	<Frame Index="4">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="256" Y="0" Width="64" Height="64" />
	</Frame>
	<Frame Index="5">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="0" Y="64" Width="64" Height="64" />
	</Frame>

	<Frame Index="6">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="64" Y="64" Width="64" Height="64" />
	</Frame>

	<Frame Index="7">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="128" Y="64" Width="64" Height="64" />
	</Frame>

	<Frame Index="8">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="192" Y="64" Width="64" Height="64" />
	</Frame>

	<Frame Index="9">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="256" Y="64" Width="64" Height="64" />
	</Frame>
	<Frame Index="10">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="0" Y="128" Width="64" Height="64" />
	</Frame>

	<Frame Index="11">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="64" Y="128" Width="64" Height="64" />
	</Frame>

	<Frame Index="12">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="128" Y="128" Width="64" Height="64" />
	</Frame>

	<Frame Index="13">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="192" Y="128" Width="64" Height="64" />
	</Frame>

	<Frame Index="14">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="256" Y="128" Width="64" Height="64" />
	</Frame>
	<Frame Index="15">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="0" Y="192" Width="64" Height="64" />
	</Frame>

	<Frame Index="16">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="64" Y="192" Width="64" Height="64" />
	</Frame>

	<Frame Index="17">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="128" Y="192" Width="64" Height="64" />
	</Frame>

	<Frame Index="18">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="192" Y="192" Width="64" Height="64" />
	</Frame>

	<Frame Index="19">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="256" Y="192" Width="64" Height="64" />
	</Frame>

	<Frame Index="20">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="0" Y="256" Width="64" Height="64" />
	</Frame>

	<Frame Index="21">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="64" Y="256" Width="64" Height="64" />
	</Frame>

	<Frame Index="22">
		<Anchor X="32" Y="32" />
		<Texture Path="explosion.png" />
		<SourceRectangle X="128" Y="256" Width="64" Height="64" />
	</Frame>
	
</Animation>

void PrintDebugMessage(const string &Text)
{
	dbeals::Debug::CallStack CallStack = dbeals::Debug::CallStack::Capture();
	
	// We pass in 1 because 0 would be PrintDebugMessage();
	// CallStack is inverse-index based (0 is the last element, n - 1 is the first.)
	std::stringstream Stream;
	Stream<<CallStack[1].FileName;
	Stream<<"("<<CallStack[1].LineNumber<<") ";
	Stream<<"from "<<CallStack[1].SymbolName;
	Stream<<" : "<<Text<<"\n";
	OutputDebugStringA(Stream.str().c_str());
}

using System;

namespace Lab
{
    class Program
    {
        class MyObject
        {
            public string Name;

            public MyObject()
            {
            }

            public override string ToString()
            {
                return String.Format("Name: {0}", this.Name);
            }
        };

        static void Foo(MyObject Obj)
        {
            Obj.Name = "Programmer16";
        }

        static void Foo(string String)
        {
            String = "Programmer16";
        }

        static void Foo(ref string String)
        {
            String = "Programmer16";
        }

        static void Main(string[] args)
        {
            MyObject Obj = new MyObject();
            Foo(Obj); // Name = "Programmer16"
            Console.WriteLine(Obj);

            Obj.Name = ""; // Name = ""
            Foo(Obj.Name); // Name = ""
            Console.WriteLine(Obj);

            Foo(ref Obj.Name); // Name = "Programmer16"    
            Console.WriteLine(Obj);

            Console.In.Read();
        }
    }
}

namespace dbeals
{
    /*
    TagItem is an arbitrary container for storing state-specific, type-specific data as either copies of objects or references to objects.
    To store a copy use either:
        TagItemInstance = ObjectInstance;
    or
        TagItemInstance = *ValidObjectPointer;

    To store a reference use either:
        TagItemInstance = &ObjectInstance;
    or
        TagItemInstance = ValidObjectPointer;

    Do NOT store references to temporary. I'm not sure how defined this is (if at all.) I only tested it with a vector, which resulted in an empty vector after the object went out of scope,
    but I don't think that's reliable behavior.
    */
    struct TagItem
    {
        boost::any Data;

        // Default Constructor
        TagItem()
        {
        }

        // Copy Constructor
        TagItem(const TagItem &Tag) : Data(Tag.Data)
        {
        }

        // Value Constructors
        template <typename ValueType>
        TagItem(const ValueType &Value) : Data(Value)
        {
        }

        template <typename ValueType>
        TagItem(ValueType *Value) : Data(Value)
        {
        }

        // Modifiers
        void Clear()
        {
            this->Data = boost::any();
        }

        void Swap(TagItem &Tag)
        {
            this->Data.swap(Tag.Data);
        }

        // Queries
        bool IsEmpty() const
        {
            return this->Data.empty() == true;
        }

        bool IsNotEmpty() const
        {
            return this->Data.empty() == false;
        }

        // Removed : CanCastTo<>()
        /* I removed this because it just bulks things up. The whole design is to be simple using the form:
        ValueType *Result = 0;
        if((Result = Tag.CastTo<ValueType>()) != 0)
            // Do something here

        This requires only one cast, whereas using CanCastTo<>() would require two casts.
        To use this class in that manner (not for which it was intended, but inherently can be use in such a manner), just use multiple casts:
        ValueType0 *Result0 = 0, ValueType1 *Result1 = 0;
        if((Result0 == Tag.CastTo<ValueType0>()) != 0)
            // It's ValueType0, do something with it.
        else if((Result1 == Tag.CastTo<ValueType1>()) != 0)
            // It's ValueType1, do something with it.

        or
        if(Tag.CastTo<ValueType0>())
        {
            ValueType0 *Result = Tag.CastTo<ValueType0>();
            // do something with it.
        }
        else if(Tag.CastTo<ValueType1>())
        {
            ValueType1 *Result = Tag.CastTo<ValueType1>();
            // do something with it.
        }
        */

        // Accessors
        template <typename ValueType>
        ValueType *CastTo()
        {
            ValueType **Result = boost::any_cast<ValueType *>(&this->Data);
            if(Result)
                return *Result;

            ValueType *Result2 = boost::any_cast<ValueType>(&this->Data);
            if(Result2)
                return Result2;
            return 0;
        }

        template <typename ValueType>
        const ValueType *CastTo() const
        {
            return const_cast<TagItem *>(this)->CastTo<ValueType>();
        }

        // Assignment Operators
        TagItem &operator =(const TagItem &Pointer)
        {
            this->Data = Pointer.Data;
            return *this;
        }

        template <typename ValueType>
        TagItem &operator =(const ValueType &Value)
        {
            this->Data = Value;
            return *this;
        }

        template <typename ValueType>
        TagItem &operator =(ValueType *Value)
        {
            this->Data = Value;
            return *this;
        }
    };
}

//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
namespace dbeals
{
    //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    template <typename EnumerationType>
    struct EnumValue
    {
        EnumerationType Value;

        EnumValue()
        {
        }

        EnumValue(EnumerationType Value)
        {
            this->Value = Value;
        }

        EnumValue(const string &Name, EnumerationType Value)
        {
            this->Value = Value;

            std::pair<std::map<EnumerationType, string>::iterator, bool> Result = EnumValue<EnumerationType>::_container().insert(std::make_pair(Value, Name));
            if(!Result.second)
                throw std::exception((format("The enum value '%1%' has already been registered with the name '%2%'.") % Value % Result.first->second).str().c_str());
        }

        const string &ToString() const
        {
            std::map<EnumerationType, string>::iterator Itor = _container().find(Value);
            if(Itor == _container().end())
            {
                try
                {
                    static string Dummy = "";
                    Dummy = boost::lexical_cast<string>(this->Value);
                    return Dummy;
                }
                catch(boost::bad_lexical_cast)
                {
                    throw std::exception((format("Failed to cast the value '%1%' to a string.") % this->Value).str().c_str());
                }
            }
            return Itor->second;
        }

        static EnumerationType Parse(const string &Text)
        {
            string Copy = String::trim_copy(Text);
            for(std::map<EnumerationType, string>::iterator Itor = _container().begin(); Itor != _container().end(); ++Itor)
            {
                if(String::equals(Copy, Itor->second))
                    return Itor->first;
            }

            throw std::exception((format("The enum-value '%1%' does not exist in this enumeration.") % Text).str().c_str());
        }

        operator EnumerationType() const
        {
            return this->Value;
        }

        const EnumValue &operator =(const EnumValue &Value)
        {
            this->Value = Value.Value;
            return *this;
        }

        const EnumValue &operator =(EnumerationType Value)
        {
            this->Value = Value;
            return *this;
        }

    private:
        static std::map<EnumerationType, string> &_container()
        {
            static std::map<EnumerationType, string> Enum;
            return Enum;
        }
    };

    //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
    template <typename EnumerationType>
    struct FlagValue
    {
        EnumerationType Value;

        FlagValue()
        {
        }

        FlagValue(EnumerationType Value)
        {
            this->Value = Value;
        }

        FlagValue(const string &Name, EnumerationType Value)
        {
            this->Value = Value;

            std::pair<std::map<EnumerationType, string>::iterator, bool> Result = FlagValue<EnumerationType>::_container().insert(std::make_pair(Value, Name));
            if(!Result.second)
                throw std::exception((format("The enum value '%1%' has already been registered with the name '%2%'.") % Value % Result.first->second).str().c_str());
        }

        string ToString() const
        {
            string Output = "";
            for(std::map<EnumerationType, string>::iterator Itor = _container().begin(); Itor != _container().end(); ++Itor)
            {
                if(this->Value & Itor->first)
                {
                    if(!Output.empty())
                        Output += "|";
                    Output += Itor->second;
                }
            }
            return Output;
        }

        static EnumerationType Parse(const string &Text)
        {
            std::vector<string> Tokens;
            String::split(Tokens, Text, compare_with('|'));
            EnumerationType Output = (EnumerationType)0;
            string Copy;
            for(std::vector<string>::iterator StrItor = Tokens.begin(); StrItor != Tokens.end(); ++StrItor)
            {
                for(std::map<EnumerationType, string>::iterator Itor = _container().begin(); Itor != _container().end(); ++Itor)
                {
                    if(String::equals(String::trim(*StrItor), Itor->second))
                        Output |= Itor->first;
                }
            }
            return Output;
        }

        operator EnumerationType() const
        {
            return this->Value;
        }

        FlagValue operator |(const FlagValue &Value) const
        {
            return FlagValue(EnumerationType(this->Value | Value.Value));
        }

        const FlagValue &operator |=(const FlagValue &Value)
        {
            this->Value |= Value.Value;
            return *this;
        }

        FlagValue operator |(EnumerationType Value) const
        {
            return FlagValue(EnumerationType(this->Value | Value));
        }

        const FlagValue &operator |=(EnumerationType Value)
        {
            this->Value |= Value;
            return *this;
        }

        FlagValue operator &(const FlagValue &Value) const
        {
            return FlagValue(EnumerationType(this->Value & Value.Value));
        }

        const FlagValue &operator &=(const FlagValue &Value)
        {
            this->Value &= Value.Value;
            return *this;
        }

        FlagValue operator &(EnumerationType Value) const
        {
            return FlagValue(EnumerationType(this->Value & Value));
        }

        const FlagValue &operator &=(EnumerationType Value)
        {
            this->Value &= Value;
            return *this;
        }

        const FlagValue &operator =(const FlagValue &Value)
        {
            this->Value = Value.Value;
            return *this;
        }

        const FlagValue &operator =(EnumerationType Value)
        {
            this->Value = Value;
            return *this;
        }

    private:
        static std::map<EnumerationType, string> &_container()
        {
            static std::map<EnumerationType, string> Enum;
            return Enum;
        }
    };
}

namespace BuildTypes
{
    enum enum_type { };
    db_EnumValue(enum_type, DebugBuild);
    db_EnumValue(enum_type, ReleaseBuild);
} db_DeclEnumType(BuildTypes::enum_type, BuildType);

int main()
{
    BuildType MyBuildType;
#if defined(_DEBUG) || defined(DEBUG)
    MyBuildType = BuildTypes::DebugBuild;
#else
    MyBuildType = BuildTypes::ReleaseBuild;
#endif
    std::cout<<MyBuildType.ToString()<<std::endl;
    return 0;
}

namespace BuildOptions
{
    enum enum_type { };
    db_FlagValue(enum_type, IncludeComments);
    db_FlagValue(enum_type, IncludeWarnings);
    db_FlagValue(enum_type, IncludeErrors);
} db_DeclFlagType(BuildOptions::enum_type, BuildOption);

int main()
{
    BuildOption Options;
    Options = BuildOptions::IncludeComments | BuildOptions::IncludeErrors;
    
    BuildOptions ParseTest1 = BuildOption::Parse("IncludeComments");
    BuildOptions ParseTest2 = BuildOption::Parse("includeComments"); // Fails; case-sensitive
    BuildOptions ParseTest3 = BuildOption::Parse("IncludeComments | IncludeWarnings|IncludeErrors"); // Works fine; spaces are trimmed
    
    std::cout<<Options.ToString()<<"\n";
    std::cout<<(BuildOptions::IncludeWarnings | BuildOptions::IncludeErrors).ToString()<<std::endl;
    return 0;
}