Want more features on Pastebin? Sign Up, it's FREE!
Guest

LotsOfCodeForStackOverflow

By: a guest on Jan 10th, 2011  |  syntax: C++  |  size: 5.28 KB  |  views: 96  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
This paste has a previous version, view the difference. Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  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
clone this paste RAW Paste Data