void MSU1::serialize(serializer &s) {
  Processor::serialize(s);

  s.integer(mmio.data_offset);
  s.integer(mmio.audio_offset);
  s.integer(mmio.audio_loop_offset);

  s.integer(mmio.audio_track);
  s.integer(mmio.audio_volume);

  s.integer(mmio.data_busy);
  s.integer(mmio.audio_busy);
  s.integer(mmio.audio_repeat);
  s.integer(mmio.audio_play);
  s.integer(mmio.audio_error);

  if(datafile.open()) datafile.close();
  if(datafile.open(string(cartridge.basename(), ".msu"), file::mode::read)) {
    datafile.seek(mmio.data_offset);
  }

  if(audiofile.open()) audiofile.close();
  if(audiofile.open(string(cartridge.basename(), "-", mmio.audio_track, ".pcm"), file::mode::read)) {
    audiofile.seek(mmio.audio_offset);
  }
}
Example #2
0
void sBus::serialize(serializer &s) {
  s.array(memory::wram.data(), memory::wram.size());
  s.array(memory::apuram.data(), memory::apuram.size());
  s.array(memory::vram.data(), memory::vram.size());
  s.array(memory::oam.data(), memory::oam.size());
  s.array(memory::cgram.data(), memory::cgram.size());
}
Example #3
0
void SuperScope::serialize(serializer& s) {
  Processor::serialize(s);
  //Save block.
  unsigned char block[Controller::SaveSize] = {0};
  block[0] = latched ? 1 : 0;
  block[1] = counter;
  block[2] = trigger ? 1 : 0;
  block[3] = cursor ? 1 : 0;
  block[4] = turbo ? 1 : 0;
  block[5] = pause ? 1 : 0;
  block[6] = offscreen ? 1 : 0;
  block[7] = (unsigned short)x >> 8;
  block[8] = (unsigned short)x;
  block[9] = (unsigned short)y >> 8;
  block[10] = (unsigned short)y;

  s.array(block, Controller::SaveSize);
  if(s.mode() == nall::serializer::Load) {
    latched = (block[0] != 0);
    counter = block[1];
    trigger = (block[2] != 0);
    cursor = (block[3] != 0);
    turbo = (block[4] != 0);
    pause = (block[5] != 0);
    offscreen = (block[6] != 0);
    x = (short)(((unsigned short)block[7] << 8) | (unsigned short)block[8]);
    y = (short)(((unsigned short)block[9] << 8) | (unsigned short)block[10]);
  }
}
 void serialize(serializer &s) {
   s.integer(basecounter);
   s.integer(heapsize);
   for(unsigned n = 0; n < heapcapacity; n++) {
     s.integer(heap[n].counter);
     s.integer(heap[n].event);
   }
 }
Example #5
0
void PPUcounter::serialize(serializer &s) {
  s.integer(status.hcounter);
  s.integer(status.vcounter);
  s.integer(status.lineclocks);
  s.integer(status.prev_lineclocks);
  s.array(status.fieldlines);
  s.integer(status.field);
}
Example #6
0
void MSU1::serialize(serializer &s) {
  Thread::serialize(s);

  s.integer(mmio.data_offset);
  s.integer(mmio.audio_offset);
  s.integer(mmio.audio_loop_offset);

  s.integer(mmio.audio_track);
  s.integer(mmio.audio_volume);

  s.integer(mmio.data_busy);
  s.integer(mmio.audio_busy);
  s.integer(mmio.audio_repeat);
  s.integer(mmio.audio_play);

  if(datafile.open()) datafile.close();
  if(datafile.open({interface->path(0), "msu1.rom"}, file::mode::read)) {
    datafile.seek(mmio.data_offset);
  }

  if(audiofile.open()) audiofile.close();
  if(audiofile.open({interface->path(0), "track-", mmio.audio_track, ".pcm"}, file::mode::read)) {
    audiofile.seek(mmio.audio_offset);
  }
}
Example #7
0
void serialize(serializer &s) {
  Board::serialize(s);

  s.integer(prg_bank);
  s.integer(chr_bank[0][0]);
  s.integer(chr_bank[0][1]);
  s.integer(chr_bank[1][0]);
  s.integer(chr_bank[1][1]);
  s.integer(mirror);
  s.array(latch);
}
Example #8
0
void serialize(serializer &s, const std::string &key, const mean_result<T> &self)
{
    internal::check_valid(self);
    internal::serializer_sentry group(s, key);

    // serialize to uint64_t to make sure we are consistent across 32/64 bit
    serialize(s, "@size", static_cast<uint64_t>(self.store_->data_.size()));
    serialize(s, "count", self.store_->count_);
    s.enter("mean");
    serialize(s, "value", self.store_->data_);
    s.exit();
}
void PPU::serialize(serializer &s) {
  PPUcounter::serialize(s);

  s.integer(status.render_output);
  s.integer(status.frame_executed);
  s.integer(status.frames_updated);
  s.integer(status.frames_rendered);
  s.integer(status.frames_executed);

  s.integer(ppu1_version);
  s.integer(ppu2_version);
}
Example #10
0
void Gamepad::serialize(serializer& s) {
  Processor::serialize(s);
  //Save block.
  unsigned char block[Controller::SaveSize] = {0};
  block[0] = latched ? 1 : 0;
  block[1] = counter;
  s.array(block, Controller::SaveSize);
  if(s.mode() == nall::serializer::Load) {
    latched = (block[0] != 0);
    counter = block[1];
  }
}
Example #11
0
void System::serialize(serializer &s) {
  s.integer((unsigned&)region);
  s.integer((unsigned&)expansion);

  s.integer(scheduler.clock.cpu_freq);
  s.integer(scheduler.clock.smp_freq);

  s.integer(scheduler.clock.cpucop);
  s.integer(scheduler.clock.cpuppu);
  s.integer(scheduler.clock.cpusmp);
  s.integer(scheduler.clock.smpdsp);
}
Example #12
0
bool StateManager::save(const char *filename, uint8 slot, serializer &s, const char *description) {
  //if no state archive exists ...
  if(file::exists(filename) == false) {
    //try and create one
    if(create(filename) == false) return false;
  }
  //if we cannot load the existing state archive ...
  if(load(filename) == false) {
    //it's probably an older version, try and create a new one
    if(create(filename) == false) return false;
    //it still needs to be loaded before we can write to it
    if(load(filename) == false) return false;
  }

  uint8 index = findslot(slot);
  if(index == SlotInvalid) {
    //create new slot instead of over-writing existing slot
    if(info.slotcount >= 255) return false;
    index = info.slotcount;
    slot  = info.slotcount;
  }

  file fp;
  if(fp.open(filename, file::mode_readwrite) == false) return false;

  fp.seek(SlotIndex + index);
  fp.write(slot);

  time_t current = time(0);
  tm *ts = localtime(&current);
  char timestamp[32];
  sprintf(timestamp, "%.4u-%.2u-%.2u %.2u:%.2u:%.2u",
    1900 + ts->tm_year, ts->tm_mon + 1, ts->tm_mday,
    ts->tm_hour, ts->tm_min, ts->tm_sec,
    (ts->tm_hour < 12 ? "AM" : "PM")
  );
  fp.seek(DateTimeIndex + index * DateTimeSize);
  fp.write((uint8*)&timestamp[0], DateTimeSize);

  char desc[DescriptionSize];
  memset(&desc, 0, DescriptionSize);
  strlcpy(desc, description, DescriptionSize);
  fp.seek(DescIndex + index * DescriptionSize);
  fp.write((uint8*)&desc[0], DescriptionSize);

  fp.seek(HeaderSize + index * system.serialize_size);
  fp.write(s.data(), s.size());
  for(unsigned n = 0; n < system.serialize_size - s.size(); n++) fp.write(0x00);

  fp.close();
  return true;
}
Example #13
0
void Cartridge::serialize(serializer &s) {
  if(memory::cartram.size() != 0 && memory::cartram.size() != ~0) {
    s.array(memory::cartram.data(), memory::cartram.size());
  }

  if(memory::cartrtc.size() != 0 && memory::cartrtc.size() != ~0) {
    s.array(memory::cartrtc.data(), memory::cartrtc.size());
  }

  if(memory::bsxram.size() != 0 && memory::bsxram.size() != ~0) {
    s.array(memory::bsxram.data(), memory::bsxram.size());
  }

  if(memory::bsxpram.size() != 0 && memory::bsxpram.size() != ~0) {
    s.array(memory::bsxpram.data(), memory::bsxpram.size());
  }

  if(memory::stAram.size() != 0 && memory::stAram.size() != ~0) {
    s.array(memory::stAram.data(), memory::stAram.size());
  }

  if(memory::stBram.size() != 0 && memory::stBram.size() != ~0) {
    s.array(memory::stBram.data(), memory::stBram.size());
  }

  if(memory::gbram.size() != 0 && memory::gbram.size() != ~0) {
    s.array(memory::gbram.data(), memory::gbram.size());
  }

  if(memory::gbrtc.size() != 0 && memory::gbrtc.size() != ~0) {
    s.array(memory::gbrtc.data(), memory::gbrtc.size());
  }
}
Example #14
0
bool System::unserialize(serializer& s) {
  unsigned signature, version;
  char hash[64], description[512];

  s.integer(signature);
  s.integer(version);
  s.array(hash);
  s.array(description);

  if(signature != 0x31545342) return false;
  if(version != Info::SerializerVersion) return false;

  power();
  serialize_all(s);
  return true;
}
Example #15
0
bool System::unserialize(serializer &s) {
  unsigned signature, version, crc32;
  char description[512];

  s.integer(signature);
  s.integer(version);
  s.integer(crc32);
  s.array(description);

  if(signature != 0x31545342) return false;
  if(version != bsnesSerializerVersion) return false;
//if(crc32 != cartridge.crc32()) return false;
  scheduler.init();

  serialize_all(s);
  return true;
}
Example #16
0
void serialize(serializer &s) {
  s.array(prg_bank);
  s.array(chr_bank);
  s.integer(mirror);

  s.integer(irq_latch);
  s.integer(irq_mode);
  s.integer(irq_enable);
  s.integer(irq_acknowledge);

  s.integer(irq_counter);
  s.integer(irq_scalar);
  s.integer(irq_line);
}
Example #17
0
void message::serialize(serializer& sink) const {
  // ttn can be nullptr even if tuple is not empty (in case of object_array)
  std::string tname = empty() ? "@<>" : tuple_type_names();
  auto uti_map = detail::singletons::get_uniform_type_info_map();
  auto uti = uti_map->by_uniform_name(tname);
  if (uti == nullptr) {
    std::string err = "could not get uniform type info for \"";
    err += tname;
    err += "\"";
    CAF_LOGF_ERROR(err);
    throw std::runtime_error(err);
  }
  sink.begin_object(uti);
  for (size_t i = 0; i < size(); ++i) {
    uniform_type_info::from(uniform_name_at(i))->serialize(at(i), &sink);
  }
  sink.end_object();
}
Example #18
0
void Mouse::serialize(serializer& s) {
  Processor::serialize(s);
  //Save block.
  unsigned char block[Controller::SaveSize] = {0};
  block[0] = latched ? 1 : 0;
  block[1] = counter;
  block[2] = (unsigned short)position_x >> 8;
  block[3] = (unsigned short)position_x;
  block[4] = (unsigned short)position_y >> 8;
  block[5] = (unsigned short)position_y;
  s.array(block, Controller::SaveSize);
  if(s.mode() == nall::serializer::Load) {
    latched = (block[0] != 0);
    counter = block[1];
    position_x = (short)(((unsigned short)block[2] << 8) | (unsigned short)block[3]);
    position_y = (short)(((unsigned short)block[4] << 8) | (unsigned short)block[5]);
  }
}
Example #19
0
void serialize(serializer &s, const std::string &key, const autocorr_result<T> &self)
{
    internal::check_valid(self);
    internal::serializer_sentry group(s, key);

    // Write size and nlevel as 64-bit integers for consistency
    serialize(s, "@size", static_cast<uint64_t>(self.size()));
    serialize(s, "@nlevel", static_cast<uint64_t>(self.nlevel()));

    s.enter("level");
    for (size_t i = 0; i != self.nlevel(); ++i)
        serialize(s, std::to_string(i), self.level_[i]);
    s.exit();

    s.enter("mean");
    serialize(s, "value", self.mean());
    serialize(s, "error", self.stderror());
    s.exit();
}
Example #20
0
void ArmDSP::serialize(serializer &s) {
  ARM::serialize(s);
  Thread::serialize(s);

  s.array(programRAM, 16 * 1024);

  s.integer(bridge.cputoarm.ready);
  s.integer(bridge.cputoarm.data);
  s.integer(bridge.armtocpu.ready);
  s.integer(bridge.armtocpu.data);
  s.integer(bridge.timer);
  s.integer(bridge.timerlatch);
  s.integer(bridge.reset);
  s.integer(bridge.ready);
  s.integer(bridge.signal);
}
Example #21
0
typename std::enable_if<
  std::is_same<
    void,
    decltype(std::declval<serializer&>().apply(std::declval<T&>()))
  >::value,
  serializer&
>::type
operator<<(serializer& sink, T& x) {
  sink.apply(x);
  return sink;
}
Example #22
0
typename std::enable_if<
  std::is_same<
    void,
    decltype(std::declval<serializer&>().apply(std::declval<T&>()))
  >::value,
  serializer&
>::type
operator<<(serializer& sink, const T& x) {
  // implementations are required to not change an object while serializing
  sink.apply(const_cast<T&>(x));
  return sink;
}
void FragSpectrumScanDatabaseBoostdb::print(serializer & ser) 
{

  mapdb::const_iterator it;
  for (it = bdb->begin(); it != bdb->end(); it++) 
  {
    std::istringstream istr (it->second);
    binary_iarchive ia (istr);
    xml_schema::istream<binary_iarchive> is (ia);
    std::auto_ptr< ::percolatorInNs::fragSpectrumScan> fss (new ::percolatorInNs::fragSpectrumScan (is));
    ser.next ( PERCOLATOR_IN_NAMESPACE, "fragSpectrumScan", *fss);
  }

}
Example #24
0
void serialize(serializer &s) {
  s.integer(prg_bank);
  s.integer(irq_mode);
  s.integer(irq_enable);
  s.integer(irq_acknowledge);
  s.integer(irq_latch);
  s.integer(irq_counter.w);
  s.integer(irq_line);
}
Example #25
0
void
SerializerImpl::setSerializationParameters(
  serializer&   aInternalSerializer,
  ItemSequence* aSerializerOptions)
{
  Item lItem;
  Iterator_t  ser_iter = aSerializerOptions->getIterator();
  ser_iter->open();
  while (ser_iter->next(lItem)) {
    Item lNodeName;
    lItem.getNodeName(lNodeName);
    aInternalSerializer.setParameter(lNodeName.getLocalName().c_str(), lItem.getStringValue().c_str());
  }
  ser_iter->close();
}
Example #26
0
        void GenericCommunicator::recv_msg_callback( serializer & ser, int sender )
        {
            // ITAC logging:
            VT_RECV( sender, (int)ser.get_total_size(), ITC_TAG_EXTERNAL );

            // Prepare the serializer for unpacking:
            //BufferAccess::initUnpack( ser );

            // Delegate the message to the distributor:
            /*            int globalSenderId = sender + m_globalIdShift; uncomment this for the local tests */
            {
                VT_FUNC( "Dist::distributor::recv_msg" );
                distributor::recv_msg( &ser/*, globalSenderId uncomment this for the local tests */ );
            }
        }
Example #27
0
void SPC7110::Decomp::serialize(serializer &s) {
  s.integer(decomp_mode);
  s.integer(decomp_offset);

  s.array(decomp_buffer, decomp_buffer_size);
  s.integer(decomp_buffer_rdoffset);
  s.integer(decomp_buffer_wroffset);
  s.integer(decomp_buffer_length);

  for(unsigned n = 0; n < 32; n++) {
    s.integer(context[n].index);
    s.integer(context[n].invert);
  }
}
Example #28
0
void PPUcounter::serialize(serializer &s) {
  s.integer(status.interlace);
  s.integer(status.field);
  s.integer(status.vcounter);
  s.integer(status.hcounter);

  s.array(history.field);
  s.array(history.vcounter);
  s.array(history.hcounter);
  s.integer(history.index);
}
Example #29
0
void HSU1::serialize(serializer& s) {
  s.integer(txbusy);
  s.integer(rxbusy);
  s.integer(txlatch);

  unsigned size;

  size = txbuffer.size();
  s.integer(size);
  txbuffer.resize(size);
  s.array(txbuffer.data(), txbuffer.size());

  size = rxbuffer.size();
  s.integer(size);
  rxbuffer.resize(size);
  s.array(rxbuffer.data(), rxbuffer.size());
}
Example #30
0
void serialize(serializer &s) {
  Board::serialize(s);

  s.integer(mmu_port);
  s.integer(apu_port);

  s.array(prg_bank);
  s.array(chr_bank);
  s.integer(mirror);
  s.integer(irq_enable);
  s.integer(irq_counter_enable);
  s.integer(irq_counter);

  pulse[0].serialize(s);
  pulse[1].serialize(s);
  pulse[2].serialize(s);
}