41335575034

Committed 01 Nov 2026 06:14PM UTC coverage: 87.583% (+4.4%) from 83.224%

Build # 41335575034

Build Type

push

github

Committed by

Flamefire

Commit Message

Detect *.mid as *.midi files

Coverage Stats

1 of 1 new or added line in 1 file covered. (100.0%)

32 existing lines in 5 files now uncovered.

4909 of 5605 relevant lines covered (87.58%)

4551.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

77.46

/src/WriteType.cpp

// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
//
// SPDX-License-Identifier: GPL-2.0-or-later

#include "ArchivItem_Bitmap_Player.h"
#include "ArchivItem_Bitmap_RLE.h"
#include "ArchivItem_Bitmap_Raw.h"
#include "ArchivItem_Bitmap_Shadow.h"
#include "ArchivItem_Bob.h"
#include "ArchivItem_Font.h"
#include "ArchivItem_Map.h"
#include "ArchivItem_Palette.h"
#include "ArchivItem_PaletteAnimation.h"
#include "ArchivItem_Sound.h"
#include "ArchivItem_Text.h"
#include "ErrorCodes.h"
#include "prototypen.h"
#include "libendian/EndianOStreamAdapter.h"
#include <iostream>

/**
 *  schreibt eine spezifizierten Bobtype aus einem ArchivItem in eine Datei.
 *
 *  @param[in]  bobtype Typ des Items
 *  @param[in]  filepath    Filehandle auf die auszulesende Datei
 *  @param[in]  palette Grundpalette
 *  @param[out] item    ArchivItem-Struktur, welche gefüllt wird
 *
 *  @return Null bei Erfolg, ein Wert ungleich Null bei Fehler
 */
int libsiedler2::loader::WriteType(BobType bobtype, std::ostream& lst, const ArchivItem& item,
                                   const ArchivItem_Palette* palette)
{
    if(!lst)
        return ErrorCode::FILE_NOT_ACCESSIBLE;

    try
    {
        switch(bobtype)
        {
            case BobType::Sound: // WAVs, MIDIs
            {
                const auto& i = dynamic_cast<const ArchivItem_Sound&>(item);
                libendian::EndianOStreamAdapter<false, std::ostream&> fs(lst);
                const long sizePos = fs.getPosition();
                fs << uint32_t(0);
                if(int ec = i.write(lst))
                    return ec;
                const long curPos = fs.getPosition();
                fs.setPosition(sizePos);
                fs << uint32_t(curPos - sizePos - 4);
                fs.setPosition(curPos);
            }
            break;
            case BobType::BitmapRLE: // RLE komprimiertes Bitmap
            {
                const auto& i = dynamic_cast<const baseArchivItem_Bitmap_RLE&>(item);

                if(int ec = i.write(lst, palette))
                    return ec;
            }
            break;
            case BobType::Font: // Font
            {
                const auto& i = dynamic_cast<const ArchivItem_Font&>(item);

                if(int ec = i.write(lst, palette))
                    return ec;
            }
            break;
            case BobType::BitmapPlayer: // Bitmap mit spezifischer Spielerfarbe
            {
                const auto& i = dynamic_cast<const ArchivItem_Bitmap_Player&>(item);

                if(int ec = i.write(lst, palette))
                    return ec;
            }
            break;
            case BobType::Palette: // Palette
            {
                const auto& i = dynamic_cast<const ArchivItem_Palette&>(item);

                if(int ec = i.write(lst))
                    return ec;
            }
            break;
            case BobType::BitmapShadow: // Schatten
            {
                const auto& i = dynamic_cast<const baseArchivItem_Bitmap_Shadow&>(item);

                if(int ec = i.write(lst, palette))
                    return ec;
            }
            break;
            case BobType::Bob: // Bobfile
            {
                const auto& i = dynamic_cast<const ArchivItem_Bob&>(item);

                if(int ec = i.write(lst, palette))
                    return ec;
            }
            break;
            case BobType::Map: // Mapfile
            {
                const auto& i = dynamic_cast<const ArchivItem_Map&>(item);

                if(int ec = i.write(lst))
                    return ec;
            }
            break;
            case BobType::Bitmap: // unkomprimiertes Bitmap
            {
                const auto& i = dynamic_cast<const baseArchivItem_Bitmap_Raw&>(item);

                if(int ec = i.write(lst, palette))
                    return ec;
            }
            break;
            case BobType::PaletteAnim:
            {
                const auto& i = dynamic_cast<const ArchivItem_PaletteAnimation&>(item);
                if(int ec = i.write(lst)) //-V522
                    return ec;
            }
            break;
            case BobType::Text:
            {
                const auto& i = dynamic_cast<const ArchivItem_Text&>(item);
                if(int ec = i.write(lst))
                    return ec;
            }
            break;
            default: return ErrorCode::NONE;
        }
    } catch(std::exception& e)
    {
        // Mostly error on writing (e.g. unexpected end of file)
        std::cerr << "Error while writing: " << e.what() << std::endl;
        return ErrorCode::CUSTOM;
    }
    return ErrorCode::NONE;
}

1	// Copyright (C) 2005 - 2021 Settlers Freaks (sf-team at siedler25.org)
2	//
3	// SPDX-License-Identifier: GPL-2.0-or-later
4
5	#include "ArchivItem_Bitmap_Player.h"
6	#include "ArchivItem_Bitmap_RLE.h"
7	#include "ArchivItem_Bitmap_Raw.h"
8	#include "ArchivItem_Bitmap_Shadow.h"
9	#include "ArchivItem_Bob.h"
10	#include "ArchivItem_Font.h"
11	#include "ArchivItem_Map.h"
12	#include "ArchivItem_Palette.h"
13	#include "ArchivItem_PaletteAnimation.h"
14	#include "ArchivItem_Sound.h"
15	#include "ArchivItem_Text.h"
16	#include "ErrorCodes.h"
17	#include "prototypen.h"
18	#include "libendian/EndianOStreamAdapter.h"
19	#include <iostream>
20
21	/**
22	* schreibt eine spezifizierten Bobtype aus einem ArchivItem in eine Datei.
23	*
24	* @param[in] bobtype Typ des Items
25	* @param[in] filepath Filehandle auf die auszulesende Datei
26	* @param[in] palette Grundpalette
27	* @param[out] item ArchivItem-Struktur, welche gefüllt wird
28	*
29	* @return Null bei Erfolg, ein Wert ungleich Null bei Fehler
30	*/
31	int libsiedler2::loader::WriteType(BobType bobtype, std::ostream& lst, const ArchivItem& item,	91 ✔
32	const ArchivItem_Palette* palette)
33	{
34	if(!lst)	91 ✔
UNCOV 35	return ErrorCode::FILE_NOT_ACCESSIBLE;	×
36
37	try
38	{
39	switch(bobtype)	91 ✔
40	{
41	case BobType::Sound: // WAVs, MIDIs	4 ✔
42	{
43	const auto& i = dynamic_cast<const ArchivItem_Sound&>(item);	4 ✔
44	libendian::EndianOStreamAdapter<false, std::ostream&> fs(lst);	4 ✔
45	const long sizePos = fs.getPosition();	4 ✔
46	fs << uint32_t(0);	4 ✔
47	if(int ec = i.write(lst))	4 ✔
48	return ec;	×
49	const long curPos = fs.getPosition();	4 ✔
50	fs.setPosition(sizePos);	4 ✔
51	fs << uint32_t(curPos - sizePos - 4);	4 ✔
52	fs.setPosition(curPos);	4 ✔
53	}
54	break;	4 ✔
55	case BobType::BitmapRLE: // RLE komprimiertes Bitmap	13 ✔
56	{
57	const auto& i = dynamic_cast<const baseArchivItem_Bitmap_RLE&>(item);	13 ✔
58
59	if(int ec = i.write(lst, palette))	13 ✔
60	return ec;	1 ✔
61	}
62	break;	12 ✔
63	case BobType::Font: // Font	2 ✔
64	{
65	const auto& i = dynamic_cast<const ArchivItem_Font&>(item);	2 ✔
66
67	if(int ec = i.write(lst, palette))	2 ✔
UNCOV 68	return ec;	×
69	}
70	break;	2 ✔
71	case BobType::BitmapPlayer: // Bitmap mit spezifischer Spielerfarbe	35 ✔
72	{
73	const auto& i = dynamic_cast<const ArchivItem_Bitmap_Player&>(item);	35 ✔
74
75	if(int ec = i.write(lst, palette))	35 ✔
76	return ec;	1 ✔
77	}
78	break;	34 ✔
79	case BobType::Palette: // Palette	1 ✔
80	{
81	const auto& i = dynamic_cast<const ArchivItem_Palette&>(item);	1 ✔
82
83	if(int ec = i.write(lst))	1 ✔
UNCOV 84	return ec;	×
85	}
86	break;	1 ✔
87	case BobType::BitmapShadow: // Schatten	13 ✔
88	{
89	const auto& i = dynamic_cast<const baseArchivItem_Bitmap_Shadow&>(item);	13 ✔
90
91	if(int ec = i.write(lst, palette))	13 ✔
92	return ec;	1 ✔
93	}
94	break;	12 ✔
UNCOV 95	case BobType::Bob: // Bobfile	×
96	{
UNCOV 97	const auto& i = dynamic_cast<const ArchivItem_Bob&>(item);	×
98
99	if(int ec = i.write(lst, palette))	×
UNCOV 100	return ec;	×
101	}
102	break;	×
103	case BobType::Map: // Mapfile	2 ✔
104	{
105	const auto& i = dynamic_cast<const ArchivItem_Map&>(item);	2 ✔
106
107	if(int ec = i.write(lst))	2 ✔
UNCOV 108	return ec;	×
109	}
110	break;	2 ✔
111	case BobType::Bitmap: // unkomprimiertes Bitmap	17 ✔
112	{
113	const auto& i = dynamic_cast<const baseArchivItem_Bitmap_Raw&>(item);	17 ✔
114
115	if(int ec = i.write(lst, palette))	17 ✔
116	return ec;	1 ✔
117	}
118	break;	16 ✔
119	case BobType::PaletteAnim:	3 ✔
120	{
121	const auto& i = dynamic_cast<const ArchivItem_PaletteAnimation&>(item);	3 ✔
122	if(int ec = i.write(lst)) //-V522	3 ✔
UNCOV 123	return ec;	×
124	}
125	break;	3 ✔
126	case BobType::Text:	1 ✔
127	{
128	const auto& i = dynamic_cast<const ArchivItem_Text&>(item);	1 ✔
129	if(int ec = i.write(lst))	1 ✔
130	return ec;	×
131	}
132	break;	1 ✔
UNCOV 133	default: return ErrorCode::NONE;	×
134	}
UNCOV 135	} catch(std::exception& e)	×
136	{
137	// Mostly error on writing (e.g. unexpected end of file)
UNCOV 138	std::cerr << "Error while writing: " << e.what() << std::endl;	×
UNCOV 139	return ErrorCode::CUSTOM;	×
140	}
141	return ErrorCode::NONE;	87 ✔
142	}

Return-To-The-Roots / libsiedler2 / 41335575034

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous