struct StandardFileHeader
{
    char* fileType;
    int formatVersion;
            
    std::string name;
    std::string author;
    std::string description;
    std::string creationProgram;
};

(note, the formatting is kind of screwed up)

StandardFileHeader FileIoHandle::LoadStandardHeader()
        {
            StandardFileHeader header;
            int nameSize, authorSize, descSize, creatorSize;
            char* name, *author, *desc, *creator;
            
            ToBeginning();
            
            header.fileType = GetChunk<char>(8);
            header.formatVersion = GetChunk<int>();
            
            nameSize = GetChunk<int>();
            name = GetChunk<char>(nameSize);
            authorSize = GetChunk<int>();
            author = GetChunk<char>(authorSize);
            descSize = GetChunk<int>();
            desc = GetChunk<char>(descSize);
            creatorSize = GetChunk<int>();
            creator = GetChunk<char>(creatorSize);
            
            header.name = name;
            header.author = author;
            header.description = desc;
            header.creationProgram = creator;
            
            return header;
        }

void FileIoHandle::PutStandardHeader
            (const std::string& fileType, int formatVersion, const std::string& name, 
             const std::string& author, const std::string& description, 
                                            const std::string& creationProgram)
        {
            ToBeginning();
            
            PutString(fileType.c_str(), 8);
            PutChunk<int>(formatVersion);
            
            
            PutChunk<int>(name.size());
            PutString(name.c_str(), name.size());
            PutChunk<int>(author.size());
            PutString(author.c_str(), author.size());
            PutChunk<int>(description.size());
            PutString(description.c_str(), description.size());
            PutChunk<int>(creationProgram.size());
            PutString(creationProgram.c_str(), creationProgram.size());
        }

bool FileIoTestWrite()
        {
            using namespace stratus;
            using namespace base;
            
            FileIoHandle* File = new FileIoHandle();
            
            File->Open("testFile.txt");
                
            File->PutStandardHeader("testfil", 27, "Test File", 
"Grant Williams",
"This is a file for testing", 
"FileIo library");
            
            File->Close();
            
            delete File;
        }
        
        bool FileIoTestRead()
        {
            using namespace stratus;
            using namespace base;
            
            using namespace std;
            
            FileIoHandle* File = new FileIoHandle();
            
            if(!File->Open("testFile.txt"))
                return false;
                
            StandardFileHeader header;
            header = File->LoadStandardHeader();
            
            cout << File->GetFileName() << endl
                 << File->GetFileSize() << endl << endl;
            
            cout << header.fileType << endl
                 << header.formatVersion << endl
                 << header.name << endl
                 << header.author << endl
                 << header.description << endl
                 << header.creationProgram << endl;
                 
            File->Close();
            
            delete File;
        }

template<typename T>        T FileIoHandle::GetChunk()        {            if(!SafeForIo())                throw FileIoException("Error-Fatal: File stream, unsafe for io.");                            if(m_FileSize - (m_CurrentPosition + sizeof(T)) < 0)                throw FileIoException("Error-Fatal: Overflow on file read.");                        T data;            m_File.read((char*)&data, sizeof(T));                        m_CurrentPosition += sizeof(T);                        return data;        }                template<typename T>        T* FileIoHandle::GetChunk(int size)        {            if(!SafeForIo())                throw FileIoException("Error-Fatal: File stream, unsafe for io.");                        T* data = new T[size];            m_File.read((char*)data, size);                        m_CurrentPosition += size;                        return data;        }

class FileIoHandle        {            std::fstream m_File;            std::string m_FileName;                        int m_FileSize;            int m_CurrentPosition;                        bool safeForIo; //true if the stream is good.                        public:                bool SafeForIo();                                template<typename T>                T GetChunk();                //vv used when you want an array                template<typename T>                T* GetChunk(int size);                                template<typename T>                void PutChunk(const T& data);                void PutString(char* data, int size);                void PutString(const char* data, int size);                                bool SetCurrentPosition(int pos);                bool ToBeginning();                bool ToEnd();                                StandardFileHeader LoadStandardHeader();                ReducedFileHeader LoadReducedHeader();                                void PutStandardHeader (const std::string& fileType, int formatVersion,                                        const std::string& name,                                         const std::string& author,                                        const std::string& description,                                        const std::string& creationProgram);                void PutReducedHeader(const std::string& fileType, int formatVersion);                int GetCurrentPosition();                int GetFileSize();                std::string GetFileName();                                bool Open(const std::string& fileName);                                void Close();                                FileIoHandle();                ~FileIoHandle();        };