4. Binary Datein zu String (Archiv)

Binary Datein zu String (Archiv)

  • D

    Hi

    Ich habe folgendes Problem:

    if(bBinary) { //Binary geht nicht
        CFile DateiLesen(m_strDirectoryLoader + OrdnerPrefix + strOrdner + strName, CFile::modeRead | CFile::typeBinary);
            BYTE *binbuffer = "";
            DateiLesen.Read(binbuffer, 30);
            strFileContent.Format("%d", binbuffer);
        DateiLesen.Close();

    } else { // Text Einlesen
        CStdioFile DateiLesen(m_strDirectoryLoader + OrdnerPrefix + strOrdner + strName, CFile::modeRead | CFile::typeText);
        while(DateiLesen.ReadString(buffer))
        {
            strFileContent += "\r\n" + buffer;
        }

        DateiLesen.Close();
    }

    Also Text datein einlesen klappt Prima.

    Jetz müsste ich aber auch noch Binary Datein einlesen und sie so Konvertieren das wenn das Archiv später als String eingelesen wird nichts Verloren geht. So wie ich mir dsa gedacht hab klappt das aber nicht mit den Binary Datein.

    Ich hab ja weder die Grösse der Datei, noch kann ich sie einlesen. Wäre Prima wenn ihr ein wenig Schützenhilfe geben würdet.

    Oder andere Möglichkeit zB wavs, bmps als Strings einlesen aber kein bissl bearbeiten. Würde dabei nichts verloren gehen ?

    Danke schonmal, DaRpH

    [ Dieser Beitrag wurde am 12.03.2003 um 22:09 Uhr von DaRpH editiert. ]

    [ Dieser Beitrag wurde am 13.03.2003 um 14:52 Uhr von DaRpH editiert. ]

    0
  • R

    Ein CString-Objekt dafür zu verwenden, geht deshalb nicht, weil schon bei der Übergabe der Zeichenkette an das CString-Objekt die Länge festgelegt wird, welche mit dem 1. Auftreten eines '\0' definiert ist.
    Hier musst Du schon ein Array nehmen. Zu empfehlen wäre CArray aus MFC oder aber die STL.

    0
  • D

    Kann man nicht irgendwie die Binary Daten als byte einlesen und über .Format in einen CString rein?

    Wenn das Archiv später eingelesen wird ist ja die Struktur ungefähr so :

    File Content {
Datei Inhalt
} FileContent

    Der Datei Inhalt wird dann ausgeschnitten. Und wieder zu byte umgewandelt und dann auch so gespeichert.

    Ich weiss blos halt nicht wo den nun der Fehler liegt.

    0
  • ?

    CString speichert Texte/ Zeichenketten, dafür ist die Klasse da. Alle anderen Daten sollten auch anders gespeichert werden. Denn sobald in diesen Daten ein '\0'-Zeichen enthalten ist, kommt alles durcheinander. Und das kann ich mir vor allem bei Binary-Daten sehr gut vorstellen.

    Kleiner Rat: 🙂
    Vergiss die Idee mit CString und denk' Dir was anderes aus! Wieso muss es unbedingt ein CString sein? Und die Größe einer Datei lässt sich ermitteln, als weisst Du auch wieviel Daten Du maximal lesen wirst.

    0
  • R

    Doppelt scheint manchmal doch besser zu helfen, gell Shaggy 😉

    0
  • ?

    Hoppla, hab Dich doch glatt "überscrollt".

    Shit happens! :p

    0
  • D

    hmm dann ist die Sache mit Archiv eigentlich schon für mich gestorben.

    oder weis einer von euch wie man ein Archiv gesamt in Binary aufbaut?

    0
  • ?

    Präzisiere doch mal Dein Projekt, damit man ungefähr weiß, worum es im großen und ganzen gehen soll.

    0
  • D

    um einen Installer.

    Alle Datein die kopiert werden sollen sind in einem Selbst gecodetetem Archiv. Jetz bräucht ich allerdings halt auch noch den Support für Binary Datein. Und die Textdatein muss ich auch als Textdatein einlesen da ich an den Datein (Art Templates) mit .Replace noch Teilstrings ersetzen muss.

    Bei den Binary datein will ich gar nichts ändern ich will sie nur gerne auch in einem Archiv haben. Das ganze muss nicht Komprimiert sein.

    Mein Momentanes Archiv ist halt so aufgebaut

    Archiv erstellen:

    void CAgentAimDumperv1Dlg::DateiSpeichern(bool bPrefix, bool bSyntax, bool bBinary, CString strOrdner, CString strName)
{
    /* Verzeichnisse testen und erstellen */
    CString OrdnerPrefix = "",
            MainOrdnerName = "OGS",
            buffer = "",
            strFileContent = "",
            strPrefix = "",
            strBinary = "",
            strSyntax = "";

    if(bPrefix){
        OrdnerPrefix = "\\" + MainOrdnerName;
        strPrefix = "true";
    } else {
        OrdnerPrefix = "\\";
        strPrefix = "false";
    }

    if(bSyntax){
        strSyntax = "true";
    } else {
        strSyntax = "false";
    }

    if(bBinary){
        strBinary = "true";
    } else {
        strBinary = "false";
    }

    if(bBinary) { //Binäre fehlt noch
        CFile DateiLesen(m_strDirectoryLoader + OrdnerPrefix + strOrdner + strName, CFile::modeRead | CFile::typeBinary);
            BYTE tester2 = 1;
            BYTE* binbuffer = &tester2;
            DateiLesen.Read(binbuffer, 30);
            strFileContent.Format("%d", tester2);
        DateiLesen.Close();

    } else { // Text Einlesen
        CStdioFile DateiLesen(m_strDirectoryLoader + OrdnerPrefix + strOrdner + strName, CFile::modeRead | CFile::typeText);
        while(DateiLesen.ReadString(buffer))
        {
            strFileContent += "\r\n" + buffer;
        }

        DateiLesen.Close();
    }

    m_strNewText += "\r\nµ__NEW FILE__\r\n";
    m_strNewText += "µPrefix :" + strPrefix + "\r\n";
    m_strNewText += "µSyntax :" + strSyntax + "\r\n";
    m_strNewText += "µBinary :" + strBinary + "\r\n";
    m_strNewText += "µName :"   + strName   + "\r\n";
    m_strNewText += "µOrdner :" + strOrdner + "\r\n";

    m_strNewText += "µContent {" + strFileContent + "\r\n} µContent\r\n\r\n";

    strFileContent.ReleaseBuffer();

    UpdateData(false);
}

    Archiv Lesen:

    void CAgentAimLoaderv1Dlg::GetDump(CString Dumpfile)
{
    m_strStatus += "opening DumpFile: " + m_strDirectoryLoader + "\\" + Dumpfile + "\r\n";
    UpdateData(false);
    m_cStatus.LineScroll(++m_intLinePos, 0);
    const CString   m_strStartPrefix        = "µPrefix :",
                    m_strStartSyntax        = "µSyntax :",
                    m_strStart              = "µBinary :",
                    m_strStartName          = "µFilename :",
                    m_strStartOrdner        = "µOrdner :",
                    m_strStartFile          = "µ__NEW FILE__",
                    m_strStartFileContent   = "µContent {",

                    m_strEndFileContent     = "} µContent";

    int FileCount = 0;
    CString buffer = "";
    bool FileContent = false;
    m_strText = "";

    m_strStatus += "reading DumpFile...\r\n";
    UpdateData(false);
    m_cStatus.LineScroll(++m_intLinePos, 0);

    CStdioFile DateiLesen(m_strDirectoryLoader + "\\" + Dumpfile, CFile::modeRead);
    while(DateiLesen.ReadString(buffer)) {

        int FindPrefix           = buffer.Find(m_strStartPrefix     , 0),
            FindName             = buffer.Find(m_strStartName       , 0),
            FindOrdner           = buffer.Find(m_strStartOrdner     , 0),
            FindFileStart        = buffer.Find(m_strStartFile       , 0),
            FindFileContentStart = buffer.Find(m_strStartFileContent, 0),
            FindFileContentEnd   = buffer.Find(m_strEndFileContent  , 0);

        if(FindFileContentEnd != -1) {
            FileContent = false;
        }

        if(FileContent) {
            Archiv[FileCount].strContent += "\r\n" + buffer;
        } 

        if(!FileContent) {
            if(FindFileStart != -1){
                Archiv[FileCount].strContent += "\r\n\r\n%input_scriptcopyright";
                ++FileCount;
                Archiv[FileCount].strContent += "%input_scriptcopyright\r\n";
            }

            if(FindPrefix != -1){
                CString tempbuffer = buffer.Right(buffer.GetLength() - m_strStartName.GetLength());

                if(tempbuffer == "TRUE") {
                    Archiv[FileCount].bPrefix = true;
                }

                if(tempbuffer == "FALSE") {
                    Archiv[FileCount].bPrefix = false;
                }

            }

            if(FindName != -1){
                Archiv[FileCount].strName = buffer.Right(buffer.GetLength() - m_strStartName.GetLength());

                m_strStatus += "Found File: " + Archiv[FileCount].strName + "\r\n";
                UpdateData(false);
                m_cStatus.LineScroll(++m_intLinePos, 0);
            }

            if(FindOrdner != -1){
                Archiv[FileCount].strOrdner = buffer.Right(buffer.GetLength() - m_strStartOrdner.GetLength());
            }
        }

        if(FindFileContentStart != -1) {
            FileContent = true;
        }
    }
    DateiLesen.Close();
    m_strStatus += "\r\n************ DUMP READING COMPLETE ************\r\n";
    UpdateData(false);
    m_cStatus.LineScroll(++m_intLinePos, 0);
}

    Datein aus Archiv erstellen:

    void CAgentAimLoaderv1Dlg::DateiSpeichern(bool Prefix, bool Syntax, bool Binary, CString Ordner, CString Name, CString FileContent)
{
    UpdateData(true);

    /* Variablen je Nach Script Bezeichnug
    *  MainOrdnerName  -> Name des Scriptordners ohne prefix
    */

    /* Prozentangabe des Total Fortschritts */
    ++m_intProgressTotal;
    m_CtrlProgressTotal.SetPos(m_intProgressTotal);

    /* Prozentangabe des File Fortschritts */
    m_CtrlProgressFile.SetPos(0);
    m_intProgressFile=0;
    ++m_intProgressFile;
    m_CtrlProgressFile.SetPos(m_intProgressFile);

    /* Verzeichnisse testen und erstellen */
    CString OrdnerPrefix,
            AlleOrdner,
            MainOrdnerName = "OGS";

    if(Prefix){ /* MainOrdner erstellen falls Datei prefix geschuetzt ist */
        CreateDirectory(m_strDirectoryScript + "\\" + m_strZufallszahl + MainOrdnerName, NULL);
        OrdnerPrefix = "\\" + m_strZufallszahl + MainOrdnerName;
    } else {
        OrdnerPrefix = "";
    }

    if(Ordner != "") {

        CreateDirectory(m_strDirectoryScript + OrdnerPrefix + AlleOrdner, NULL);
    }

    ++m_intProgressFile;
    m_CtrlProgressFile.SetPos(m_intProgressFile);
    /* Datein erstellen */

    m_strText = FileContent;
    StringReplace();

    CFile DateiSchreiben(m_strDirectoryScript + OrdnerPrefix + AlleOrdner + "\\" + Name, CFile::modeCreate | CFile::modeWrite); 
    DateiSchreiben.Write(m_strText.GetBuffer(m_strText.GetLength()), m_strText.GetLength());
    DateiSchreiben.Close();
    m_strText.ReleaseBuffer();

    m_strStatus += "creating file " + m_strDirectoryScript + OrdnerPrefix + AlleOrdner + "\\" + Name + "\r\n";
    ++m_intProgressFile;
    m_CtrlProgressFile.SetPos(m_intProgressFile);

    UpdateData(false);
    m_cStatus.LineScroll(++m_intLinePos, 0);
}

    Im letzen können Fehler drin sein weil ich hab vor kurzem noch was geändert

    [ Dieser Beitrag wurde am 13.03.2003 um 14:36 Uhr von DaRpH editiert. ]

    0
  • ?

    Also ich empfehle Dir da folgende Methode:

    Nutze CObject, CArchive und CFile und verwende Serialization (CObject::Serialize(...)).

    Leite Dir von CObject verschiedene Klassen ab, eine für Archivinformationen, eine für Textdateien, eine für Binärdateien, etc.

    Zum Archiv erzeugen machst Du dann folgendes:

    Archive mit CFile öffnen, CArchive auf die Datei ansetzen und Deine Objekte per

    CMeinObject::Serialize(archive);

    dort hineinverfrachten.

    Die Objekte müssen natürlich CObject::Serialize() überschrieben haben, um Daten lesen und schreiben zu können.

    Noch einfacher geht's, wenn Du die Objekte, die die ganzen Daten halten in z.B ein CObArray einfügts und dann einfach

    MyArchive << MyArray;

    aufrufst.

    Das ist jetzt natürlich alles in Schnellform, aber ein grober Überblick. Zum Thema Serialization gibt die MSDN viel her. Ich bin von dieser Methode sehr überzeugt, zumal sie sehr flexibel handhabbar ist und sich so in eine Datei alles reinspeichern lässt.

    Ich hoffe, dass hilft etwas weiter.

    Kleiner Tipp: Deine Dateiobjekte könnten z.B. erst in Ihrer Serialize()-Methode, die Quell-/Zieldateien öffnen und Daten transferieren, so hältst Du die Speichernutzung niedrig.

    Shaggy

    PS.: Wenn Fragen sind, gerne stellen, aber bitte erst mal mit der MSDN ausgiebig beschäftigen.

    0
Anmelden zum Antworten