Some definitions for the following paragraphs:

Text: any text. Can be a complete book, a word, a sentence, etc.

LR<Languages>: Language Recognizer for the languages.

Possible applications of the LR

Advanced Texthelper

Features

Can correct words without a dictionary: recognizes when something probably isn’t a word.

A word of length X has an average score of AVG. If there is a word with length X and its score is lower with significance S, then the word probably isn’t a word in the current language. I don’t know how to determine significance S.

Can correct sentences, since it also recognizes sentence structures.

Basically the same as the word recognition, but for sentences.

Can auto-complete sentences (and parts thereof).

Since the LR keeps tracks of how many times a word follows another word, it should be able to predict what word you are going to type, which could speed up writing a text. As you read, a lot of shoulda coulda woulda, but maybe we are clever enough to pull this off.

Language Recognizer

Features

Can tell if text A is more English than text B

If text A scores higher on LR<English> than B, A is more likely to be english than B.

Test results indicate very few false positives with a simple implementation.

Can help for auto-recognizing if something is human readable text.

If a text gets a higher score than previous texts, the text is more likely to be human readable text, which is useful for the “recovery” of encrypted text.

Language

I’ve been experimenting with some fun stuff lately, it involves language, programming, password-dictionaries, spell checkers, and more .

1. Get a file with a lot of words (i.e. a spell checker dictionary).
2. Count the occurrences of N-letter-groups in those words. (example with N = 3: “hello”, hel++, ell++, llo++)
3. Find high-scoring letter-groups which overlap (ie. “hel” + “ell” = “hell”) to form a word. (Obviously, repeat this to form bigger words)

Using an English dictionary, this gives output such as: “anteringlogratio”, “callinesthesional” and “prestionistering”. Altough those words are absolutely not English words (as far as I know), they look pretty English. Cool huh?

It can obviously also create ‘fake words’ in other languages, by using other dictionaries. For example, using a Dutch dictionary: “verderendelijker”, “heiderdelijkeren” and “eerderingelijkerigen”. (I’m Dutch, and I can tell you those words are easy to read and pronounce, altough they mean nothing to me)

I can hear you thinking: “Nice, but why’d you ever need to create ‘fake words’ ?”.
Well, for example, we could expand a password-dictionary by generating new passwords from the passwords already in there. This gives new passwords wich are likely to be passwords, instead of the 99% of garbage from a simple brute-forcer.

Also, if we can create words that seem to belong to some language, we can probably also recognize if something could be a real word.

We could create a program wich can tell random sequences of letters and real words apart by giving the words an ‘Englishness-score’, the more it uses high-scoring letter-groups, the higher the score. This might come in handy while brute-forcing a password for some text file. The program could detect if it succesfully decrypted the file, or just got some garbage-output. Or we could create a smart spell checker wich can check and correct words even when they’re not in the dictionary. If ‘hello’ has a much higher score than ‘helllo’, the user probably wanted to type ‘hello’. Or a language-recognizer, if all the words have a higher ‘Dutchness-score’ than ‘Englishness-score’, it’s probably not an English text.

When we take this a level higher, not using words and letter-groups, but sentences and word-groups, the awesomeness grows exponentially. A spell checker could simply correct “Ive is fun” to “Ice is fun”, but “Ive been running” to “I’ve been running”. An internet spider could tell real text apart from those random-keywords-pages. Lots of possibilities.

Anyway, I’ll try to code some of this stuff to see how well it all works, stay tuned.

So the parser was working, but it didn’t utilize C++ all the way. I’m trying to reduce the code and thus ease further development and maintainability.

Some hours later…

It is finished! As far as I can tell anyway.  It has a nice example app with it, here’s a (now already dated) sneak peek:

    prettyprint("Welcome to the SSS example app");
cout
<< "This application shows how easy it is to use SSS.\n"
<< "STF is a \"new\" way to store leveled data, just as XML can do, for example.\n"
<< "The format looks like a C(++) struct, which we think is easier to read than XML.\n"
<< "Each :{ is a node, a node has other nodes and values. The first node is unnamed.\n"
<< endl;

So what are you waiting for? Grab the source with example app from the SourceForge page (either checkout from the SVN or select “Browse SVN” -> “Download GNU tarball” (all the way down) ), and use this neat alternative to XML! More information after the break.

Its documentation is made with Doxygen (nice program by the way, never used it until today, and it creates nice documentation) and can be found here(with left explorer style bar) and here(without). With the documentation is the code for review by you, because I’d like some comments where I could improve. About half of it was first written by Maurice Bos of BosByte and then completely reviewed and altered by me. Then I added the other half. I tried to use C++’s features where I could, and I’m quite happy with the results.

So again, comments on the code are welcome! You can view the code in the documentation.

What did you say? How it looks?

Like this:

imthefirst: "The first value!"
name with spaces: "Names can contain spaces"
name
with
newlines: "And even newlines!"

test: {
    blah: "The value of [root].test.blah"
    newlines: "newlines and all their whitespace
             get stored"
    comment: This comment value contains some information about how to comment in SSS files.
    "You can place comment before the quotes, the parser will ignore it."
    output this: "This particular value is retrieved in the code."
    output child:
    Same goes for children. The parser ignores anything until a curly bracket is found. {
        info: "Awwwwwwright! Tree output oh yeah."
        coolness: "+20"
    }
    Array: { :"This" :"is" :"like" :"an" :"array" }

    2D array:
    {
            : { :"First" :"Row" }
            : { :"Second" :"Row" :"!" }
    }
}

But seriously, go check out the SF page, download the STFU and play around with it. It oozes simplicity.

Also, a sneak peek on what I’m currently working on.

DataStore.h

#ifndef __DATASTORE_H__
#define __DATASTORE_H__

// Include files
#include "../dependencies.h"
#include "DataStack.h"

// Forward declarations
class DataStack;

// DataStore class.
class DataStore
{
public:

    // Initialisation and deinitialisation
    DataStore();
    ~DataStore();

    void init();
    void clear();

    // Methods
    bool addDataStack(DataStack *stack);
    DataStack* createDataStack(const std::string &name);

    DataStack* getDataStack(const unsigned int id);
    DataStack* getDataStack(const std::string &name);

    void removeAll();
    bool removeDataStack(DataStack *stack);
    bool removeDataStack(const unsigned int);
    bool removeDataStack(const std::string &name);

private:

    // Normal members
    std::vector<DataStack*> mStacks;

};

#endif

DataStore.cpp

// Include files
#include "DataStore.h"

// DataStore class
// DataStore constructor.
DataStore::DataStore()
{
    init();
}

// DataStore deconstructor.
DataStore::~DataStore()
{
    clear();
}

// Initialises the Data Store.
void DataStore::init()
{
}

// Clears the Data Store.
void DataStore::clear()
{
    removeAll();
}

// Adds the given Data Stack to the Data Store.
bool DataStore::addDataStack(DataStack *stack)
{
    // Did we get a valid pointer?
    if(stack == NULL)
      return false;

    // Does a Data Stack with the same name exist?
    if(getDataStack(stack->getName()))
      return false;

    // Add the Data Stack to the vector.
    mStacks.push_back(stack);

    return true;
}

// Creates a Data Stack with the given name.
DataStack* DataStore::createDataStack(const std::string &name)
{
    // Does a Data Stack with the same name exist?
    if(getDataStack(name))
      return NULL;

    // Create the Data Stack and add it to the vector.
    DataStack *stack = new DataStack(name);
    mStacks.push_back(stack);

    return stack;
}

// Gets the Data Stack with the given id.
DataStack* DataStore::getDataStack(const unsigned int id)
{
    for(unsigned int i = 0; i < mStacks.size(); i++)
    {
       if(mStacks[i]->getID() == id)
         return mStacks[i];
    }

    return NULL;
}

// Gets the Data Stack with the given name.
DataStack* DataStore::getDataStack(const std::string &name)
{
    for(unsigned int i = 0; i < mStacks.size(); i++)
    {
       if(mStacks[i]->getName() == name)
         return mStacks[i];
    }

    return NULL;
}

// Removes all Data Stacks from this Data Store.
void DataStore::removeAll()
{
    // Clear the Data Stacks.
    for(unsigned int i = 0; i < mStacks.size(); i++)
      delete mStacks[i];

    mStacks.clear();
}

// Removes the given Data Stack.
bool DataStore::removeDataStack(DataStack *stack)
{
    // Did we get a valid pointer?
    if(stack == NULL)
      return false;

    // Try to remove the Data Stack.
    vector<DataStack*>::iterator it;

    for(it = mStacks.begin(); it < mStacks.end(); it++)
    {
        DataStack *dstack = *it;

        if(dstack == stack)
        {
           delete dstack;
           mStacks.erase(it);
           return true;
        }
    }

    // We couldn't find the Data Stack and thus couldn't remove it.
    return false;

}

// Removes the given Data Stack with the given id.
bool DataStore::removeDataStack(const unsigned int id)
{
    // Try to remove the Data Stack.
    vector<DataStack*>::iterator it;

    for(it = mStacks.begin(); it < mStacks.end(); it++)
    {
        DataStack *dstack = *it;

        if(dstack->getID() == id)
        {
           delete dstack;
           mStacks.erase(it);
           return true;
        }
    }

    // We couldn't find the Data Stack and thus couldn't remove it.
    return false;
}

// Removes the given Data Stack with the given name.
bool DataStore::removeDataStack(const std::string &name)
{
    // Try to remove the Data Stack.
    vector<DataStack*>::iterator it;

    for(it = mStacks.begin(); it < mStacks.end(); it++)
    {
        DataStack *dstack = *it;

        if(dstack->getName() == name)
        {
           delete dstack;
           mStacks.erase(it);
           return true;
        }
    }

    // We couldn't find the Data Stack and thus couldn't remove it.
    return false;
}

// End of File

DataStack.h

#ifndef __DATASTACK_H__
#define __DATASTACK_H__

// Include files
#include "../dependencies.h"
#include "DataStore.h"

// Forward declarations.
class DataStore;

// DataStack class.
class DataStack
{

    friend class DataStore;

public:

    // Initialisation and deinitialisation
    DataStack(const std::string &name);
    ~DataStack();

    void init();
    void clear();

    // Methods
    unsigned int getID() const;
    const std::string& getName() const;

    unsigned int getSize() const;

    // Sets the variable with the given name.
    template<typename T>
    bool setVar(const std::string &name, const T &value)
    {
        std::stringstream ss;
        ss << value;

        if(ss.good())
        {
           mVars[name] = ss.str();
           return true;
        }

        else return false;
    };

    // Gets the variable with the given name.
    template<typename T>
    T getVar(const std::string &name)
    {
        std::map<std::string, std::string>::iterator it;
        it = mVars.find(name);

        if(it != mVars.end())
        {
           std::stringstream ss(it->second);

           T t;
           ss >> t;
           return t;
        }

        else return NULL;
    };

    void removeAll();
    bool removeVar(const std::string &name);

    //bool save(const std::string &filename); TODO
    //bool load(const std::string &filename); TODO

private:

    // Static members
    static unsigned int mIDCount;

    // Normal members
    unsigned int mID;
    std::string mName;

    std::map<std::string, std::string> mVars;
};

#endif

DataStack.cpp

// Include files.
#include "DataStack.h"

// DataStack class
// Static variables.
unsigned int DataStack::mIDCount = 0;

// DataStack constructor.
DataStack::DataStack(const std::string &name)
: mName(name)
{
    mID = mIDCount++;
}

// DataStack deconstructor.
DataStack::~DataStack()
{
    clear();
}

// Initialises the Data Stack.
void DataStack::init()
{
}

// Clears the Data Stack.
void DataStack::clear()
{
    removeAll();
}

// Gets the ID of the Data Stack.
unsigned int DataStack::getID() const
{
    return mID;
}

// Gets the name of the Data Stack.
const std::string& DataStack::getName() const
{
    return mName;
}

// Gets the number of variables on the Data Stack.
unsigned int DataStack::getSize() const
{
    return mVars.size();
}

// Removes all variables from this Data Stack.
void DataStack::removeAll()
{
    mVars.clear();
}

// Removes the variable with the given name.
bool DataStack::removeVar(const std::string &name)
{
    std::map<std::string, std::string>::iterator it;
    it = mVars.find(name);

    if(it != mVars.end())
    {
       mVars.erase(it);
       return true;
    }

    else return false;
}

// End of File

Remember that all of the above code has been placed in the public domain and that I’ll take no responsibility or liability of any kind for any use that you may make of this code.

Maurice and I were thinking of how to circumvent XML one more time, and Maurice came up with this format:

ideayaybox:{
  author:"nick overdijk"
  author:"maurice bos"
  description:
"blabla
   blabla"
  link:{
      file:       "blah"
      tag: "something"
      tag:"something"
  }
}

So, basically we have 2 types, values and lists (which can be seen as values). Values are between quotation marks, if you want a quotation mark inside a value, you need double quotation marks! A list starts with ‘{‘, and ends with ‘}’.

In the above example, ideayaybox consists of 2 authors, 1 description, and a list of links. Simple enough right?

Simple String Structures, taking over the world!

The idea behind Component Oriented Entities is to make entities data-driven. In order to do this the functionalities are split in various individual components. As a result an entity is in fact nothing more than a collection of components. An added advantage is the ability to describe these components (and thus the entities) in XML or a similar mark-up language.

Yesterday I actually had a discussion with Nick about Component Oriented Entities. Initially he disagreed with me as I had some trouble explaining the “dangers” of the blob anti-pattern (a huge single class with a large amount of complex functionality). Later on, he agreed with me, but he also pointed out some things to keep in mind. One of those things was the implementation. And I really agree with that as these kind of things stand or fall based upon the implementation. Which brings me to my own implementation of Component Oriented Entities. Please note that all of the following code has been placed in the public domain and that I’ll take no responsibility or liability of any kind for any use that you may make of this code.

Lets start with the Entity Manager.

EntityManager.h

#ifndef __ENTITYMANAGER_H__
#define __ENTITYMANAGER_H__

// Include files
#include "../dependencies.h"
#include "Entity.h"

// Forward declarations
class Entity;

// EntityManager class
class EntityManager
{
public:

    // Initialisation and deinitialisation
    EntityManager();
    ~EntityManager();

    void init();
    void clear();

    // Methods
    bool addEntity(Entity *entity);
    Entity* createEntity(const std::string &name);

    Entity* getEntity(const unsigned int id);
    Entity* getEntity(const std::string &name);

    void removeAll();
    bool removeEntity(Entity *entity);
    bool removeEntity(const unsigned int id);
    bool removeEntity(const std::string &name);

private:

    vector<Entity*> mEntities;
};

#endif

EntityManager.cpp

// Include files
#include "EntityManager.h"

// EntityManager class
// EntityManager constructor.
EntityManager::EntityManager()
{
    init();
}

// EntityManager deconstructor.
EntityManager::~EntityManager()
{
    clear();
}

// Initialises the Entity Manager.
void EntityManager::init()
{
}

// Clears the Entity Manager.
void EntityManager::clear()
{
    // Clear entities.
    removeAll();
}

// Adds an entity to the Entity Manager.
bool EntityManager::addEntity(Entity *entity)
{
    // Did we get a valid pointer?
    if(entity == NULL)
      return false;

    // Look if a entity with given name doesn't already exist.
    if(getEntity(entity->getName()))
      return false;

    // Add the entity.
    mEntities.push_back(entity);

    return true;
}

// Creates an entity with the given name and adds it to the Entity Manager.
Entity* EntityManager::createEntity(const std::string &name)
{
    // Look if a entity with given name doesn't already exist.
    if(getEntity(name))
      return NULL;

    // Add the entity.
    Entity *entity = new Entity(name);
    mEntities.push_back(entity);

    return entity;
}

// Gets the entity with the given ID.
Entity* EntityManager::getEntity(const unsigned int id)
{
    for(unsigned int i = 0; i < mEntities.size(); i++)
    {
       if(mEntities[i]->getID() == id)
         return mEntities[i];
    }

    return NULL;
}

// Gets the entity with the given name.
Entity* EntityManager::getEntity(const std::string &name)
{
    for(unsigned int i = 0; i < mEntities.size(); i++)
    {
       if(mEntities[i]->getName() == name)
         return mEntities[i];
    }

    return NULL;
}

// Removes all entities.
void EntityManager::removeAll()
{
    for(unsigned int i = 0; i < mEntities.size(); i++)
      delete mEntities[i];

    mEntities.clear();
}

// Removes the given entity.
bool EntityManager::removeEntity(Entity *entity)
{
    // Did we get a valid pointer?
    if(entity == NULL)
      return false;

    // Try to remove the entity.
    vector<Entity*>::iterator it;

    for(it = mEntities.begin(); it < mEntities.end(); it++)
    {
        Entity *ent = *it;

        if(ent == entity)
        {
           delete ent;
           mEntities.erase(it);
           return true;
        }
    }

    // We couldn't find the entity and thus couldn't remove it.
    return false;
}

// Removes the entity with the given ID.
bool EntityManager::removeEntity(const unsigned int id)
{
    // Try to remove the entity.
    vector<Entity*>::iterator it;

    for(it = mEntities.begin(); it < mEntities.end(); it++)
    {
        Entity *ent = *it;

        if(ent->getID() == id)
        {
           delete ent;
           mEntities.erase(it);
           return true;
        }
    }

    // We couldn't find the entity and thus couldn't remove it.
    return false;
}

// Removes the entity with the given name.
bool EntityManager::removeEntity(const std::string &name)
{
    // Try to remove the entity.
    vector<Entity*>::iterator it;

    for(it = mEntities.begin(); it < mEntities.end(); it++)
    {
        Entity *ent = *it;

        if(ent->getName() == name)
        {
           delete ent;
           mEntities.erase(it);
           return true;
        }
    }

    // We couldn't find the entity and thus couldn't remove it.
    return false;
}

// End of File

The Entity Manager takes care of organizing all entities. Through the Entity Manager it’s possible to create, add, get and remove entities. To this end the Entity Manager offers various methods.

Now lets look at the Entity class.

Entity.h

#ifndef __ENTITY_H__
#define __ENTITY_H__

// Include files
#include "../dependencies.h"
#include "EntityComponent.h"

// Forward declarations
class EntityComponent;

// Entity class
class Entity
{
public:

    // Initialisation and deinitialisation
    Entity(const std::string &name);
    ~Entity();

    void init();
    void clear();

    // Methods
    unsigned int getID() const;
    const std::string& getName() const;

    bool addComponent(EntityComponent* component);

    EntityComponent* getComponent(const unsigned int id);
    EntityComponent* getComponent(const std::string &name);

    void removeAll();
    bool removeComponent(EntityComponent *component);
    bool removeComponent(const unsigned int id);
    bool removeComponent(const std::string &name);

private:

    // Static members
    static unsigned int mIDCount;

    // Normal members
    unsigned int mID;
    std::string mName;

    vector<EntityComponent*> mComponents;
};

#endif

Entity.cpp

// Include files
#include "Entity.h"

// Entity class
// Static variables.
unsigned int Entity::mIDCount = 0;

// Entity constructor.
Entity::Entity(const std::string &name)
: mName(name)
{
    mID = mIDCount++;

    init();
}

// Entity deconstructor.
Entity::~Entity()
{
    clear();
}

// Initialises the entity.
void Entity::init()
{
}

// Clears the entity.
void Entity::clear()
{
    // Remove all components.
    removeAll();
}

// Gets the ID of this entity.
unsigned int Entity::getID() const
{
    return mID;
}

// Gets the name of this entity.
const std::string& Entity::getName() const
{
    return mName;
}

// Adds a component to the entity.
bool Entity::addComponent(EntityComponent *component)
{
    // Did we get a pointer to a component?
    if(component == NULL)
      return false;

    // Check if a component of the given type doesn't already exist.
    if(getComponent(component->getName()))
      return false;

    // Add new component.
    mComponents.push_back(component);

    return true;
}

// Gets the component with the given ID from this entity.
EntityComponent* Entity::getComponent(const unsigned int id)
{
    for(unsigned int i = 0; i < mComponents.size(); i++)
    {
       if(mComponents[i]->getID() == id)
         return mComponents[i];
    }

    return NULL;
}

// Gets the component with the given name from this entity.
EntityComponent* Entity::getComponent(const std::string &name)
{
    for(unsigned int i = 0; i < mComponents.size(); i++)
    {
       if(mComponents[i]->getName() == name)
         return mComponents[i];
    }

    return NULL;
}

// Removes all components.
void Entity::removeAll()
{
    for(unsigned int i = 0; i < mComponents.size(); i++)
       delete mComponents[i];

    mComponents.clear();
}

// Removes the given component.
bool Entity::removeComponent(EntityComponent *component)
{
    // Did we get a valid pointer?
    if(component == NULL)
      return false;

    // Try to remove the entity.
    vector<EntityComponent*>::iterator it;

    for(it = mComponents.begin(); it < mComponents.end(); it++)
    {
        EntityComponent *comp = *it;

        if(comp == component)
        {
           delete comp;
           mComponents.erase(it);
           return true;
        }
    }

    // We couldn't find the entity and thus couldn't remove it.
    return false;
}

// Removes the component with the given ID.
bool Entity::removeComponent(const unsigned int id)
{
    // Try to remove the entity.
    vector<EntityComponent*>::iterator it;

    for(it = mComponents.begin(); it < mComponents.end(); it++)
    {
        EntityComponent *comp = *it;

        if(comp->getID() == id)
        {
           delete comp;
           mComponents.erase(it);
           return true;
        }
    }

    // We couldn't find the entity and thus couldn't remove it.
    return false;
}

// Removes the component with the given name.
bool Entity::removeComponent(const std::string &name)
{
    // Try to remove the entity.
    vector<EntityComponent*>::iterator it;

    for(it = mComponents.begin(); it < mComponents.end(); it++)
    {
        EntityComponent *comp = *it;

        if(comp->getName() == name)
        {
           delete comp;
           mComponents.erase(it);
           return true;
        }
    }

    // We couldn't find the entity and thus couldn't remove it.
    return false;
}

// End of File

As you can see an entity is a collection of an ID, name and a vector of components. That means that an entity is largely defined by its components. These are in my implementation described by the EntityComponent class.

EntityComponent.h

#ifndef __ENTITYCOMPONENT_H__
#define __ENTITYCOMPONENT_H__

// Include files
#include "../dependencies.h"
#include "Entity.h"

// Forward declarations
class Entity;

// EntityComponent class
class EntityComponent
{
public:

    // Initialisation and deinitialisation
    EntityComponent(Entity *parent);
    virtual ~EntityComponent();

    // Methods
    unsigned int getID() const;
    const std::string& getName() const;

    const Entity* getParent();

protected:

    void setName(const std::string &name);

private:

    // Static members
    static unsigned int mIDCount;

    // Normal members
    Entity *pParent;

    unsigned int mID;
    std::string mName;
};

#endif

EntityComponent.cpp

// Include files
#include "EntityComponent.h"

// EntityComponent class
// Static variables.
unsigned int EntityComponent::mIDCount = 0;

// EntityComponent constructor.
EntityComponent::EntityComponent(Entity *parent)
: pParent(parent)
{
    // Get new unique ID.
    mID = mIDCount++;

    // Check if we got a valid pointer.
    if(parent == NULL)
      delete this;

    else parent->addComponent(this);
}

// EntityComponent deconstructor.
EntityComponent::~EntityComponent()
{
}

// Sets the name of the component.
void EntityComponent::setName(const std::string &name)
{
    mName = name;
}

// Gets the ID of the component.
unsigned int EntityComponent::getID() const
{
    return mID;
}

// Gets the name of the component.
const std::string& EntityComponent::getName() const
{
    return mName;
}

// Gets the parent of this component.
const Entity* EntityComponent::getParent()
{
    return pParent;
}

// End of File

And just as the Entity class, the EntityComponent is also fairly simple. You might be wondering, though, how these components communicate with each other and other parts of the framework. The truth is that I’ve build an Event Manager on top of this entity system that takes care of that. Unfortunately that Event Manager depends on a third-party library called Sigslot And I think that such thing is beyond the scope of this post. Partly, also because I’m still tweaking my Event Manager myself and don’t feel comfortable yet showing that.

Fast File Finder – Ideayay Example Usage

User wants to create a local file search program.

User already has worked out a GUI in a file.

User creates idea: “Fast File Finder”
Ideayay creates a folder “Fast File Finder” and sets its status to “Just started”

User creates question: “What GUI?” and links earlier mentioned file to this as answer.
Ideayay asks if that completely answers the question, user says yes, Ideayay marks this question as answered.

User creates the problem: “How to index all files on a PC?”.
Then goes on the internet to look it up and stores some links as attachments to that problem.
Then writes code using the attachments and links that (the sourcecode file) as solution for the problem.
Ideayay asks if that completely solves the problem, user says yes, Ideayay marks this problem solved.

User creates the problem: “How to quickly search through strings?”.
He posts the problem to a forum and links the URL as attachment to the problem.
The solution is found on the forum and he copies the text containing the solution as “Solution” to the problem.
Ideayay creates a file: problemname.answer.txt and metadata.
Ideayay asks if that completely solves the problem, user says yes, Ideayay marks this problem solved.

User links final source files to the idea itself and marks the idea finished.

Where is the horizontal rule when you need it?jaskldfjlkasjflkajsfkljaslkjflajslfjalsjfjaslkfjalksjfsal

That’ll do. The program’s name is. Ideayay. It was the worst name I could think of that’d surely piss off my partner. I was not wrong. Hehe.

We are going FAST with this one. Our SVN server definitely has an headache trying to keep up with the commits and updates and merges.

Less ideas in the mind makes room for more new ideas! Woeii.

You’ll the the software draft up here in a few days.

-Nick

It’s tested with this file:

<window 100 456 789 120 windone SimpleXML>
  <button 101 258 369 123 buttone Ok 1337/>
  <button 102 258 369 123 buttwo Cancel 1338/>
</>

<window 103 456 789 120 windtwo SimpleXML1>
  <window 104 456 789 120 windthree SimpleXML2>
    <button 105 258 369 123 buttwo yes 1339/>
    <button 106 258 369 123 buttwo nay 1340/>
  </>
  <button 106 258 369 123 buttwo nay 1340/>
</>

/*Free to do anything (with this source file) but leave this comment block alone!
  Created by .simplicity's Nick Overdijk (nick@dotsimplicity.net)
*/
#include <iostream>
#include <cstdio>
#include <fstream>
#include <string>
#include <sstream>
#include <vector>
#include <stack>
using namespace std;

/*Load file into memory as string
  create vector of element pointers
  parse the document, create elements on the fly
*/

class element {
public:
    element();

    element(string &amp;amp;amp;amp;type, unsigned int x, unsigned int y, unsigned int height, unsigned int width, element *parent) :
    type(type), x(x), y(y), height(height), width(width), parent(parent) {
    }

    element(string &amp;amp;amp;amp;attributes) :
    attributes(attributes) {
        attributeStream.str(attributes);
        parse();
    }

    virtual ~element(){ cout << "Finishing element" << endl; }

    virtual void printInfo() {
        cout << "---" << type << " @ " << this << "---" << endl;
        cout << "Width: " << width << endl;
        cout << "Height: " << height << endl;
        cout << "x: " << x << endl;
        cout << "y: " << y << endl;
        if(parent != NULL)
        cout << "Parent: " << parent << "(" << parent->type << "::" << parent->name << ")" << endl;
    }

    void printTree() {
        printInfo();
        if (parent != NULL) {
            parent->printTree();
        }
    }

    virtual void parse(){
        attributeStream >> type;
        attributeStream >> x;
        attributeStream >> y;
        attributeStream >> width;
        attributeStream >> height;
    }

    void setParent(element *parent){
        this->parent = parent;
    }

    string name;
    string type;
    string attributes;
    stringstream attributeStream;
    unsigned int x;
    unsigned int y;
    unsigned int height;
    unsigned int width;
    element *parent;
};

class button : public element {
    public:
    button(string &amp;amp;amp;amp;attributes) :
    element(attributes) {
        parse();
    }

    virtual ~button() { cout << endl; }

    virtual void parse(){
        attributeStream >> name;
        attributeStream >> caption;
        attributeStream >> style;
    }

    virtual void printInfo(){
        element::printInfo();
        cout << "Name: " << name << endl;
        cout << "Caption: " << caption << endl;
        cout << "Style: " << style << endl;
    }

    string caption;
    int style;
};

class window : public element {
    public:
    window(string &amp;amp;amp;amp;attributes) :
    element(attributes) {
        parse();
    }

    virtual ~window() { cout << endl; }

    virtual void parse(){
        attributeStream >> name;
        attributeStream >> title;
    }

    virtual void printInfo(){
        element::printInfo();
        cout << "Name: " << name << endl;
        cout << "Title: " << title << endl;
    }

    string title;
};

element *createElement(string &amp;amp;amp;amp;type, string &amp;amp;amp;amp;attributes){
#define \
createThis(x)\
if(type == #x) return new x(attributes)

    createThis(button);
    else createThis(window);
    else return NULL;
}

/*Each part of the code is divided into:
   Letting the user know what we're doing
   Do it
   Perform a check
   Tell the user fail or done
   exit or continue
  At any given time, the user knows what the program is doing and it helps debugging a lot.
*/

int main(int argc, char *argv[]) {
    vector<element*> elementList;

    cout << "Opening file: ";
    ifstream document;
    document.open("test.sxml", ios::binary);
    if (!document.is_open()) {
        cout << "[fail]" << endl;
        exit(-1);
    } else {
        cout << "[done]" << endl;
    }

    cout << "Getting filesize: ";
    document.seekg(0, ios::end);
    unsigned int docLen = document.tellg();
    document.seekg(0, ios::beg);
    cout << docLen << " bytes. [done]" << endl;

    cout << "Loading file into memory: ";

    char *buf = new char [docLen];
    document.read(buf, docLen);
    if (document.bad()) {
        cout << "[fail]" << endl;
    } else {
        cout << "[done]" << endl;
    }

    cout << "Parsing file for elements: ";
    /*Algorithm:
          Find a '<'
          if nextchar != '/''
              read in data until >
              parse data, create element
              if char before > != '/'
                  push this element as curent parent
          else if nextchar == '/'
              pop the last parent
    */

    stack <element*> parentStack;
    parentStack.push(NULL);
    unsigned int n, i;
    for (i = 0; i < docLen; i++) {
        if (buf[i] == '<') {
            if (buf[i+1] != '/') {
                for(n = i+1; buf[n] != '>' &amp;amp;amp;amp;&amp;amp;amp;amp; buf[n] != '/'; n++);
                unsigned int lineLength = n - i;
                string line(&amp;amp;amp;amp;buf[i+1], lineLength-1);
                //cout << "DEBUG LINE READ: " << line << endl;
                stringstream lineStream(line);
                string type;
                lineStream >> type;
                element *curElem = createElement(type, line);
                curElem->setParent(parentStack.top());

                for (n = i+2; buf[n] != '>'; n++);
                if (buf[n-1] != '/') {
                    parentStack.push(curElem);
                }
                elementList.push_back(curElem);
            } else {
                parentStack.pop();
            }
        }
    }
    cout << "[done]" << endl;

    for (unsigned int n = 0; n < elementList.size(); n++) {
        elementList[n]->printInfo();
    }
    return 0;
}

Sooo, feel free to comment on the code, but make it useful.