API tools faq
paste
View difference between Paste ID: pDVgw3tK and
SHOW: | | - or go back to the newest paste.
1-
1+
//////////////

2
// List Tag //

3
//////////////

4
5
// Code omitted

6
7
void NBT::Tag::List::ClearMismatchedTypes(){

8
	for (std::vector<std::shared_ptr<NBT::Tag::Base> >::iterator i = Value.begin(); i != Value.end();){

9
		if ((*i)->GetType() != Type)

10
			i = Value.erase(i);

11
		else

12
			++i;

13
	}

14
}

15
16
// Code omitted

17
18
bool NBT::Tag::List::Load(std::istream &Stream, bool LoadExtra){

19
	// Code omitted

20
	int8_t ID = ReadByte(Stream);

21
	if (!Stream.good() || ID < 0 || ID > 10)

22
		return false;

23
	SetTagType(ID);

24
	int32_t Length = ReadInt(Stream);

25
	if (!Stream.good())

26
		return false;

27
	std::vector<std::shared_ptr<NBT::Tag::Base> > NewValue;

28
	for (int32_t i = 0; i < Length; i++){

29
		std::shared_ptr<NBT::Tag::Base> NewTag;

30
		switch (ID){

31
			case NBT::TagID::Byte:{

32
				NewTag.reset(new NBT::Tag::Byte("", 0));

33
				break;

34
			}

35
			case NBT::TagID::Short:{

36
				NewTag.reset(new NBT::Tag::Short("", 0));

37
				break;

38
			}

39
			case NBT::TagID::Int:{

40
				NewTag.reset(new NBT::Tag::Int("", 0));

41
				break;

42
			}

43
			case NBT::TagID::Long:{

44
				NewTag.reset(new NBT::Tag::Long("", 0));

45
				break;

46
			}

47
			case NBT::TagID::Float:{

48
				NewTag.reset(new NBT::Tag::Float("", 0));

49
				break;

50
			}

51
			case NBT::TagID::Double:{

52
				NewTag.reset(new NBT::Tag::Double("", 0));

53
				break;

54
			}

55
			case NBT::TagID::ByteArray:{

56
				NewTag.reset(new NBT::Tag::ByteArray("", std::vector<int8_t>()));

57
				break;

58
			}

59
			case NBT::TagID::String:{

60
				NewTag.reset(new NBT::Tag::String("", ""));

61
				break;

62
			}

63
			case NBT::TagID::List:{

64
				NewTag.reset(new NBT::Tag::List("", std::vector<std::shared_ptr<NBT::Tag::Base> >()));

65
				break;

66
			}

67
			case NBT::TagID::Compound:{

68
				NewTag.reset(new NBT::Tag::Compound("", std::map<std::string, std::shared_ptr<NBT::Tag::Base> >()));

69
				break;

70
			}

71
			default:

72
				break;

73
		}

74
		if (NewTag.get() == NULL){

75
			NewValue.clear();

76
			return false;

77
		}

78
		if (!NewTag->Load(Stream, false) || !Stream.good()){

79
			NewTag.reset();

80
			NewValue.clear();

81
			return false;

82
		}

83
		std::cout << "Pointer: " << NewTag.get() << '\n';

84
		NewValue.push_back(NewTag);

85
	}

86
	if (!Stream.good()){

87
		NewValue.clear();

88
		return false;

89
	}

90
	SetValue(NewValue);

91
	std::cout << Value.size() << " entries\n";

92
	std::cout << "Pointers:\n";

93
	for (std::vector<std::shared_ptr<NBT::Tag::Base> >::iterator i = Value.begin(); i != Value.end(); i++)

94
		std::cout << i->get() << '\n';

95
	std::cout << "}\n";

96
	return true;

97
}

98
99
// Code omitted

100
101
void NBT::Tag::List::SetTagType(int8_t NewType){

102
	Type = NewType;

103
	ClearMismatchedTypes();

104
}

105
106
void NBT::Tag::List::SetValue(std::vector<std::shared_ptr<NBT::Tag::Base> > &NewValue){

107
	Value.clear();

108
	for (std::vector<std::shared_ptr<NBT::Tag::Base> >::iterator i = NewValue.begin(); i != NewValue.end(); i++)

109
		Value.push_back(*i);

110
	if (Value.size() > 0)

111
		SetTagType(Value.front()->GetType());

112
	else

113
		SetTagType(-1);

114
}

115
116
// Code omitted

117
118
//////////////////

119
// Compound Tag //

120
//////////////////

121
122
// Code omitted

123
124
bool NBT::Tag::Compound::Load(std::istream &Stream, bool LoadExtra){

125
	// Code omitted

126
	std::map<std::string, std::shared_ptr<NBT::Tag::Base> > NewValue;

127
	while (true){

128
		std::shared_ptr<NBT::Tag::Base> NewTag;

129
		int8_t ID = ReadByte(Stream);

130
		if (!Stream.good() || ID < 0 || ID > 10){

131
			NewValue.clear();

132
			return false;

133
		}

134
		if (ID == 0)

135
			break;

136
		switch (ID){

137
			case NBT::TagID::Byte:{

138
				NewTag.reset(new NBT::Tag::Byte("", 0));

139
				break;

140
			}

141
			case NBT::TagID::Short:{

142
				NewTag.reset(new NBT::Tag::Short("", 0));

143
				break;

144
			}

145
			case NBT::TagID::Int:{

146
				NewTag.reset(new NBT::Tag::Int("", 0));

147
				break;

148
			}

149
			case NBT::TagID::Long:{

150
				NewTag.reset(new NBT::Tag::Long("", 0));

151
				break;

152
			}

153
			case NBT::TagID::Float:{

154
				NewTag.reset(new NBT::Tag::Float("", 0));

155
				break;

156
			}

157
			case NBT::TagID::Double:{

158
				NewTag.reset(new NBT::Tag::Double("", 0));

159
				break;

160
			}

161
			case NBT::TagID::ByteArray:{

162
				NewTag.reset(new NBT::Tag::ByteArray("", std::vector<int8_t>()));

163
				break;

164
			}

165
			case NBT::TagID::String:{

166
				NewTag.reset(new NBT::Tag::String("", ""));

167
				break;

168
			}

169
			case NBT::TagID::List:{

170
				NewTag.reset(new NBT::Tag::List("", std::vector<std::shared_ptr<NBT::Tag::Base> >()));

171
				break;

172
			}

173
			case NBT::TagID::Compound:{

174
				NewTag.reset(new NBT::Tag::Compound("", std::map<std::string, std::shared_ptr<NBT::Tag::Base> >()));

175
				break;

176
			}

177
			default:

178
				break;

179
		}

180
		if (NewTag.get() == NULL){

181
			NewValue.clear();

182
			return false;

183
		}

184
		if (!NewTag->Load(Stream, true) || !Stream.good()){

185
			NewTag.reset();

186
			NewValue.clear();

187
			return false;

188
		}

189
		std::cout << "Pointer: " << NewTag.get() << '\n';

190
		NewValue.insert(std::pair<std::string, std::shared_ptr<NBT::Tag::Base> >(NewTag->GetName(), NewTag));

191
	}

192
	if (!Stream.good()){

193
		NewValue.clear();

194
		return false;

195
	}

196
	SetValue(NewValue);

197
	std::cout << Value.size() << " entries\n";

198
	std::cout << "Pointers:\n";

199
	for (std::map<std::string, std::shared_ptr<NBT::Tag::Base> >::iterator i = Value.begin(); i != Value.end(); i++)

200
		std::cout << i->second.get() << '\n';

201
	std::cout << "}\n";

202
	return true;

203
}

204
205
// Code omitted

206
207
void NBT::Tag::Compound::SetValue(std::map<std::string, std::shared_ptr<NBT::Tag::Base> > &NewValue){

208
	Value.clear();

209
	Value = NewValue;

210
}

211
212
// Code omitted
        

    


            


                                


        

            



                
    

        Public Pastes
    

    
            

    

                    

        

    





    


    
    
    
    
    
    
    
    




    


    



                

            We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.             OK, I Understand
        

    
                

            

                
                    
                
            

            

                Not a member of Pastebin yet?

                Sign Up, it unlocks many cool features!