void TablePage::on_publishButton_clicked()
{
  std::cout << "on_publishButton_clicked()" << std::endl;
    const std::shared_ptr<OpenDynamicData> sample = m_tableModel->commitSample();
    const DDS::DynamicData_var dynamicSample = m_tableModel->commitDynamicSample();
    if (dynamicSample) {
      std::cout << "Detected dynamicSample, attempting to publish" << std::endl;
      m_topicReplayer->publishSample(dynamicSample);
      revertButton->setEnabled(false);
    } else if (sample) {
      std::cout << "Detected NON-dynamic sample, attempting to publish" << std::endl;
      m_topicReplayer->publishSample(sample);
      revertButton->setEnabled(false);
    }
}

const DDS::DynamicData_var TopicTableModel::commitDynamicSample()
{
  // Reset the edited state
  for (size_t i = 0; i < m_data.size(); i++)
  {
    m_data.at(i)->edited = false;
  }

  // Create a new sample
  std::shared_ptr<TopicInfo> topicInfo = CommonData::getTopicInfo(m_topicName);
  if (!topicInfo || topicInfo->typeCode)
  {
    return nullptr;
  }

  // Create a copy of the current sample
  DDS::DynamicData_var newDynamicSample = m_dynamicsample->clone();
//  DDS::DynamicData_var newDynamicSample = m_dynamicsample;
  if(!newDynamicSample) {
    std::cout << "CLONE BAD" << std::endl;
  }

  // Populate the new sample from the user-edited changes
  for (size_t i = 0; i < m_data.size(); i++)
  {
    populateSample(newDynamicSample, m_data.at(i));
  }

  // Replace and delete the old sample
  setSample(newDynamicSample);
  return newDynamicSample;
}

bool TopicTableModel::populateSample(DDS::DynamicData_var memberData,
                                     DataRow* const dataInfo)
{
  bool pass = false;
  if (!memberData || !dataInfo)
  {
    return false;
  }

  const QString memberName = dataInfo->name.toUtf8().data();
  DDS::MemberId memberId = CommonData::getNestedMemberAndIdByFullName(memberData, memberName);//Custom function - seems to work, can share - it also updates memberData to be the final level of a complex member
  OpenDDS::XTypes::TypeKind tk = CommonData::getMemberTypeKindById(memberData, memberId);//Custom function - seems to work, can share
  std::cout << "tk: " << OpenDDS::XTypes::typekind_to_string(tk) << std::endl;
  if (!memberData)
  {
    std::cerr << "TopicTableModel::populateSample: "
              << "Unable to find member named "
              << memberName.toStdString()
              << std::endl;

    return false;
  }

  DDS::ReturnCode_t rc = DDS::RETCODE_INCONSISTENT_POLICY; //temporary, not actual error
  std::cout << "memberId: " << memberId << std::endl;
  switch (dataInfo->type)
  {
    case CORBA::tk_long:
    {
      int32_t tmpValue = dataInfo->value.toInt(&pass);
      if (pass)
      {
        rc = memberData->set_int32_value(memberId, tmpValue);
      }
      std::cout << dataInfo->type << " " << tmpValue << std::endl;
      break;
    }
    case CORBA::tk_short:
    {
      CORBA::Int16 tmpValue = dataInfo->value.toInt(&pass);
      short temp = 33;
      memberData->get_int16_value(temp, memberId);
      std::cout << "before: " << temp << std::endl;
      if (pass)
      {
        rc = memberData->set_int16_value(memberId, tmpValue);
        memberData->get_int16_value(temp, memberId);
        std::cout << "mid: " << temp << std::endl;
      }
      std::cout << dataInfo->type << " " << tmpValue << std::endl;
      break;
    }
///All the other switch cases exist here but they're all giving the same error so I've omitted them to shorten this comment
    default:
      std::cerr << "TopicTableModel::populateSample "
                << "Skipped "
                << memberName.toStdString()
                << std::endl;
      break;

  } // End child type switch
  std::cout << "Return code: " << rc << std::endl;
  return pass;

} // End TopicTableModel::populateSample

TopicReplayer::TopicReplayer(const QString& topicName) :
                             m_topicName(topicName),
                             m_typeCode(nullptr),
                             m_topic(nullptr),
                             m_replayer(nullptr)
{
    // Make sure we have an information object for this topic
    std::shared_ptr<TopicInfo> topicInfo = CommonData::getTopicInfo(topicName);
    if (topicInfo == nullptr)
    {
        std::cerr << "Unable to find topic information for "
                  << topicName.toStdString()
                  << std::endl;
        return;
    }

    //store extensibility
    m_extensibility = topicInfo->extensibility;

    OpenDDS::DCPS::Service_Participant* service = TheServiceParticipant;
    DDS::DomainParticipant* domainParticipant = CommonData::m_ddsManager->getDomainParticipant();

  if (topicInfo->typeCode) {
    // Existing code, but now only running if non-dynamic data
    m_typeCode = topicInfo->typeCode;
    m_topic = service->create_typeless_topic(domainParticipant,
        topicInfo->name.c_str(),
        topicInfo->typeName.c_str(),
        topicInfo->hasKey,
        topicInfo->topicQos,
        new GenericTopicListener,
        DDS::INCONSISTENT_TOPIC_STATUS);

    if (!m_topic)
    {
        std::cerr << "Failed to create typeless topic" << std::endl;
        return;
    }

    m_replayer = service->create_replayer(
        domainParticipant,
        m_topic,
        topicInfo->pubQos,
        topicInfo->writerQos,
        OpenDDS::DCPS::RcHandle<OpenDDS::DCPS::ReplayerListener>()
    );

    if (!m_replayer)
    {
        std::cerr << "Failed to created replayer" << std::endl;
        return;
    }
  } else {
    // Use DynamicDataWriter instead.

    m_topic = domainParticipant->create_topic(topicInfo->name.c_str(),
                                              topicInfo->typeName.c_str(),
                                              topicInfo->topicQos,
                                              0,
                                              0);
    if (!m_topic) {
      std::cerr << "Failed to create topic " << topicInfo->name << " in topic REPLAYER!!" << std::endl;
      return;
    }

    DDS::Publisher_var publisher = domainParticipant->create_publisher(topicInfo->pubQos,0,
                                                                       0);
    if (!publisher) {
      std::cerr << "Failed to create publisher for topic " << topicInfo->name << std::endl;
      return;
    }

    m_dw = publisher->create_datawriter(m_topic,
                                        topicInfo->writerQos,
                                        DDS::DataWriterListener::_nil(),
                                        OpenDDS::DCPS::DEFAULT_STATUS_MASK);
    if (!m_dw) {
      std::cerr << "Failed to create data writer for topic " << topicInfo->name << std::endl;
      return;
    }
  }
} // End TopicReplayer::TopicReplayer

void TopicReplayer::publishSample(const DDS::DynamicData_var sample)
{
  DDS::DynamicDataWriter_var w = DDS::DynamicDataWriter::_narrow(m_dw);
  if (!w) {
    std::cerr << "DataWriter narrowing failed, m_dw is invalid" << std::endl;
    return;
  }
  DDS::ReturnCode_t response = w->write(sample, DDS::HANDLE_NIL);
  if (response != DDS::RETCODE_OK) {

    std::cout << "write() failed; response: " << response << std::endl;
  }
}